refactor: test cases and add golangci

Author: neverovski

.golangci.yaml

@@ -0,0 +1,120 @@
+linters-settings:
+  gosimple:
+    checks: [ "all" ]
+  govet:
+    check-shadowing: true
+    enable-all: true
+    disable:
+      - fieldalignment
+  staticcheck:
+    checks: [ "all" ]
+  revive:
+    ignore-generated-header: true
+    enable-all-rules: true
+    rules:
+      - name: add-constant
+        disabled: false
+        arguments:
+          - maxLitCount: "3"
+            allowInts: "0,1"
+      - name: argument-limit
+        arguments: [ 4 ]
+      - name: banned-characters
+        severity: warning
+        disabled: false
+        arguments: ["Ω", "Σ", "σ", "ω"]
+      - name: cognitive-complexity
+        arguments: [ 9 ]
+      - name: context-as-argument
+        arguments:
+          - allowTypesBefore: "*testing.T"
+      - name: cyclomatic
+        arguments: [ 7 ]
+      - name: defer
+        arguments:
+          - [ "call-chain", "loop" ]
+      - name: file-header
+        disabled: true
+      - name: function-result-limit
+        arguments: [ 3 ] #3 TODO
+      - name: flag-parameter
+        disabled: true #4 TODO
+      - name: function-length
+        disabled: false
+        arguments: [ 10, 20 ]
+      - name: line-length-limit
+        arguments: [ 120 ]
+      - name: max-public-structs
+        arguments: [ 3 ]
+      - name: string-format
+        arguments:
+          - - 'core.WriteError[1].Message'
+            - '/^([^A-Z]|$)/'
+            - must not start with a capital letter
+          - - 'fmt.Errorf[0]'
+            - '/(^|[^\.!?])$/'
+            - must not end in punctuation
+          - - panic
+            - '/^[^\n]*$/'
+            - must not contain line breaks
+      - name: unhandled-error
+        arguments:
+          - "fmt.Printf"
+  stylecheck:
+    checks: [ "all" ]
+  gosec:
+    exclude-generated: true
+    severity: high
+    concurrency: 3
+  gocritic:
+    enabled-checks:
+      - hugeParam
+      - tooManyResultsChecker
+      - rangeValCopy
+      - rangeExprCopy
+      - nestingReduce
+      - unnamedResult
+      - truncateCmp
+      - ruleguard
+      - elseif
+      - captLocal
+      - underef
+    settings:
+      captLocal:
+        paramsOnly: false
+      elseif:
+        skipBalanced: false
+      hugeParam:
+        sizeThreshold: 256
+      truncateCmp:
+        skipArchDependent: false
+      underef:
+        skipRecvDeref: false
+      unnamedResult:
+        checkExported: true
+linters:
+  disable-all: true
+  enable:
+    - errcheck
+    - gosimple
+    - govet
+    - ineffassign
+    - staticcheck
+    - unused
+    - revive
+    - stylecheck
+    - gosec
+    - gocritic
+issues:
+  # See the dedicated "issues" documentation section.
+  exclude-rules:
+    - path: _test\.go
+      text: "add-constant:"
+    - path: _test\.go
+      text: "line-length-limit:"
+    - path: _test\.go
+      text: "function-length: maximum number of lines"
+    - path: _test\.go
+      text: "function-length: maximum number of statements"
+    - path: '(.*)\/index\.go'
+      text: "function-length: maximum number of statements"

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "go.lintTool": "golangci-lint",
+  "go.lintFlags": [
+    "--fast"
+  ]
+}

problems/easy/problem001/problem001_test.go

@@ -1,22 +1,35 @@
 package problem001
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+type TestCase struct {
+	nums   []int
+	target int
+	out    []int
+}
+
 func TestTwoSum(t *testing.T) {
 	a := assert.New(t)
 
-	a.ElementsMatch([]int{0, 1}, twoSum([]int{2, 7, 11, 15}, 9))
-	a.ElementsMatch([]int{1, 2}, twoSum([]int{3, 2, 4}, 6))
-	a.ElementsMatch([]int{0, 1}, twoSum([]int{3, 3}, 6))
-	a.ElementsMatch([]int{1, 2}, twoSum([]int{1, 2, 3, 4}, 5))
-	a.ElementsMatch([]int{2, 4}, twoSum([]int{1, 1, 2, 3, 4}, 6))
-	a.ElementsMatch([]int{1, 2}, twoSum([]int{-1, -2, -3, -4}, -5))
-	a.ElementsMatch([]int{0, 1}, twoSum([]int{0, 0, 0}, 0))
-	a.ElementsMatch([]int{}, twoSum([]int{1, 2, 3, 4}, 10))
+	testCases := []TestCase{
+		{nums: []int{2, 7, 11, 15}, target: 9, out: []int{0, 1}},
+		{nums: []int{3, 2, 4}, target: 6, out: []int{1, 2}},
+		{nums: []int{3, 3}, target: 6, out: []int{0, 1}},
+		{nums: []int{1, 2, 3, 4}, target: 5, out: []int{1, 2}},
+		{nums: []int{1, 1, 2, 3, 4}, target: 6, out: []int{2, 4}},
+		{nums: []int{-1, -2, -3, -4}, target: -5, out: []int{1, 2}},
+		{nums: []int{0, 0, 0}, target: 0, out: []int{0, 1}},
+		{nums: []int{1, 2, 3, 4}, target: 10, out: []int{}},
+	}
+
+	for key, tc := range testCases {
+		a.ElementsMatch(tc.out, twoSum(tc.nums, tc.target), fmt.Sprintf("TestTwoSum number # %d", key+1))
+	}
 }
 
 func BenchmarkTwoSum(b *testing.B) {

problems/easy/problem009/problem009_test.go

@@ -1,23 +1,35 @@
 package problem009
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+type TestCase struct {
+	in  int
+	out bool
+}
+
 func TestIsPalindrome(t *testing.T) {
 	a := assert.New(t)
 
-	a.Equal(true, isPalindrome(121))
-	a.Equal(false, isPalindrome(10))
-	a.Equal(false, isPalindrome(-123))
-	a.Equal(true, isPalindrome(5))
-	a.Equal(true, isPalindrome(1221), "even number of digits")
-	a.Equal(false, isPalindrome(1231), "not a palindrome")
-	a.Equal(true, isPalindrome(1), "single digit")
-	a.Equal(false, isPalindrome(-1), "negative single digit")
-	a.Equal(true, isPalindrome(0), "zero")
+	testCases := []TestCase{
+		{in: 121, out: true},
+		{in: 10, out: false},
+		{in: -123, out: false},
+		{in: 5, out: true},
+		{in: 1221, out: true},
+		{in: 1231, out: false},
+		{in: 1, out: true},
+		{in: -1, out: false},
+		{in: 0, out: true},
+	}
+
+	for key, tc := range testCases {
+		a.Equal(tc.out, isPalindrome(tc.in), fmt.Sprintf("TestIsPalindrome number # %d", key+1))
+	}
 }
 
 func BenchmarkIsPalindrome(b *testing.B) {

problems/easy/problem013/problem013.go

@@ -1,13 +1,15 @@
 package problem013
 
+const multiplier = 2
+
 var symbols = map[byte]int{'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
 
 func romanToInt(s string) int {
 	num := 0
 
 	for i := 0; i < len(s); i++ {
 		if i > 0 && symbols[s[i]] > symbols[s[i-1]] {
-			num += symbols[s[i]] - 2*symbols[s[i-1]]
+			num += symbols[s[i]] - multiplier*symbols[s[i-1]]
 		} else {
 			num += symbols[s[i]]
 		}

problems/easy/problem013/problem013_test.go

@@ -1,26 +1,38 @@
 package problem013
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+type TestCase struct {
+	in  string
+	out int
+}
+
 func TestRomanToInt(t *testing.T) {
 	a := assert.New(t)
 
-	a.Equal(3, romanToInt("III"))
-	a.Equal(54, romanToInt("LIV"))
-	a.Equal(58, romanToInt("LVIII"))
-	a.Equal(1994, romanToInt("MCMXCIV"))
-	a.Equal(1, romanToInt("I"))
-	a.Equal(3999, romanToInt("MMMCMXCIX"))
-	a.Equal(4, romanToInt("IV"))
-	a.Equal(9, romanToInt("IX"))
-	a.Equal(40, romanToInt("XL"))
-	a.Equal(90, romanToInt("XC"))
-	a.Equal(400, romanToInt("CD"))
-	a.Equal(900, romanToInt("CM"))
+	testCases := []TestCase{
+		{in: "III", out: 3},
+		{in: "LIV", out: 54},
+		{in: "LVIII", out: 58},
+		{in: "MCMXCIV", out: 1994},
+		{in: "I", out: 1},
+		{in: "MMMCMXCIX", out: 3999},
+		{in: "IV", out: 4},
+		{in: "IX", out: 9},
+		{in: "XL", out: 40},
+		{in: "XC", out: 90},
+		{in: "CD", out: 400},
+		{in: "CM", out: 900},
+	}
+
+	for key, tc := range testCases {
+		a.Equal(tc.out, romanToInt(tc.in), fmt.Sprintf("TestRomanToInt number # %d", key+1))
+	}
 }
 
 func BenchmarkRomanToInt(b *testing.B) {

problems/easy/problem014/problem014.go

@@ -9,6 +9,14 @@ func longestCommonPrefix(strs []string) string {
 		return strs[0]
 	}
 
+	if len(strs) == 1 {
+		return strs[0]
+	}
+
+	return findCommonPrefix(strs)
+}
+
+func findCommonPrefix(strs []string) string {
 	prefix := strs[0]
 
 	for i := 1; i < len(strs); i++ {

problems/easy/problem014/problem014_test.go

@@ -1,21 +1,33 @@
 package problem014
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+type TestCase struct {
+	in  []string
+	out string
+}
+
 func TestLongestCommonPrefix(t *testing.T) {
 	a := assert.New(t)
 
-	a.Equal("fl", longestCommonPrefix([]string{"flower", "flow", "flight"}))
-	a.Equal("", longestCommonPrefix([]string{"dog", "racecar", "car"}))
-	a.Equal("a", longestCommonPrefix([]string{"abc", "a", "ab"}), "one string is a prefix of the others")
-	a.Equal("", longestCommonPrefix([]string{"", "b", "c"}), "one string is empty")
-	a.Equal("abc", longestCommonPrefix([]string{"abc", "abc", "abc"}), "all strings are the same")
-	a.Equal("", longestCommonPrefix([]string{"abc", "def", "ghi"}), "no common prefix")
-	a.Equal("", longestCommonPrefix([]string{}), "empty slice")
+	testCases := []TestCase{
+		{in: []string{"flower", "flow", "flight"}, out: "fl"},
+		{in: []string{"dog", "racecar", "car"}, out: ""},
+		{in: []string{"abc", "a", "ab"}, out: "a"},
+		{in: []string{"", "b", "c"}, out: ""},
+		{in: []string{"abc", "abc", "abc"}, out: "abc"},
+		{in: []string{"abc", "def", "ghi"}, out: ""},
+		{in: []string{}, out: ""},
+	}
+
+	for key, tc := range testCases {
+		a.Equal(tc.out, longestCommonPrefix(tc.in), fmt.Sprintf("TestLongestCommonPrefix number # %d", key+1))
+	}
 }
 
 func BenchmarkLongestCommonPrefix(b *testing.B) {

problems/easy/problem020/problem020.go

@@ -1,11 +1,11 @@
 package problem020
 
-import (
-	stack "leetcode/go/utils/stack"
-)
+import "leetcode/go/utils/stack"
+
+const DIVISOR = 2
 
 func isValid(s string) bool {
-	if len(s) == 0 || len(s)%2 == 1 {
+	if len(s) == 0 || len(s)%DIVISOR == 1 {
 		return false
 	}
 
@@ -16,6 +16,10 @@ func isValid(s string) bool {
 	}
 	symbolStack := stack.New()
 
+	return processSymbols(s, pattern, symbolStack)
+}
+
+func processSymbols(s string, pattern map[byte]byte, symbolStack *stack.Stack) bool {
 	for i := 0; i < len(s); i++ {
 		if _, ok := pattern[s[i]]; ok {
 			symbolStack.Push(s[i])