format code

.gitignore

@@ -1,105 +1,105 @@
-# If you prefer the allow list template instead of the deny list, see community template:
-# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
-#
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-
-# Go workspace file
-go.work
-
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
-# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
-
-.idea
-
-# User-specific stuff
-.idea/**/workspace.xml
-.idea/**/tasks.xml
-.idea/**/usage.statistics.xml
-.idea/**/dictionaries
-.idea/**/shelf
-
-# AWS User-specific
-.idea/**/aws.xml
-
-# Generated files
-.idea/**/contentModel.xml
-
-# Sensitive or high-churn files
-.idea/**/dataSources/
-.idea/**/dataSources.ids
-.idea/**/dataSources.local.xml
-.idea/**/sqlDataSources.xml
-.idea/**/dynamic.xml
-.idea/**/uiDesigner.xml
-.idea/**/dbnavigator.xml
-
-# Gradle
-.idea/**/gradle.xml
-.idea/**/libraries
-
-# Gradle and Maven with auto-import
-# When using Gradle or Maven with auto-import, you should exclude module files,
-# since they will be recreated, and may cause churn.  Uncomment if using
-# auto-import.
-.idea/artifacts
-.idea/compiler.xml
-.idea/jarRepositories.xml
-.idea/modules.xml
-.idea/*.iml
-.idea/modules
-*.iml
-*.ipr
-
-# CMake
-cmake-build-*/
-
-# Mongo Explorer plugin
-.idea/**/mongoSettings.xml
-
-# File-based project format
-*.iws
-
-# IntelliJ
-out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Cursive Clojure plugin
-.idea/replstate.xml
-
-# SonarLint plugin
-.idea/sonarlint/
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-fabric.properties
-
-# Editor-based Rest Client
-.idea/httpRequests
-
-# Android studio 3.1+ serialized cache file
-.idea/caches/build_file_checksums.ser
-
-*.log
-
-/config.yml
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+.idea
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+.idea/artifacts
+.idea/compiler.xml
+.idea/jarRepositories.xml
+.idea/modules.xml
+.idea/*.iml
+.idea/modules
+*.iml
+*.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+*.log
+
+/config.yml

README.md

@@ -1,32 +1,32 @@
-# Lavos
-
-算法设计与分析例题/作业代码合集，使用go编写实现
-
-## 目录结构
-
-包代码目录格式为，`cap{x}`，对应的是第x章的例题和作业代码，其中每个例题/作业代码文件均命名为`ex{x}.go`以及`work{x}.go`。
-
-如第三章例6，位于`cap3/ex6.go`中，第四章作业5，位于`cap4/ex5.go`中。
-
-## 运行/测试
-
-要运行测试，需要go开发环境。[Go installation instructions: https://go.dev/doc/install](https://go.dev/doc/install)
-
-完成后，运行
-```shell
-go test lavos/cap3
-```
-
-即可运行该章节下所有的例题和作业的test用例，例题和作业的test代码位于`example_test.go`和`work_test.go`中。
-
-如果需要单独测试某一个题目，运行
-```shell
-go test lavos/cap3 -v '-test.run' 'Ex6$'
-go test lavos/cap3 -v '-test.run' 'Work1$'
-```
-即可运行对应的题目，如示例中将会运行第三章例题6的test和作业1
-
-## 其他细节
-
-由于习惯原因，我并不是很喜欢在算法代码中进行具体的输出操作，或者直接将输出输入放置于算法代码中，而是使用了类似于leetcode中的核心代码模式，因此`ex{x}.go`和`work{x}.go`中的代码模式均为核心代码，不负责输出输入，
+# Lavos
+
+算法设计与分析例题/作业代码合集，使用go编写实现
+
+## 目录结构
+
+包代码目录格式为，`cap{x}`，对应的是第x章的例题和作业代码，其中每个例题/作业代码文件均命名为`ex{x}.go`以及`work{x}.go`。
+
+如第三章例6，位于`cap3/ex6.go`中，第四章作业5，位于`cap4/ex5.go`中。
+
+## 运行/测试
+
+要运行测试，需要go开发环境。[Go installation instructions: https://go.dev/doc/install](https://go.dev/doc/install)
+
+完成后，运行
+```shell
+go test lavos/cap3
+```
+
+即可运行该章节下所有的例题和作业的test用例，例题和作业的test代码位于`example_test.go`和`work_test.go`中。
+
+如果需要单独测试某一个题目，运行
+```shell
+go test lavos/cap3 -v '-test.run' 'Ex6$'
+go test lavos/cap3 -v '-test.run' 'Work1$'
+```
+即可运行对应的题目，如示例中将会运行第三章例题6的test和作业1
+
+## 其他细节
+
+由于习惯原因，我并不是很喜欢在算法代码中进行具体的输出操作，或者直接将输出输入放置于算法代码中，而是使用了类似于leetcode中的核心代码模式，因此`ex{x}.go`和`work{x}.go`中的代码模式均为核心代码，不负责输出输入，
 如有需要输出的算法，通过callback实现，传入能够实现输出的callback函数，在核心中调用callback来实现输出，核心代码不关心也不区负责输出输入，输出输入由test负责实现。

cap3/ex10.go

@@ -2,28 +2,28 @@ package cap3
 
 // Ex10 从0~n的整数中取r个不同的数做一组，求所有可能的组合
 func Ex10(n, r int, callback func(nums []int)) int {
-    if r > n {
-        return 0
-    }
+	if r > n {
+		return 0
+	}
 
-    count := 0
-    combine := make([]int, r)
+	count := 0
+	combine := make([]int, r)
 
-    var findCombine func(m, k int)
-    findCombine = func(n, k int) {
-        // 从n开始往下遍历组合
-        for i := n; i >= k; i-- {
-            combine[k-1] = i
-            if k > 1 {
-                // k-1和n-1，继续深入遍历，处理子问题
-                findCombine(i-1, k-1)
-            } else {
-                count++
-                callback(combine)
-            }
-        }
-    }
+	var findCombine func(m, k int)
+	findCombine = func(n, k int) {
+		// 从n开始往下遍历组合
+		for i := n; i >= k; i-- {
+			combine[k-1] = i
+			if k > 1 {
+				// k-1和n-1，继续深入遍历，处理子问题
+				findCombine(i-1, k-1)
+			} else {
+				count++
+				callback(combine)
+			}
+		}
+	}
 
-    findCombine(n, r)
-    return count
+	findCombine(n, r)
+	return count
 }

cap3/ex11.go

@@ -5,19 +5,19 @@ type Vote int      // 票数
 
 // Ex11 投票统计，有调整，这里不使用数组存储结果，使用hashmap表存结果
 func Ex11(votes []Candidate, numOfCandidate int) map[Candidate]Vote {
-    result := map[Candidate]Vote{}
-    for _, candidate := range votes {
-        // 无效的投票
-        if candidate <= 0 || int(candidate) > numOfCandidate {
-            continue
-        }
+	result := map[Candidate]Vote{}
+	for _, candidate := range votes {
+		// 无效的投票
+		if candidate <= 0 || int(candidate) > numOfCandidate {
+			continue
+		}
 
-        if _, exists := result[candidate]; !exists {
-            result[candidate] = 1
-        } else {
-            result[candidate]++
-        }
-    }
+		if _, exists := result[candidate]; !exists {
+			result[candidate] = 1
+		} else {
+			result[candidate]++
+		}
+	}
 
-    return result
+	return result
 }

cap3/ex12.go

@@ -4,18 +4,18 @@ type HeightGrade int
 
 // Ex12 身高统计，这里也是用的hashmap存结果
 func Ex12(heights []int) []int {
-    result := make([]int, 8)
-    for _, height := range heights {
-        // 身高映射，上下限调整
-        mapping := height/5 - 29
-        if mapping < 0 {
-            mapping = 0
-        } else if mapping > 7 {
-            mapping = 7
-        }
+	result := make([]int, 8)
+	for _, height := range heights {
+		// 身高映射，上下限调整
+		mapping := height/5 - 29
+		if mapping < 0 {
+			mapping = 0
+		} else if mapping > 7 {
+			mapping = 7
+		}
 
-        result[mapping]++
-    }
+		result[mapping]++
+	}
 
-    return result
+	return result
 }

cap3/ex13.go

@@ -4,23 +4,23 @@ type Subject int
 type Student int
 
 func Ex14(subjectPassedStudentMap map[Subject]Student) []Student {
-    result := make([]Student, 0)
+	result := make([]Student, 0)
 
-    // 学生及格科目数记录
-    studentRecord := map[Student]int{}
-    for _, student := range subjectPassedStudentMap {
-        // 对当前学生及格科目计数
-        if _, exists := studentRecord[student]; !exists {
-            studentRecord[student] = 1
-        } else {
-            studentRecord[student]++
-        }
+	// 学生及格科目数记录
+	studentRecord := map[Student]int{}
+	for _, student := range subjectPassedStudentMap {
+		// 对当前学生及格科目计数
+		if _, exists := studentRecord[student]; !exists {
+			studentRecord[student] = 1
+		} else {
+			studentRecord[student]++
+		}
 
-        // 学生及格科目数已达到传入的科目数，即为全科及格
-        if studentRecord[student] == len(subjectPassedStudentMap) {
-            result = append(result, student)
-        }
-    }
+		// 学生及格科目数已达到传入的科目数，即为全科及格
+		if studentRecord[student] == len(subjectPassedStudentMap) {
+			result = append(result, student)
+		}
+	}
 
-    return result
+	return result
 }

cap3/ex14.go

@@ -1,25 +1,25 @@
 package cap3
 
 var _numberTexts = []string{
-    "zero", "one", "two", "three", "four",
-    "five", "six", "seven", "eight", "nine",
+	"zero", "one", "two", "three", "four",
+	"five", "six", "seven", "eight", "nine",
 }
 
 // Ex14NumInput 输入数字，输出英文
 func Ex14NumInput(num uint64, callback func(str string)) {
-    digits := make([]uint8, 0, 20)
-    for i := num; i >= 1; i /= 10 {
-        digits = append(digits, uint8(i%10))
-    }
+	digits := make([]uint8, 0, 20)
+	for i := num; i >= 1; i /= 10 {
+		digits = append(digits, uint8(i%10))
+	}
 
-    for i := len(digits) - 1; i >= 0; i-- {
-        callback(_numberTexts[digits[i]])
-    }
+	for i := len(digits) - 1; i >= 0; i-- {
+		callback(_numberTexts[digits[i]])
+	}
 }
 
 // Ex14StrInput 输入数字字符串，输出英文
 func Ex14StrInput(num string, callback func(str string)) {
-    for _, char := range num {
-        callback(_numberTexts[char-48])
-    }
+	for _, char := range num {
+		callback(_numberTexts[char-48])
+	}
 }

cap3/ex15.go

@@ -1,24 +1,24 @@
 package cap3
 
 var (
-    cashes = []int{50, 20, 10, 5, 2, 1}
+	cashes = []int{50, 20, 10, 5, 2, 1}
 )
 
 // Ex15 最少的纸币找零钱
 func Ex15(amount, paid int) map[int]int {
-    result := map[int]int{}
+	result := map[int]int{}
 
-    // 还要找的钱
-    change := paid - amount
-    for i, cash := range cashes {
-        // 当前面额需要找的张数，整除后结果为0说明当前面额不足以找零
-        cashNum := change / cash
-        if cashNum != 0 {
-            result[i] = cashNum
-            // 当前面额找完后更新剩余未找余额
-            change = change - cashNum*cash
-        }
-    }
+	// 还要找的钱
+	change := paid - amount
+	for i, cash := range cashes {
+		// 当前面额需要找的张数，整除后结果为0说明当前面额不足以找零
+		cashNum := change / cash
+		if cashNum != 0 {
+			result[i] = cashNum
+			// 当前面额找完后更新剩余未找余额
+			change = change - cashNum*cash
+		}
+	}
 
-    return result
+	return result
 }

cap3/ex16.go

@@ -3,20 +3,20 @@ package cap3
 // Ex16 求x，其平方为一个各位数字互不相同的九位数
 func Ex16(callback func(x, x2 int)) {
 Next:
-    for x := 10000; x < 32000; x++ {
-        numCntMap := map[int]bool{}
+	for x := 10000; x < 32000; x++ {
+		numCntMap := map[int]bool{}
 
-        x2 := x * x
-        for i := x2; i >= 1; i /= 10 {
-            digit := i % 10
-            // 当前数字已经出现过，直接跳过，找下一个x，如果没出现过，则做标记后看下一位数字情况
-            if _, exists := numCntMap[digit]; exists {
-                continue Next
-            }
+		x2 := x * x
+		for i := x2; i >= 1; i /= 10 {
+			digit := i % 10
+			// 当前数字已经出现过，直接跳过，找下一个x，如果没出现过，则做标记后看下一位数字情况
+			if _, exists := numCntMap[digit]; exists {
+				continue Next
+			}
 
-            numCntMap[digit] = true
-        }
+			numCntMap[digit] = true
+		}
 
-        callback(x, x2)
-    }
+		callback(x, x2)
+	}
 }

cap3/ex17.go

@@ -2,52 +2,52 @@ package cap3
 
 // _node 链表节点，单向循环链表
 type _node struct {
-    Value int
-    Next  *_node
+	Value int
+	Next  *_node
 }
 
 // 初始化长度为n的环
 func _initCircle(n int) *_node {
-    head := &_node{0, nil}
-    current := head
-    for i := 1; i < n; i++ {
-        newNode := &_node{i, nil}
-        current.Next = newNode
-        current = newNode
-    }
-
-    // 头尾相连成环
-    current.Next = head
-    return head
+	head := &_node{0, nil}
+	current := head
+	for i := 1; i < n; i++ {
+		newNode := &_node{i, nil}
+		current.Next = newNode
+		current = newNode
+	}
+
+	// 头尾相连成环
+	current.Next = head
+	return head
 }
 
 // Ex17Normal 小朋友游戏(约瑟夫问题)，一般解法（非数学解法），n: 总人数（节点数），k：出队报数
 func Ex17Normal(n, k int) int {
-    circle := _initCircle(n)
-    current := circle
-    for current.Next != current {
-        for i := 1; i < k-1; i++ {
-            current = current.Next
-        }
-
-        // 报到k-1时移除下一个节点
-        next := current.Next
-        current.Next = next.Next
-        current = current.Next
-
-        // 避免内存泄露
-        next.Next = nil
-    }
-
-    return current.Value
+	circle := _initCircle(n)
+	current := circle
+	for current.Next != current {
+		for i := 1; i < k-1; i++ {
+			current = current.Next
+		}
+
+		// 报到k-1时移除下一个节点
+		next := current.Next
+		current.Next = next.Next
+		current = current.Next
+
+		// 避免内存泄露
+		next.Next = nil
+	}
+
+	return current.Value
 }
 
 // Ex17Math 小朋友游戏(约瑟夫问题)，公式递推解法，n: 总人数（节点数），k：出队报数
 func Ex17Math(n, k int) int {
-    idx := 0
-    for i := 2; i <= n; i++ {
-        idx = (idx + k) % i
-    }
+	idx := 0
+	for i := 2; i <= n; i++ {
+		idx = (idx + k) % i
+	}
 
-    return idx
+	return idx
 }

cap3/ex18.go

@@ -1,107 +1,107 @@
 package cap3
 
 import (
-    "strings"
+	"strings"
 )
 
 // Ex18 超长整数乘法（都超长）
 func Ex18(a, b string) string {
-    result := make([]uint8, len(a)+len(b))
-    resultEndIdx := len(result) - 1
-    for i := 0; i < len(b); i++ {
-        carry := uint8(0)
-        aEnd, bEnd, resultIdx := len(a)-1, len(b)-1, 0
-        bDigit := b[bEnd-i] - 48
-        for j := 0; j < len(a); j++ {
-            // 字符转数字
-            aDigit := a[aEnd-j] - 48
-            // 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
-            resultIdx = resultEndIdx - (i + j)
-            num := result[resultIdx] + aDigit*bDigit + carry
-            // 当前位为计算结果的个位，进位为十位上的数字
-            result[resultIdx] = num % 10
-            carry = num / 10
-        }
+	result := make([]uint8, len(a)+len(b))
+	resultEndIdx := len(result) - 1
+	for i := 0; i < len(b); i++ {
+		carry := uint8(0)
+		aEnd, bEnd, resultIdx := len(a)-1, len(b)-1, 0
+		bDigit := b[bEnd-i] - 48
+		for j := 0; j < len(a); j++ {
+			// 字符转数字
+			aDigit := a[aEnd-j] - 48
+			// 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
+			resultIdx = resultEndIdx - (i + j)
+			num := result[resultIdx] + aDigit*bDigit + carry
+			// 当前位为计算结果的个位，进位为十位上的数字
+			result[resultIdx] = num % 10
+			carry = num / 10
+		}
 
-        // 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
-        if carry != 0 {
-            resultIdx--
-            result[resultIdx] += carry
-        }
-    }
+		// 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
+		if carry != 0 {
+			resultIdx--
+			result[resultIdx] += carry
+		}
+	}
 
-    zeroPrefix := true
-    sb := strings.Builder{}
-    for _, num := range result {
-        if zeroPrefix && num == 0 {
-            continue
-        } else {
-            zeroPrefix = false
-        }
+	zeroPrefix := true
+	sb := strings.Builder{}
+	for _, num := range result {
+		if zeroPrefix && num == 0 {
+			continue
+		} else {
+			zeroPrefix = false
+		}
 
-        sb.WriteByte(num + 48)
-    }
+		sb.WriteByte(num + 48)
+	}
 
-    return sb.String()
+	return sb.String()
 }
 
 // Ex18type2 超长整数乘法（都超长），a和b都是大端序的数字数组/切片
 func Ex18type2(a, b []uint8) []uint8 {
-    result := make([]uint8, len(a)+len(b))
-    resultEndIdx := len(result) - 1
-    for i := 0; i < len(b); i++ {
-        carry := uint8(0)
-        aEnd, bEnd, resultIdx := len(a)-1, len(b)-1, 0
-        bDigit := b[bEnd-i]
-        for j := 0; j < len(a); j++ {
-            // 字符转数字
-            aDigit := a[aEnd-j]
-            // 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
-            resultIdx = resultEndIdx - (i + j)
-            num := result[resultIdx] + aDigit*bDigit + carry
-            // 当前位为计算结果的个位，进位为十位上的数字
-            result[resultIdx] = num % 10
-            carry = num / 10
-        }
+	result := make([]uint8, len(a)+len(b))
+	resultEndIdx := len(result) - 1
+	for i := 0; i < len(b); i++ {
+		carry := uint8(0)
+		aEnd, bEnd, resultIdx := len(a)-1, len(b)-1, 0
+		bDigit := b[bEnd-i]
+		for j := 0; j < len(a); j++ {
+			// 字符转数字
+			aDigit := a[aEnd-j]
+			// 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
+			resultIdx = resultEndIdx - (i + j)
+			num := result[resultIdx] + aDigit*bDigit + carry
+			// 当前位为计算结果的个位，进位为十位上的数字
+			result[resultIdx] = num % 10
+			carry = num / 10
+		}
 
-        // 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
-        if carry != 0 {
-            resultIdx--
-            result[resultIdx] += carry
-        }
-    }
+		// 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
+		if carry != 0 {
+			resultIdx--
+			result[resultIdx] += carry
+		}
+	}
 
-    return result
+	return result
 }
 
 // Ex18type3 超长整数乘法（都超长），a是大端序的数字数组/切片，b为uint64
 func Ex18type3(a []uint8, b uint64) []uint8 {
-    result := make([]uint8, len(a)+22)
-    resultEndIdx := len(result) - 1
-    bOffset := 0
-    for i := b; i >= 1; i /= 10 {
-        carry := uint8(0)
-        bDigit := uint8(i % 10)
-        aEnd, resultIdx := len(a)-1, 0
-        for j := 0; j < len(a); j++ {
-            // 字符转数字
-            aDigit := a[aEnd-j]
-            // 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
-            resultIdx = resultEndIdx - (bOffset + j)
-            num := result[resultIdx] + aDigit*bDigit + carry
-            // 当前位为计算结果的个位，进位为十位上的数字
-            result[resultIdx] = num % 10
-            carry = num / 10
-        }
+	result := make([]uint8, len(a)+22)
+	resultEndIdx := len(result) - 1
+	bOffset := 0
+	for i := b; i >= 1; i /= 10 {
+		carry := uint8(0)
+		bDigit := uint8(i % 10)
+		aEnd, resultIdx := len(a)-1, 0
+		for j := 0; j < len(a); j++ {
+			// 字符转数字
+			aDigit := a[aEnd-j]
+			// 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
+			resultIdx = resultEndIdx - (bOffset + j)
+			num := result[resultIdx] + aDigit*bDigit + carry
+			// 当前位为计算结果的个位，进位为十位上的数字
+			result[resultIdx] = num % 10
+			carry = num / 10
+		}
 
-        // 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
-        if carry != 0 {
-            resultIdx--
-            result[resultIdx] += carry
-        }
+		// 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
+		if carry != 0 {
+			resultIdx--
+			result[resultIdx] += carry
+		}
 
-        bOffset++
-    }
+		bOffset++
+	}
 
-    return result
+	return result
 }

cap3/ex19.go

@@ -4,134 +4,134 @@ import "strings"
 
 // Ex19 高精度阶乘
 func Ex19(n uint64) string {
-    result := []uint8{1}
-    for i := uint64(2); i <= n; i++ {
-        result = multiply(result, i)
-    }
+	result := []uint8{1}
+	for i := uint64(2); i <= n; i++ {
+		result = multiply(result, i)
+	}
 
-    return DigitSlice2String(result)
+	return DigitSlice2String(result)
 }
 
 func multiply(a []uint8, b uint64) []uint8 {
-    result := make([]uint8, len(a)+22)
-    resultEndIdx := len(result) - 1
-    bOffset := 0
-    for i := b; i >= 1; i /= 10 {
-        carry := uint8(0)
-        bDigit := uint8(i % 10)
-        aEnd, resultIdx := len(a)-1, 0
-        for j := 0; j < len(a); j++ {
-            // 字符转数字
-            aDigit := a[aEnd-j]
-            // 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
-            resultIdx = resultEndIdx - (bOffset + j)
-            num := result[resultIdx] + aDigit*bDigit + carry
-            // 当前位为计算结果的个位，进位为十位上的数字
-            result[resultIdx] = num % 10
-            carry = num / 10
-        }
-
-        // 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
-        if carry != 0 {
-            resultIdx--
-            result[resultIdx] += carry
-        }
-
-        bOffset++
-    }
-
-    return result
+	result := make([]uint8, len(a)+22)
+	resultEndIdx := len(result) - 1
+	bOffset := 0
+	for i := b; i >= 1; i /= 10 {
+		carry := uint8(0)
+		bDigit := uint8(i % 10)
+		aEnd, resultIdx := len(a)-1, 0
+		for j := 0; j < len(a); j++ {
+			// 字符转数字
+			aDigit := a[aEnd-j]
+			// 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
+			resultIdx = resultEndIdx - (bOffset + j)
+			num := result[resultIdx] + aDigit*bDigit + carry
+			// 当前位为计算结果的个位，进位为十位上的数字
+			result[resultIdx] = num % 10
+			carry = num / 10
+		}
+
+		// 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
+		if carry != 0 {
+			resultIdx--
+			result[resultIdx] += carry
+		}
+
+		bOffset++
+	}
+
+	return result
 }
 
 func multiply2(a []uint8, b uint64) []uint8 {
-    result := make([]uint8, len(a)+22)
-    resultEndIdx := len(result)*2 - 1
-    bOffset := 0
-    for i := b; i >= 1; i /= 10 {
-        carry := uint8(0)
-        bDigit := uint8(i % 10)
-        aEnd, resultIdx := len(a)*2-1, 0
-        for j := 0; j < len(a); j++ {
-            // 字符转数字
-            aDigit := uint8(0)
-            // 4,5 -> 37(0010,0101)
-            aIdx := aEnd - j
-            if aIdx%2 == 0 {
-                aDigit = a[aIdx/2] >> 4
-            } else {
-                aDigit = a[aIdx/2] & 0b00001111
-            }
-
-            // 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
-            resultIdx = resultEndIdx - (bOffset + j)
-            bitIdx := resultIdx / 2
-            if resultIdx%2 == 0 {
-                num := (result[bitIdx] >> 4) + aDigit*bDigit + carry
-                // 清位
-                // 4,5 -> 37(0010,0101) => 0,5 -> 5(0000,0101)
-                result[bitIdx] &= 0b00001111
-                // 位赋值
-                // 0,5 -> 5(0000,0101) => 5,5 -> 5(0101,0101)
-                // 5(0000,0101) << 4 => 80(0101,0000)
-                // 5(0000,0101) | 80(0101,0000) => 5,5 -> 5(0101,0101)
-                result[bitIdx] |= (num % 10) << 4
-                carry = num / 10
-            } else {
-                num := (result[bitIdx] & 0b00001111) + aDigit*bDigit + carry
-                // 清位
-                // 4,5 -> 37(0010,0101) => 4,0 -> 32(0010,0000)
-                result[bitIdx] &= 0b11110000
-                // 赋值
-                // 4,0 -> 32(0010,0000) => 4,5 -> 37(0010,0101)
-                // 32(0010,0000) | 5(0000,0101) => 4,5 -> 37(0010,0101)
-                result[bitIdx] |= num % 10
-                carry = num / 10
-            }
-        }
-
-        // 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
-        if carry != 0 {
-            resultIdx--
-            bitIdx := resultIdx / 2
-            if resultIdx%2 == 0 {
-                // 4,5 -> 37(0010,0101) => 5,5 -> 37(0101,0101)
-                // 4+1 -> 5(0000,0101) << 4 => 80(0101,0000)
-                // 5(0000,0101) | 80(0101,0000) => 5,5 -> 5(0101,0101)
-                result[bitIdx] &= 0b00001111
-                num := (result[bitIdx] >> 4) + carry
-                result[bitIdx] |= num << 4
-            } else {
-                result[bitIdx] &= 0b11110000
-                num := (result[bitIdx] & 0b00001111) + carry
-                result[bitIdx] |= num
-            }
-        }
-
-        bOffset++
-    }
-
-    return result
+	result := make([]uint8, len(a)+22)
+	resultEndIdx := len(result)*2 - 1
+	bOffset := 0
+	for i := b; i >= 1; i /= 10 {
+		carry := uint8(0)
+		bDigit := uint8(i % 10)
+		aEnd, resultIdx := len(a)*2-1, 0
+		for j := 0; j < len(a); j++ {
+			// 字符转数字
+			aDigit := uint8(0)
+			// 4,5 -> 37(0010,0101)
+			aIdx := aEnd - j
+			if aIdx%2 == 0 {
+				aDigit = a[aIdx/2] >> 4
+			} else {
+				aDigit = a[aIdx/2] & 0b00001111
+			}
+
+			// 当前位计算结果 = 当前结果 + aDigit*bDigit + 进位
+			resultIdx = resultEndIdx - (bOffset + j)
+			bitIdx := resultIdx / 2
+			if resultIdx%2 == 0 {
+				num := (result[bitIdx] >> 4) + aDigit*bDigit + carry
+				// 清位
+				// 4,5 -> 37(0010,0101) => 0,5 -> 5(0000,0101)
+				result[bitIdx] &= 0b00001111
+				// 位赋值
+				// 0,5 -> 5(0000,0101) => 5,5 -> 5(0101,0101)
+				// 5(0000,0101) << 4 => 80(0101,0000)
+				// 5(0000,0101) | 80(0101,0000) => 5,5 -> 5(0101,0101)
+				result[bitIdx] |= (num % 10) << 4
+				carry = num / 10
+			} else {
+				num := (result[bitIdx] & 0b00001111) + aDigit*bDigit + carry
+				// 清位
+				// 4,5 -> 37(0010,0101) => 4,0 -> 32(0010,0000)
+				result[bitIdx] &= 0b11110000
+				// 赋值
+				// 4,0 -> 32(0010,0000) => 4,5 -> 37(0010,0101)
+				// 32(0010,0000) | 5(0000,0101) => 4,5 -> 37(0010,0101)
+				result[bitIdx] |= num % 10
+				carry = num / 10
+			}
+		}
+
+		// 如果还有进位，则对下一个结果位添加进位，此时不会再有进位
+		if carry != 0 {
+			resultIdx--
+			bitIdx := resultIdx / 2
+			if resultIdx%2 == 0 {
+				// 4,5 -> 37(0010,0101) => 5,5 -> 37(0101,0101)
+				// 4+1 -> 5(0000,0101) << 4 => 80(0101,0000)
+				// 5(0000,0101) | 80(0101,0000) => 5,5 -> 5(0101,0101)
+				result[bitIdx] &= 0b00001111
+				num := (result[bitIdx] >> 4) + carry
+				result[bitIdx] |= num << 4
+			} else {
+				result[bitIdx] &= 0b11110000
+				num := (result[bitIdx] & 0b00001111) + carry
+				result[bitIdx] |= num
+			}
+		}
+
+		bOffset++
+	}
+
+	return result
 }
 
 // Ex19LowMem 低内存使用版，两位数字结果按位存在同一个uint8中，一个0~9数字只使用四字节，uint8可存两位，一个字节拆成两半用
 func Ex19LowMem(n uint64) string {
-    result := []uint8{1}
-    for i := uint64(2); i <= n; i++ {
-        result = multiply2(result, i)
-    }
-
-    zeroPrefix := true
-    sb := strings.Builder{}
-    for _, num := range result {
-        if zeroPrefix && num == 0 {
-            continue
-        } else {
-            zeroPrefix = false
-        }
-
-        sb.WriteByte((num >> 4) + 48)
-        sb.WriteByte((num & 0b00001111) + 48)
-    }
-
-    return sb.String()
+	result := []uint8{1}
+	for i := uint64(2); i <= n; i++ {
+		result = multiply2(result, i)
+	}
+
+	zeroPrefix := true
+	sb := strings.Builder{}
+	for _, num := range result {
+		if zeroPrefix && num == 0 {
+			continue
+		} else {
+			zeroPrefix = false
+		}
+
+		sb.WriteByte((num >> 4) + 48)
+		sb.WriteByte((num & 0b00001111) + 48)
+	}
+
+	return sb.String()
 }

cap3/ex5.go

@@ -4,66 +4,66 @@ import "lavos/common"
 
 // Ex5 例题5 汉诺塔问题，输出移动的步骤，可指定算法类型，每做出一步移动操作都将会调用callback
 func Ex5(beadNum int, algoType AlgoType, callback func(from string, to string)) {
-    switch algoType {
-    case AlgoTypeRecursion:
-        Ex5Recursive(beadNum, "A", "B", "C", callback)
-    default:
-        Ex5NonRecursive(beadNum, "A", "B", "C", callback)
-    }
+	switch algoType {
+	case AlgoTypeRecursion:
+		Ex5Recursive(beadNum, "A", "B", "C", callback)
+	default:
+		Ex5NonRecursive(beadNum, "A", "B", "C", callback)
+	}
 }
 
 func Ex5Recursive(beadNum int, a, b, c string, callback func(from string, to string)) {
-    if beadNum == 1 {
-        // 如果只有一颗珠子，直接从 A 移动到 C，结束
-        callback(a, c)
-    } else {
-        // 第二步：将所有在 N 之上的珠子（即 N-1 颗珠子）从 A 移动到 B。此时 C 是中转站
-        Ex5Recursive(beadNum-1, a, c, b, callback)
+	if beadNum == 1 {
+		// 如果只有一颗珠子，直接从 A 移动到 C，结束
+		callback(a, c)
+	} else {
+		// 第二步：将所有在 N 之上的珠子（即 N-1 颗珠子）从 A 移动到 B。此时 C 是中转站
+		Ex5Recursive(beadNum-1, a, c, b, callback)
 
-        // 第二步：将 A 的珠子移动到 C
-        callback(a, c)
+		// 第二步：将 A 的珠子移动到 C
+		callback(a, c)
 
-        // 第三步：将剩余的 N-1 颗珠子从 B 移动到 C。此时 A 是中转站
-        Ex5Recursive(beadNum-1, b, a, c, callback)
-    }
+		// 第三步：将剩余的 N-1 颗珠子从 B 移动到 C。此时 A 是中转站
+		Ex5Recursive(beadNum-1, b, a, c, callback)
+	}
 }
 
 type _step struct {
-    n                 int
-    from, transit, to string
+	n                 int
+	from, transit, to string
 }
 
 func Ex5NonRecursive(beadNum int, a, b, c string, callback func(from string, to string)) {
-    stack := common.NewStack[_step](beadNum * 5)
-    // 最终状态：a->c，b作为中转
-    stack.Push(&_step{
-        n:    beadNum,
-        from: a, transit: b, to: c,
-    })
-    for !stack.Empty() {
-        status := stack.Pop()
-        if status.n == 1 {
-            callback(status.from, status.to)
-        } else {
-            // 把子问题的三个基本步骤压入栈
-            stack.Push(&_step{
-                n:       status.n - 1,
-                from:    status.transit,
-                transit: status.from,
-                to:      status.to,
-            })
-            stack.Push(&_step{
-                n:       1,
-                from:    status.from,
-                transit: status.transit,
-                to:      status.to,
-            })
-            stack.Push(&_step{
-                n:       status.n - 1,
-                from:    status.from,
-                transit: status.to,
-                to:      status.transit,
-            })
-        }
-    }
+	stack := common.NewStack[_step](beadNum * 5)
+	// 最终状态：a->c，b作为中转
+	stack.Push(&_step{
+		n:    beadNum,
+		from: a, transit: b, to: c,
+	})
+	for !stack.Empty() {
+		status := stack.Pop()
+		if status.n == 1 {
+			callback(status.from, status.to)
+		} else {
+			// 把子问题的三个基本步骤压入栈
+			stack.Push(&_step{
+				n:       status.n - 1,
+				from:    status.transit,
+				transit: status.from,
+				to:      status.to,
+			})
+			stack.Push(&_step{
+				n:       1,
+				from:    status.from,
+				transit: status.transit,
+				to:      status.to,
+			})
+			stack.Push(&_step{
+				n:       status.n - 1,
+				from:    status.from,
+				transit: status.to,
+				to:      status.transit,
+			})
+		}
+	}
 }

cap3/ex6.go

@@ -2,102 +2,102 @@ package cap3
 
 // Ex6Output 例六的带输出结果
 func Ex6Output(num int, callback func(nums []int)) {
-    Ex6RecursionOutput(num, callback)
+	Ex6RecursionOutput(num, callback)
 }
 
 // Ex6NoneOutput 例六的不带输出结果版本，只求数量
 func Ex6NoneOutput(num int, algoType AlgoType, callback func(nums []int)) int {
-    switch algoType {
-    case AlgoTypeRecursion:
-        return Ex6Recursion(num)
-    default:
-        return Ex6NoneRecursion(num)
-    }
+	switch algoType {
+	case AlgoTypeRecursion:
+		return Ex6Recursion(num)
+	default:
+		return Ex6NoneRecursion(num)
+	}
 }
 
 // Ex6Recursion 整数划分，递归写法，只计算结果，但对算法经过调整以适合输出
 func Ex6Recursion(num int) int {
-    count := 0
-    var divider func(num, m int)
-    divider = func(num, m int) {
-        // num == 0 来源会有两种：递归中num==m，以及传入的num本身就是0，此时可以作为一个划分
-        if num == 0 {
-            count++
-            return
-        }
+	count := 0
+	var divider func(num, m int)
+	divider = func(num, m int) {
+		// num == 0 来源会有两种：递归中num==m，以及传入的num本身就是0，此时可以作为一个划分
+		if num == 0 {
+			count++
+			return
+		}
 
-        // 最大划分大小m逐级-1求划分数
-        if m > 1 {
-            divider(num, m-1)
-        }
+		// 最大划分大小m逐级-1求划分数
+		if m > 1 {
+			divider(num, m-1)
+		}
 
-        // m <= num，对剩余未加的数进行划分
-        if m <= num {
-            divider(num-m, m)
-        }
-    }
+		// m <= num，对剩余未加的数进行划分
+		if m <= num {
+			divider(num-m, m)
+		}
+	}
 
-    divider(num, num)
-    return count
+	divider(num, num)
+	return count
 }
 
 // Ex6RecursionOutput 整数划分，由上面的递归写法修改而来，可求划分情况，对算法经过调整以适合输出
 func Ex6RecursionOutput(num int, callback func(dividedNums []int)) {
-    var divider func(num, m int, dividedNums []int, callback func(dividedNums []int))
-    divider = func(num, m int, dividedNums []int, callback func(dividedNums []int)) {
-        // num==0时，当前已划分完毕，回调输出
-        if num == 0 {
-            callback(dividedNums)
-            return
-        }
+	var divider func(num, m int, dividedNums []int, callback func(dividedNums []int))
+	divider = func(num, m int, dividedNums []int, callback func(dividedNums []int)) {
+		// num==0时，当前已划分完毕，回调输出
+		if num == 0 {
+			callback(dividedNums)
+			return
+		}
 
-        // 最大划分大小m逐级-1求划分数
-        if m > 1 {
-            divider(num, m-1, dividedNums, callback)
-        }
+		// 最大划分大小m逐级-1求划分数
+		if m > 1 {
+			divider(num, m-1, dividedNums, callback)
+		}
 
-        if m <= num {
-            // m <= num，对剩余未加的数进行划分，当前的m已经是划分中的一个成员，将其添加进dividedNums中
-            divider(num-m, m, append(dividedNums, m), callback)
-        }
-    }
+		if m <= num {
+			// m <= num，对剩余未加的数进行划分，当前的m已经是划分中的一个成员，将其添加进dividedNums中
+			divider(num-m, m, append(dividedNums, m), callback)
+		}
+	}
 
-    divider(num, num, make([]int, 0, num), callback)
+	divider(num, num, make([]int, 0, num), callback)
 }
 
 // Ex6NoneRecursion 整数划分，非递归写法，由递归法改写而来，模拟递归过程
 func Ex6NoneRecursion(num int) int {
-    divider := func(num, divideMax int) int {
-        // 初始化
-        result := make([][]int, num+1)
-        for i := 0; i < num+1; i++ {
-            result[i] = make([]int, num+1)
-        }
-        for i := 1; i <= num; i++ {
-            result[0][i] = 1
-        }
+	divider := func(num, divideMax int) int {
+		// 初始化
+		result := make([][]int, num+1)
+		for i := 0; i < num+1; i++ {
+			result[i] = make([]int, num+1)
+		}
+		for i := 1; i <= num; i++ {
+			result[0][i] = 1
+		}
 
-        // i从1开始到num进行划分计算，
-        // 里层j从1开始到m（最大划分大小）开始计算子问题的划分
-        // 从1开始，自底向上计算
-        // 此处为非递归写法，当前的结果依赖上一个结果，因此需要先计算上一个结果，
-        // 因此整个问题过程需要从最小的问题开始计算
-        divideMax = min(num, divideMax)
-        for n := 1; n <= num; n++ {
-            for m := 1; m <= divideMax; m++ {
-                if n <= m {
-                    // 对应 Q(n,n) = 1 + Q(n, n-1) 的情况
-                    // n < m (n < m) 时均看作i == m (n == m)
-                    result[n][m] = 1 + result[n][n-1]
-                } else {
-                    // 对应 Q(n,m) = Q(n, m-1) + Q(n-m, m) 的情况
-                    result[n][m] = result[n][m-1] + result[n-m][m]
-                }
-            }
-        }
+		// i从1开始到num进行划分计算，
+		// 里层j从1开始到m（最大划分大小）开始计算子问题的划分
+		// 从1开始，自底向上计算
+		// 此处为非递归写法，当前的结果依赖上一个结果，因此需要先计算上一个结果，
+		// 因此整个问题过程需要从最小的问题开始计算
+		divideMax = min(num, divideMax)
+		for n := 1; n <= num; n++ {
+			for m := 1; m <= divideMax; m++ {
+				if n <= m {
+					// 对应 Q(n,n) = 1 + Q(n, n-1) 的情况
+					// n < m (n < m) 时均看作i == m (n == m)
+					result[n][m] = 1 + result[n][n-1]
+				} else {
+					// 对应 Q(n,m) = Q(n, m-1) + Q(n-m, m) 的情况
+					result[n][m] = result[n][m-1] + result[n-m][m]
+				}
+			}
+		}
 
-        return result[num][divideMax]
-    }
+		return result[num][divideMax]
+	}
 
-    return divider(num, num)
+	return divider(num, num)
 }

cap3/ex7.go

@@ -2,25 +2,25 @@ package cap3
 
 // Ex7 低位到高位输出正整数的数字
 func Ex7(num uint64, algoType AlgoType, callback func(digit uint8)) {
-    switch algoType {
-    case AlgoTypeRecursion:
-        Ex7Recursion(num, callback)
-    default:
-        Ex7NoneRecursion(num, callback)
-    }
+	switch algoType {
+	case AlgoTypeRecursion:
+		Ex7Recursion(num, callback)
+	default:
+		Ex7NoneRecursion(num, callback)
+	}
 }
 
 func Ex7Recursion(num uint64, callback func(digit uint8)) {
-    if num < 10 {
-        callback(uint8(num))
-    } else {
-        callback(uint8(num % 10))
-        Ex7Recursion(num/10, callback)
-    }
+	if num < 10 {
+		callback(uint8(num))
+	} else {
+		callback(uint8(num % 10))
+		Ex7Recursion(num/10, callback)
+	}
 }
 
 func Ex7NoneRecursion(num uint64, callback func(digit uint8)) {
-    for i := num; i >= 1; i /= 10 {
-        callback(uint8(i % 10))
-    }
+	for i := num; i >= 1; i /= 10 {
+		callback(uint8(i % 10))
+	}
 }

cap3/ex8.go

@@ -2,33 +2,33 @@ package cap3
 
 // Ex8 高位到低位输出正整数的数字
 func Ex8(num uint64, algoType AlgoType, callback func(digit uint8)) {
-    switch algoType {
-    case AlgoTypeRecursion:
-        Ex8Recursion(num, callback)
-    default:
-        Ex8NoneRecursion(num, callback)
-    }
+	switch algoType {
+	case AlgoTypeRecursion:
+		Ex8Recursion(num, callback)
+	default:
+		Ex8NoneRecursion(num, callback)
+	}
 }
 
 // Ex8Recursion 高位到低位输出正整数的数字(递归)
 func Ex8Recursion(num uint64, callback func(digit uint8)) {
-    if num < 10 {
-        callback(uint8(num))
-    } else {
-        // 跟ex7的小区别
-        Ex8Recursion(num/10, callback)
-        callback(uint8(num % 10))
-    }
+	if num < 10 {
+		callback(uint8(num))
+	} else {
+		// 跟ex7的小区别
+		Ex8Recursion(num/10, callback)
+		callback(uint8(num % 10))
+	}
 }
 
 // Ex8NoneRecursion 高位到低位输出正整数的数字(非递归)
 func Ex8NoneRecursion(num uint64, callback func(digit uint8)) {
-    digits := make([]uint8, 0, 20)
-    for i := num; i >= 1; i /= 10 {
-        digits = append(digits, uint8(i%10))
-    }
+	digits := make([]uint8, 0, 20)
+	for i := num; i >= 1; i /= 10 {
+		digits = append(digits, uint8(i%10))
+	}
 
-    for i := len(digits) - 1; i >= 0; i-- {
-        callback(digits[i])
-    }
+	for i := len(digits) - 1; i >= 0; i-- {
+		callback(digits[i])
+	}
 }

cap3/ex9.go

@@ -2,27 +2,27 @@ package cap3
 
 // Ex9t1 整数拆解为2的幂之和(返回整数的二进制bit取值情况，bit的idx对应相应的幂)
 func Ex9t1(num int) []bool {
-    // 传进来的是int，一般是32bit，这里就用64来存bit，肯定够了
-    bits := make([]bool, 0, 64)
-    for i := 0; num != 0; i++ {
-        bits = append(bits, num%2 == 1)
-        num /= 2
-    }
+	// 传进来的是int，一般是32bit，这里就用64来存bit，肯定够了
+	bits := make([]bool, 0, 64)
+	for i := 0; num != 0; i++ {
+		bits = append(bits, num%2 == 1)
+		num /= 2
+	}
 
-    return bits
+	return bits
 }
 
 // Ex9t2 整数拆解为2的幂之和(返回幂取值)
 func Ex9t2(num int) []uint8 {
-    // 传进来的是int，一般是32bit，这里就用64来存bit，肯定够了
-    bits := make([]uint8, 0, 64)
-    for i := uint8(0); num != 0; i++ {
-        if num%2 == 1 {
-            bits = append(bits, i)
-        }
+	// 传进来的是int，一般是32bit，这里就用64来存bit，肯定够了
+	bits := make([]uint8, 0, 64)
+	for i := uint8(0); num != 0; i++ {
+		if num%2 == 1 {
+			bits = append(bits, i)
+		}
 
-        num /= 2
-    }
+		num /= 2
+	}
 
-    return bits
+	return bits
 }