init commit

Author: yuanyu90221

.github/workflows/go.yml

@@ -0,0 +1,26 @@
+name: go
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Setup Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
+      - name: Build
+        run: go build -v ./...
+      - name: Test
+        run: go test -v -cover ./...
+      - name: Benchmark
+        run: go test -benchmem -run=none -bench ^BenchmarkTest$ sol/sol

.gitignore

@@ -0,0 +1,21 @@
+# 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

.gitlab-ci.yml

@@ -0,0 +1,9 @@
+stages:
+  - test
+build and test:
+  image: golang:1.16
+  stage: test
+  script:
+    - go build -v ./...
+    - go test -v -cover ./...
+    - go test -benchmem -run=none -bench ^BenchmarkTest$ sol/sol

.husky/pre-commit

@@ -0,0 +1,2 @@
+#!/bin/bash
+go test -v -cover ./...

README.md

@@ -0,0 +1,107 @@
+# golang_combination_sum
+
+Given an array of **distinct** integers `candidates` and a target integer `target`, return *a list of all **unique combinations** of* `candidates` *where the chosen numbers sum to* `target`*.* You may return the combinations in **any order**.
+
+The **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
+
+It is **guaranteed** that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.
+
+## Examples
+
+**Example 1:**
+
+```
+Input: candidates = [2,3,6,7], target = 7
+Output: [[2,2,3],[7]]
+Explanation:
+2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
+7 is a candidate, and 7 = 7.
+These are the only two combinations.
+
+```
+
+**Example 2:**
+
+```
+Input: candidates = [2,3,5], target = 8
+Output: [[2,2,2,2],[2,3,3],[3,5]]
+
+```
+
+**Example 3:**
+
+```
+Input: candidates = [2], target = 1
+Output: []
+
+```
+
+**Constraints:**
+
+- `1 <= candidates.length <= 30`
+- `1 <= candidates[i] <= 200`
+- All elements of `candidates` are **distinct**.
+- `1 <= target <= 500`
+
+## 解析
+
+給定一個整數陣列 nums 還有一個整數 target 
+
+要求要寫出一個演算法來找出和為 target 的所有 nums 內元素不重複組合
+
+可以利用類似 PowerSet 個概念
+
+分為選擇該數值或是不選該數值的 decision tree
+
+每次先檢查當選了該數值還可以繼續則及續選
+
+否則就往下一個數值檢查
+
+概念圖如下
+
+![](https://i.imgur.com/dtvXlz9.png)
+
+## 程式碼
+```go
+package sol
+
+func combinationSum(candidates []int, target int) [][]int {
+	result := [][]int{}
+
+	var dfs func(i int, cur []int, total int)
+	dfs = func(i int, cur []int, total int) {
+		// break condition
+		if total == target {
+			temp := make([]int, len(cur))
+			copy(temp, cur)
+			result = append(result, temp)
+			return
+		}
+		// prune not possible path
+		if i >= len(candidates) || total > target {
+			return
+		}
+
+		// choose i
+		cur = append(cur, candidates[i])
+		dfs(i, cur, total+candidates[i])
+
+		// not choose i, next choose
+		cur = cur[:len(cur)-1]
+		dfs(i+1, cur, total)
+	}
+	dfs(0, []int{}, 0)
+	return result
+}
+
+```
+## 困難點
+
+1. 理解如何做窮舉法
+2. 理解如何窮舉出不重複的方式
+3. 需要理解 golang slice 只是 array 的 reference, 要保存值只能透過 copy 方式
+
+## Solve Point
+
+- [x]  Understand what problem to solve
+- [x]  Analysis Complexity

go.mod

@@ -0,0 +1,3 @@
+module sol
+
+go 1.16

sol/solution.go

@@ -0,0 +1,30 @@
+package sol
+
+func combinationSum(candidates []int, target int) [][]int {
+	result := [][]int{}
+
+	var dfs func(i int, cur []int, total int)
+	dfs = func(i int, cur []int, total int) {
+		// break condition
+		if total == target {
+			temp := make([]int, len(cur))
+			copy(temp, cur)
+			result = append(result, temp)
+			return
+		}
+		// prune not possible path
+		if i >= len(candidates) || total > target {
+			return
+		}
+
+		// choose i
+		cur = append(cur, candidates[i])
+		dfs(i, cur, total+candidates[i])
+
+		// not choose i, next choose
+		cur = cur[:len(cur)-1]
+		dfs(i+1, cur, total)
+	}
+	dfs(0, []int{}, 0)
+	return result
+}

sol/solution_test.go

@@ -0,0 +1,49 @@
+package sol
+
+import (
+	"reflect"
+	"testing"
+)
+
+func BenchmarkTest(b *testing.B) {
+	candidates := []int{2, 3, 6, 7}
+	target := 7
+	for idx := 0; idx < b.N; idx++ {
+		combinationSum(candidates, target)
+	}
+}
+
+func Test_combinationSum(t *testing.T) {
+	type args struct {
+		candidates []int
+		target     int
+	}
+	tests := []struct {
+		name string
+		args args
+		want [][]int
+	}{
+		{
+			name: "candidates = [2,3,6,7], target = 7",
+			args: args{candidates: []int{2, 3, 6, 7}, target: 7},
+			want: [][]int{{2, 2, 3}, {7}},
+		},
+		{
+			name: "candidates = [2,3,5], target = 8",
+			args: args{candidates: []int{2, 3, 5}, target: 8},
+			want: [][]int{{2, 2, 2, 2}, {2, 3, 3}, {3, 5}},
+		},
+		{
+			name: "candidates = [2], target = 1",
+			args: args{candidates: []int{2}, target: 1},
+			want: [][]int{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := combinationSum(tt.args.candidates, tt.args.target); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("combinationSum() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}