Add solution 1006

leetcode/1006.Clumsy-Factorial/1006. Clumsy Factorial.go

@@ -0,0 +1,27 @@
+package leetcode
+
+func clumsy(N int) int {
+	res, count, tmp, flag := 0, 1, N, true
+	for i := N - 1; i > 0; i-- {
+		count = count % 4
+		switch count {
+		case 1:
+			tmp = tmp * i
+		case 2:
+			tmp = tmp / i
+		case 3:
+			res = res + tmp
+			flag = true
+			tmp = -1
+			res = res + i
+		case 0:
+			flag = false
+			tmp = tmp * (i)
+		}
+		count++
+	}
+	if !flag {
+		res = res + tmp
+	}
+	return res
+}

leetcode/1006.Clumsy-Factorial/1006. Clumsy Factorial_test.go

@@ -0,0 +1,52 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+type question1006 struct {
+	para1006
+	ans1006
+}
+
+// para 是参数
+// one 代表第一个参数
+type para1006 struct {
+	N int
+}
+
+// ans 是答案
+// one 代表第一个答案
+type ans1006 struct {
+	one int
+}
+
+func Test_Problem1006(t *testing.T) {
+
+	qs := []question1006{
+
+		{
+			para1006{4},
+			ans1006{7},
+		},
+
+		{
+			para1006{10},
+			ans1006{12},
+		},
+
+		{
+			para1006{100},
+			ans1006{101},
+		},
+	}
+
+	fmt.Printf("------------------------Leetcode Problem 1006------------------------\n")
+
+	for _, q := range qs {
+		_, p := q.ans1006, q.para1006
+		fmt.Printf("【input】:%v       【output】:%v\n", p, clumsy(p.N))
+	}
+	fmt.Printf("\n\n\n")
+}

leetcode/1006.Clumsy-Factorial/README.md

@@ -0,0 +1,75 @@
+# [1006. Clumsy Factorial](https://leetcode.com/problems/clumsy-factorial/)
+
+
+## 题目
+
+Normally, the factorial of a positive integer `n` is the product of all positive integers less than or equal to `n`.  For example, `factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1`.
+
+We instead make a *clumsy factorial:* using the integers in decreasing order, we swap out the multiply operations for a fixed rotation of operations: multiply (*), divide (/), add (+) and subtract (-) in this order.
+
+For example, `clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1`.  However, these operations are still applied using the usual order of operations of arithmetic: we do all multiplication and division steps before any addition or subtraction steps, and multiplication and division steps are processed left to right.
+
+Additionally, the division that we use is *floor division* such that `10 * 9 / 8` equals `11`.  This guarantees the result is an integer.
+
+`Implement the clumsy` function as defined above: given an integer `N`, it returns the clumsy factorial of `N`.
+
+**Example 1:**
+
+```
+Input:4
+Output: 7
+Explanation: 7 = 4 * 3 / 2 + 1
+```
+
+**Example 2:**
+
+```
+Input:10
+Output:12
+Explanation:12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1
+```
+
+**Note:**
+
+1. `1 <= N <= 10000`
+2. `2^31 <= answer <= 2^31 - 1` (The answer is guaranteed to fit within a 32-bit integer.)
+
+## 题目大意
+
+通常，正整数 n 的阶乘是所有小于或等于 n 的正整数的乘积。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。相反，我们设计了一个笨阶乘 clumsy：在整数的递减序列中，我们以一个固定顺序的操作符序列来依次替换原有的乘法操作符：乘法(*)，除法(/)，加法(+)和减法(-)。例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，这些运算仍然使用通常的算术运算顺序：我们在任何加、减步骤之前执行所有的乘法和除法步骤，并且按从左到右处理乘法和除法步骤。另外，我们使用的除法是地板除法（floor division），所以 10 * 9 / 8 等于 11。这保证结果是一个整数。实现上面定义的笨函数：给定一个整数 N，它返回 N 的笨阶乘。
+
+## 解题思路
+
+- 按照题意，由于本题没有括号，所以先乘除后加减。4 个操作一组，先算乘法，再算除法，再算加法，最后算减法。减法也可以看成是加法，只是带负号的加法。
+
+## 代码
+
+```go
+package leetcode
+
+func clumsy(N int) int {
+	res, count, tmp, flag := 0, 1, N, true
+	for i := N - 1; i > 0; i-- {
+		count = count % 4
+		switch count {
+		case 1:
+			tmp = tmp * i
+		case 2:
+			tmp = tmp / i
+		case 3:
+			res = res + tmp
+			flag = true
+			tmp = -1
+			res = res + i
+		case 0:
+			flag = false
+			tmp = tmp * (i)
+		}
+		count++
+	}
+	if !flag {
+		res = res + tmp
+	}
+	return res
+}
+```