Added tasks 28-58

Author: ThanhNIT

src/main/go/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md

@@ -0,0 +1,36 @@
+28\. Implement strStr()
+
+Easy
+
+Implement [strStr()](http://www.cplusplus.com/reference/cstring/strstr/).
+
+Return the index of the first occurrence of needle in haystack, or `-1` if `needle` is not part of `haystack`.
+
+**Clarification:**
+
+What should we return when `needle` is an empty string? This is a great question to ask during an interview.
+
+For the purpose of this problem, we will return 0 when `needle` is an empty string. This is consistent to C's [strstr()](http://www.cplusplus.com/reference/cstring/strstr/) and Java's [indexOf()](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)).
+
+**Example 1:**
+
+**Input:** haystack = "hello", needle = "ll"
+
+**Output:** 2 
+
+**Example 2:**
+
+**Input:** haystack = "aaaaa", needle = "bba"
+
+**Output:** -1 
+
+**Example 3:**
+
+**Input:** haystack = "", needle = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= haystack.length, needle.length <= 5 * 10<sup>4</sup></code>
+*   `haystack` and `needle` consist of only lower-case English characters.

src/main/go/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/solution.go

@@ -0,0 +1,19 @@
+package s0028_find_the_index_of_the_first_occurrence_in_a_string
+
+// #Easy #Top_Interview_Questions #String #Two_Pointers #String_Matching
+// #Programming_Skills_II_Day_1 #Top_Interview_150_Array/String
+// #2025_05_13_Time_0_ms_(100.00%)_Space_3.83_MB_(94.91%)
+
+func strStr(haystack string, needle string) int {
+	if needle == "" {
+		return 0
+	}
+	m := len(haystack)
+	n := len(needle)
+	for start := 0; start < m-n+1; start++ {
+		if haystack[start:start+n] == needle {
+			return start
+		}
+	}
+	return -1
+}

src/main/go/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/solution_test.go

@@ -0,0 +1,14 @@
+package s0028_find_the_index_of_the_first_occurrence_in_a_string
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestStrStr(t *testing.T) {
+	assert.Equal(t, 0, strStr("sadbutsad", "sad"))
+}
+
+func TestStrStr2(t *testing.T) {
+	assert.Equal(t, -1, strStr("leetcode", "leeto"))
+}

src/main/go/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md

@@ -0,0 +1,35 @@
+30\. Substring with Concatenation of All Words
+
+Hard
+
+You are given a string `s` and an array of strings `words` of **the same length**. Return all starting indices of substring(s) in `s` that is a concatenation of each word in `words` **exactly once**, **in any order**, and **without any intervening characters**.
+
+You can return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** s = "barfoothefoobarman", words = ["foo","bar"]
+
+**Output:** [0,9]
+
+**Explanation:** Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively. The output order does not matter, returning [9,0] is fine too. 
+
+**Example 2:**
+
+**Input:** s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
+
+**Output:** [6,9,12] 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of lower-case English letters.
+*   `1 <= words.length <= 5000`
+*   `1 <= words[i].length <= 30`
+*   `words[i]` consists of lower-case English letters.

src/main/go/g0001_0100/s0030_substring_with_concatenation_of_all_words/solution.go

@@ -0,0 +1,42 @@
+package s0030_substring_with_concatenation_of_all_words
+
+// #Hard #String #Hash_Table #Sliding_Window #Top_Interview_150_Sliding_Window
+// #2025_05_13_Time_5_ms_(91.71%)_Space_8.76_MB_(38.24%)
+
+func findSubstring(s string, words []string) []int {
+	ans := make([]int, 0)
+	n1 := len(words[0])
+	n2 := len(s)
+	map1 := make(map[string]int)
+	for _, ch := range words {
+		map1[ch]++
+	}
+	for i := 0; i < n1; i++ {
+		left := i
+		j := i
+		c := 0
+		map2 := make(map[string]int)
+		for j+n1 <= n2 {
+			word1 := s[j : j+n1]
+			j += n1
+			if _, ok := map1[word1]; ok {
+				map2[word1]++
+				c++
+				for map2[word1] > map1[word1] {
+					word2 := s[left : left+n1]
+					map2[word2]--
+					left += n1
+					c--
+				}
+				if c == len(words) {
+					ans = append(ans, left)
+				}
+			} else {
+				map2 = make(map[string]int)
+				c = 0
+				left = j
+			}
+		}
+	}
+	return ans
+}

src/main/go/g0001_0100/s0030_substring_with_concatenation_of_all_words/solution_test.go

@@ -0,0 +1,18 @@
+package s0030_substring_with_concatenation_of_all_words
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestFindSubstring(t *testing.T) {
+	assert.Equal(t, []int{0, 9}, findSubstring("barfoothefoobarman", []string{"foo", "bar"}))
+}
+
+func TestFindSubstring2(t *testing.T) {
+	assert.Equal(t, []int{}, findSubstring("wordgoodgoodgoodbestword", []string{"word", "good", "best", "word"}))
+}
+
+func TestFindSubstring3(t *testing.T) {
+	assert.Equal(t, []int{6, 9, 12}, findSubstring("barfoofoobarthefoobarman", []string{"bar", "foo", "the"}))
+}

src/main/go/g0001_0100/s0036_valid_sudoku/readme.md

@@ -0,0 +1,58 @@
+36\. Valid Sudoku
+
+Medium
+
+Determine if a `9 x 9` Sudoku board is valid. Only the filled cells need to be validated **according to the following rules**:
+
+1.  Each row must contain the digits `1-9` without repetition.
+2.  Each column must contain the digits `1-9` without repetition.
+3.  Each of the nine `3 x 3` sub-boxes of the grid must contain the digits `1-9` without repetition.
+
+**Note:**
+
+*   A Sudoku board (partially filled) could be valid but is not necessarily solvable.
+*   Only the filled cells need to be validated according to the mentioned rules.
+
+**Example 1:**
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png)
+
+**Input:**
+
+    board =
+    [["5","3",".",".","7",".",".",".","."]
+    ,["6",".",".","1","9","5",".",".","."]
+    ,[".","9","8",".",".",".",".","6","."]
+    ,["8",".",".",".","6",".",".",".","3"]
+    ,["4",".",".","8",".","3",".",".","1"]
+    ,["7",".",".",".","2",".",".",".","6"]
+    ,[".","6",".",".",".",".","2","8","."]
+    ,[".",".",".","4","1","9",".",".","5"]
+    ,[".",".",".",".","8",".",".","7","9"]]
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:**
+
+    board =
+    [["8","3",".",".","7",".",".",".","."]
+    ,["6",".",".","1","9","5",".",".","."]
+    ,[".","9","8",".",".",".",".","6","."]
+    ,["8",".",".",".","6",".",".",".","3"]
+    ,["4",".",".","8",".","3",".",".","1"]
+    ,["7",".",".",".","2",".",".",".","6"]
+    ,[".","6",".",".",".",".","2","8","."]
+    ,[".",".",".","4","1","9",".",".","5"]
+    ,[".",".",".",".","8",".",".","7","9"]]
+
+**Output:** false
+
+**Explanation:** Same as Example 1, except with the **5** in the top left corner being modified to **8**. Since there are two 8's in the top left 3x3 sub-box, it is invalid. 
+
+**Constraints:**
+
+*   `board.length == 9`
+*   `board[i].length == 9`
+*   `board[i][j]` is a digit `1-9` or `'.'`.

src/main/go/g0001_0100/s0036_valid_sudoku/solution.go

@@ -0,0 +1,46 @@
+package s0036_valid_sudoku
+
+// #Medium #Top_Interview_Questions #Array #Hash_Table #Matrix #Data_Structure_I_Day_5_Array
+// #Top_Interview_150_Matrix #2025_05_13_Time_0_ms_(100.00%)_Space_4.66_MB_(82.08%)
+
+type Solution struct {
+	j1 int
+	i1 [9]int
+	b1 [9]int
+}
+
+func isValidSudoku(board [][]byte) bool {
+	s := &Solution{}
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			if !s.checkValid(board, i, j) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (s *Solution) checkValid(board [][]byte, i, j int) bool {
+	if j == 0 {
+		s.j1 = 0
+	}
+	if board[i][j] == '.' {
+		return true
+	}
+	val := int(board[i][j] - '0')
+	if s.j1 == (s.j1 | (1 << (val - 1))) {
+		return false
+	}
+	s.j1 |= 1 << (val - 1)
+	if s.i1[j] == (s.i1[j] | (1 << (val - 1))) {
+		return false
+	}
+	s.i1[j] |= 1 << (val - 1)
+	b := (i/3)*3 + j/3
+	if s.b1[b] == (s.b1[b] | (1 << (val - 1))) {
+		return false
+	}
+	s.b1[b] |= 1 << (val - 1)
+	return true
+}

src/main/go/g0001_0100/s0036_valid_sudoku/solution_test.go

@@ -0,0 +1,36 @@
+package s0036_valid_sudoku
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestIsValidSudoku(t *testing.T) {
+	board := [][]byte{
+		{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
+		{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+		{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+		{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+		{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+		{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+		{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+		{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+		{'.', '.', '.', '.', '8', '.', '.', '7', '9'},
+	}
+	assert.True(t, isValidSudoku(board))
+}
+
+func TestIsValidSudoku2(t *testing.T) {
+	board := [][]byte{
+		{'8', '3', '.', '.', '7', '.', '.', '.', '.'},
+		{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+		{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+		{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+		{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+		{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+		{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+		{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+		{'.', '.', '.', '.', '8', '.', '.', '7', '9'},
+	}
+	assert.False(t, isValidSudoku(board))
+}

src/main/go/g0001_0100/s0054_spiral_matrix/readme.md

@@ -0,0 +1,28 @@
+54\. Spiral Matrix
+
+Medium
+
+Given an `m x n` `matrix`, return _all elements of the_ `matrix` _in spiral order_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg)
+
+**Input:** matrix = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [1,2,3,6,9,8,7,4,5] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral.jpg)
+
+**Input:** matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+
+**Output:** [1,2,3,4,8,12,11,10,9,5,6,7] 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 10`
+*   `-100 <= matrix[i][j] <= 100`