initialize solution for leetcode 240 and cicd

Author: yuewang199511

.github/workflows/test.yml

@@ -0,0 +1,50 @@
+name: Test
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    
+    strategy:
+      matrix:
+        go-version: [ '1.25.6' ]
+        os: [ ubuntu-latest, windows-latest, macos-latest ]
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Go ${{ matrix.go-version }}
+      uses: actions/setup-go@v5
+      with:
+        go-version: ${{ matrix.go-version }}
+    
+    - name: Cache Go modules
+      uses: actions/cache@v4
+      with:
+        path: ~/go/pkg/mod
+        key: ${{ runner.os }}-go-${{ matrix.go-version }}-${{ hashFiles('**/go.sum') }}
+        restore-keys: |
+          ${{ runner.os }}-go-${{ matrix.go-version }}-
+    
+    - name: Download dependencies
+      run: |
+        find . -name "go.mod" -execdir go mod download \;
+    
+    - name: Run tests
+      run: |
+        find . -name "go.mod" -execdir go test -v ./... \;
+    
+    - name: Run tests with race detector
+      run: |
+        find . -name "go.mod" -execdir go test -race -v ./... \;
+
+
+    
+    - name: Check code builds
+      run: |
+        find . -name "go.mod" -execdir go build -v ./... \;

README.md

@@ -0,0 +1,70 @@
+# Introduction
+
+This repository contains notes and solutions for selected coding exercises, with examples of automated testing and CI/CD workflows.
+
+For each problem, I focus on the thought process rather than providing a full, final solution. That includes analysis of time and space complexity, discussion of constraints, intuition, and invariants used to reason about correctness.
+
+Solutions may not be optimal, but they serve as a starting point for further improvement and learning.
+
+# CI/CD setup
+
+This repository uses GitHub Actions for automated testing. The workflow:
+
+- **Triggers**: Runs on pushes to `main`/`develop` branches and pull requests to `main`
+- **Go versions**: Tests against Go 1.21, 1.22, and 1.23 for compatibility
+- **Test steps**:
+  1. Downloads dependencies for all Go modules in the repository
+  2. Runs tests with `go test -v ./...`
+  3. Runs tests with race detector enabled
+  4. Verifies code builds successfully
+
+
+Each problem directory with a `go.mod` file is automatically discovered and tested independently.
+
+
+
+# Notes on CI/CD
+
+I only used gitlab before so this note will mention some reference to gitlab but still trying to offer the concept of how CI/CD is setup in github acitons.
+
+Please also check [text](https://docs.github.com/en/actions/tutorials/build-and-test-code/go) where it has a good starting example for go.
+
+## Key Concepts
+
+**GitHub Actions Basics:**
+- **`uses`**: Runs pre-built actions instead of custom shell commands, good to check in [text](https://github.com/marketplace?query=checkout&type=actions)
+- **`runs-on`**: Specifies what machine/VM to run the job on (like GitHub's free EC2)
+- **`actions/checkout@v4`**: Downloads repository source code to the runner like running clone - cd - checkout
+- **`.github/workflows/*.yml`**: GitHub's config location (vs GitLab's single `.gitlab-ci.yml`)
+
+**Matrix Strategy (Parallel Jobs):**
+- **`strategy` + `matrix`**: Creates parallel jobs with different configurations (like GitLab's parallel:matrix)
+- **Cross-platform testing**: Simply use multiple OS runners (ubuntu/windows/macos)
+
+**Caching (Speed Optimization):**
+- **`actions/cache@v4`**: Speeds up workflows by saving/restoring files between CI/CD runs
+- **`path`**: What directory/files to cache (~/go/pkg/mod for Go modules)
+- **`key`**: Unique identifier for the cache (includes OS, Go version, dependency hash)
+- **`restore-keys`**: Fallback cache keys to try if exact match not found
+- **Cache timing**: Restore happens on the step of actions/cache, save happens automatically at job end. go actions has its own caching mechanism, this repo use the custom cache just to show one of the machanism for caching.
+- **Cache fallback**: Uses partial matches when dependencies change incrementally, but still try to get the previous installed packages
+
+**Go Commands:**
+- **`go test -v`**: Runs tests with verbose output showing individual test names
+- **`go build`**: Compiles Go source code into executables (compilation verification)
+- **`find . -name "go.mod" -execdir`**: Finds all Go modules and runs commands in their directories
+
+## Local testing
+
+To run tests locally for a specific problem:
+
+```bash
+cd "Problem Directory"
+go test -v ./...
+```
+
+To run tests with race detection:
+
+```bash
+go test -race -v ./...
+```

Search a 2D Matrix II/README.md

@@ -0,0 +1,27 @@
+# 240. Search a 2D Matrix II
+Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:
+
+- Integers in each row are sorted in ascending from left to right.
+- Integers in each column are sorted in ascending from top to bottom.
+
+Constraints:
+
+- m == matrix.length
+- n == matrix[i].length
+- 1 <= n, m <= 300
+- -109 <= matrix[i][j] <= 109
+- All the integers in each row are sorted in ascending order.
+- All the integers in each column are sorted in ascending order.
+- -109 <= target <= 109
+
+# solution process
+As the description suggests, there might be someway we can utilize this property of ascending order to achieve a running complexity less than O(m * n)
+
+As we can easily spot that any number in the mastrix lies in the range of [M[topleft], [bottomright]], we can guess the invariant to be ``if the target falls into the range of between the top left and bottom right corner number, then it may exist. If not, the number definitly does not exists.``
+
+So is it possible to remove a part of the range in the matrix, so we always remove a part that definitly does not contain the target and keep the rest?
+
+There must be a loop in this solution, so when do we exit?
+
+Is there any special situation that target falls into all ranges, how can we make the code terminate under such situation? 
+

Search a 2D Matrix II/go.mod

@@ -0,0 +1,10 @@
+module search-matrix
+
+go 1.25.6
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/testify v1.11.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

Search a 2D Matrix II/go.sum

@@ -0,0 +1,9 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

Search a 2D Matrix II/solution.go

@@ -0,0 +1,75 @@
+package main
+
+import "fmt"
+
+// searchMatrix searches for a target value in a 2D matrix
+func searchMatrix(matrix [][]int, target int) bool {
+	if len(matrix) == 0 || len(matrix[0]) == 0 {
+		return false
+	}
+
+	i := 0
+	j := 0
+	k := len(matrix) - 1
+	l := len(matrix[0]) - 1
+	M := matrix
+	t := target
+
+	// Check if target is outside the matrix range
+	if M[i][j] > t || M[k][l] < t {
+		return false
+	}
+
+	// Shrink the search area by eliminating rows/columns
+	for i < k && j < l {
+		if M[i][j] > t || M[i][l] < t {
+			i++
+		} else if M[i][j] > t || M[k][j] < t {
+			j++
+		} else if M[k][j] > t || M[k][l] < t {
+			k--
+		} else if M[i][l] > t || M[k][l] < t {
+			l--
+		} else if M[i][j] == t || M[i][l] == t || M[k][j] == t || M[k][l] == t {
+			return true
+		}
+	}
+
+	// Search in remaining row or column
+	if i == k {
+		// Search remaining row
+		for col := j; col <= l; col++ {
+			if M[i][col] == t {
+				return true
+			}
+		}
+		return false
+	} else {
+		// Search remaining column
+		for row := i; row <= k; row++ {
+			if M[row][j] == t {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+func main() {
+	// Example case, generated by AI
+	matrix := [][]int{
+		{1, 4, 7, 11, 15},
+		{2, 5, 8, 12, 19},
+		{3, 6, 9, 16, 22},
+		{10, 13, 14, 17, 24},
+		{18, 21, 23, 26, 30},
+	}
+
+	target := 5
+	result := searchMatrix(matrix, target)
+	fmt.Printf("Target %d found: %t\n", target, result)
+
+	target = 20
+	result = searchMatrix(matrix, target)
+	fmt.Printf("Target %d found: %t\n", target, result)
+}

Search a 2D Matrix II/solution_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSearchMatrix(t *testing.T) {
+	matrix := [][]int{
+		{1, 4, 7, 11, 15},
+		{2, 5, 8, 12, 19},
+		{3, 6, 9, 16, 22},
+		{10, 13, 14, 17, 24},
+		{18, 21, 23, 26, 30},
+	}
+
+	testCases := []struct {
+		target   int
+		expected bool
+	}{
+		{5, true},
+		{14, true},
+		{20, false},
+		{1, true},
+		{30, true},
+		{0, false},
+		{31, false},
+	}
+
+	for _, tc := range testCases {
+		result := searchMatrix(matrix, tc.target)
+		assert.Equal(t, tc.expected, result, "searchMatrix(matrix, %d)", tc.target)
+	}
+}
+
+func TestSearchMatrixEmptyMatrix(t *testing.T) {
+	// Test empty matrix
+	emptyMatrix := [][]int{}
+	result := searchMatrix(emptyMatrix, 1)
+	assert.False(t, result, "searchMatrix should return false for empty matrix")
+}
+
+func TestSearchMatrixSingleElement(t *testing.T) {
+	// Test single element matrix
+	singleMatrix := [][]int{{1}}
+
+	result := searchMatrix(singleMatrix, 1)
+	assert.True(t, result, "searchMatrix should find existing element")
+
+	result = searchMatrix(singleMatrix, 2)
+	assert.False(t, result, "searchMatrix should return false for non-existing element")
+}