Added tasks 137-191

Author: ThanhNIT

README.md

@@ -0,0 +1,25 @@
+137\. Single Number II
+
+Medium
+
+Given an integer array `nums` where every element appears **three times** except for one, which appears **exactly once**. _Find the single element and return it_.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,3,2]
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,1,0,1,99]
+
+**Output:** 99
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   Each element in `nums` appears exactly **three times** except for one element which appears **once**.

src/main/go/g0101_0200/s0137_single_number_ii/readme.md

@@ -0,0 +1,14 @@
+package s0137_single_number_ii
+
+// #Medium #Array #Bit_Manipulation #Top_Interview_150_Bit_Manipulation
+// #2025_05_21_Time_0_ms_(100.00%)_Space_5.16_MB_(75.27%)
+
+func singleNumber(nums []int) int {
+	ones := 0
+	twos := 0
+	for _, num := range nums {
+		ones = (ones ^ num) & (^twos)
+		twos = (twos ^ num) & (^ones)
+	}
+	return ones
+}

src/main/go/g0101_0200/s0137_single_number_ii/solution.go

@@ -0,0 +1,14 @@
+package s0137_single_number_ii
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSingleNumber(t *testing.T) {
+	assert.Equal(t, 3, singleNumber([]int{2, 2, 3, 2}))
+}
+
+func TestSingleNumber2(t *testing.T) {
+	assert.Equal(t, 99, singleNumber([]int{0, 1, 0, 1, 0, 1, 99}))
+}

src/main/go/g0101_0200/s0137_single_number_ii/solution_test.go

@@ -0,0 +1,52 @@
+150\. Evaluate Reverse Polish Notation
+
+Medium
+
+Evaluate the value of an arithmetic expression in [Reverse Polish Notation](http://en.wikipedia.org/wiki/Reverse_Polish_notation).
+
+Valid operators are `+`, `-`, `*`, and `/`. Each operand may be an integer or another expression.
+
+**Note** that division between two integers should truncate toward zero.
+
+It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.
+
+**Example 1:**
+
+**Input:** tokens = ["2","1","+","3","\*"]
+
+**Output:** 9
+
+**Explanation:** ((2 + 1) \* 3) = 9
+
+**Example 2:**
+
+**Input:** tokens = ["4","13","5","/","+"]
+
+**Output:** 6
+
+**Explanation:** (4 + (13 / 5)) = 6
+
+**Example 3:**
+
+**Input:** tokens = ["10","6","9","3","+","-11","\*","/","\*","17","+","5","+"]
+
+**Output:** 22
+
+**Explanation:** ((10 \* (6 / ((9 + 3) \* -11))) + 17) + 5 
+
+= ((10 \* (6 / (12 \* -11))) + 17) + 5 
+
+= ((10 \* (6 / -132)) + 17) + 5 
+
+= ((10 \* 0) + 17) + 5 
+
+= (0 + 17) + 5 
+
+= 17 + 5 
+
+= 22
+
+**Constraints:**
+
+*   <code>1 <= tokens.length <= 10<sup>4</sup></code>
+*   `tokens[i]` is either an operator: `"+"`, `"-"`, `"*"`, or `"/"`, or an integer in the range `[-200, 200]`.

src/main/go/g0101_0200/s0150_evaluate_reverse_polish_notation/readme.md

@@ -0,0 +1,46 @@
+package s0150_evaluate_reverse_polish_notation
+
+// #Medium #Top_Interview_Questions #Array #Math #Stack #Programming_Skills_II_Day_3
+// #Top_Interview_150_Stack #2025_05_21_Time_0_ms_(100.00%)_Space_6.10_MB_(53.08%)
+
+func evalRPN(tokens []string) int {
+	stack := make([]int, 0)
+	for _, token := range tokens {
+		if len(token) == 1 && !isDigit(token[0]) {
+			second := stack[len(stack)-1]
+			first := stack[len(stack)-2]
+			stack = stack[:len(stack)-2]
+			stack = append(stack, eval(first, second, token))
+		} else {
+			num := 0
+			sign := 1
+			i := 0
+			if token[0] == '-' {
+				sign = -1
+				i = 1
+			}
+			for ; i < len(token); i++ {
+				num = num*10 + int(token[i]-'0')
+			}
+			stack = append(stack, num*sign)
+		}
+	}
+	return stack[0]
+}
+
+func eval(first, second int, operator string) int {
+	switch operator {
+	case "+":
+		return first + second
+	case "-":
+		return first - second
+	case "*":
+		return first * second
+	default:
+		return first / second
+	}
+}
+
+func isDigit(c byte) bool {
+	return c >= '0' && c <= '9'
+}

src/main/go/g0101_0200/s0150_evaluate_reverse_polish_notation/solution.go

@@ -0,0 +1,18 @@
+package s0150_evaluate_reverse_polish_notation
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestEvalRPN(t *testing.T) {
+	assert.Equal(t, 9, evalRPN([]string{"2", "1", "+", "3", "*"}))
+}
+
+func TestEvalRPN2(t *testing.T) {
+	assert.Equal(t, 6, evalRPN([]string{"4", "13", "5", "/", "+"}))
+}
+
+func TestEvalRPN3(t *testing.T) {
+	assert.Equal(t, 22, evalRPN([]string{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}))
+}

src/main/go/g0101_0200/s0150_evaluate_reverse_polish_notation/solution_test.go

@@ -0,0 +1,41 @@
+151\. Reverse Words in a String
+
+Medium
+
+Given an input string `s`, reverse the order of the **words**.
+
+A **word** is defined as a sequence of non-space characters. The **words** in `s` will be separated by at least one space.
+
+Return _a string of the words in reverse order concatenated by a single space._
+
+**Note** that `s` may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.
+
+**Example 1:**
+
+**Input:** s = "the sky is blue"
+
+**Output:** "blue is sky the"
+
+**Example 2:**
+
+**Input:** s = " hello world "
+
+**Output:** "world hello"
+
+**Explanation:** Your reversed string should not contain leading or trailing spaces.
+
+**Example 3:**
+
+**Input:** s = "a good example"
+
+**Output:** "example good a"
+
+**Explanation:** You need to reduce multiple spaces between two words to a single space in the reversed string.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` contains English letters (upper-case and lower-case), digits, and spaces `' '`.
+*   There is **at least one** word in `s`.
+
+**Follow-up:** If the string data type is mutable in your language, can you solve it **in-place** with `O(1)` extra space?

src/main/go/g0101_0200/s0151_reverse_words_in_a_string/readme.md

@@ -0,0 +1,25 @@
+package s0151_reverse_words_in_a_string
+
+// #Medium #String #Two_Pointers #LeetCode_75_Array/String #Udemy_Strings
+// #Top_Interview_150_Array/String #2025_05_21_Time_0_ms_(100.00%)_Space_5.37_MB_(51.24%)
+
+func reverseWords(s string) string {
+	var result []rune
+	i := len(s) - 1
+	for i >= 0 {
+		if s[i] == ' ' {
+			i--
+			continue
+		}
+		start := i
+		for start >= 0 && s[start] != ' ' {
+			start--
+		}
+		if len(result) > 0 {
+			result = append(result, ' ')
+		}
+		result = append(result, []rune(s[start+1:i+1])...)
+		i = start - 1
+	}
+	return string(result)
+}

src/main/go/g0101_0200/s0151_reverse_words_in_a_string/solution.go

@@ -0,0 +1,18 @@
+package s0151_reverse_words_in_a_string
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestReverseWords(t *testing.T) {
+	assert.Equal(t, "blue is sky the", reverseWords("the sky is blue"))
+}
+
+func TestReverseWords2(t *testing.T) {
+	assert.Equal(t, "world hello", reverseWords("  hello world  "))
+}
+
+func TestReverseWords3(t *testing.T) {
+	assert.Equal(t, "example good a", reverseWords("a good   example"))
+}