Added tasks 199-224

Author: ThanhNIT

README.md

@@ -0,0 +1,30 @@
+199\. Binary Tree Right Side View
+
+Medium
+
+Given the `root` of a binary tree, imagine yourself standing on the **right side** of it, return _the values of the nodes you can see ordered from top to bottom_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/14/tree.jpg)
+
+**Input:** root = [1,2,3,null,5,null,4]
+
+**Output:** [1,3,4]
+
+**Example 2:**
+
+**Input:** root = [1,null,3]
+
+**Output:** [1,3]
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`

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

@@ -0,0 +1,29 @@
+package s0199_binary_tree_right_side_view
+
+// #Medium #Top_100_Liked_Questions #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #LeetCode_75_Binary_Tree/BFS #Data_Structure_II_Day_16_Tree #Level_2_Day_15_Tree
+// #Top_Interview_150_Binary_Tree_BFS #2025_05_22_Time_0_ms_(100.00%)_Space_4.29_MB_(85.87%)
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func rightSideView(root *TreeNode) []int {
+	var list []int
+	recurse(root, 0, &list)
+	return list
+}
+
+func recurse(node *TreeNode, level int, list *[]int) {
+	if node != nil {
+		if len(*list) < level+1 {
+			*list = append(*list, node.Val)
+		}
+		recurse(node.Right, level+1, list)
+		recurse(node.Left, level+1, list)
+	}
+}

src/main/go/g0101_0200/s0199_binary_tree_right_side_view/solution.go

@@ -0,0 +1,31 @@
+package s0199_binary_tree_right_side_view
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestRightSideView(t *testing.T) {
+	left := &TreeNode{
+		Val:   2,
+		Right: &TreeNode{Val: 5},
+	}
+	right := &TreeNode{
+		Val:   3,
+		Right: &TreeNode{Val: 4},
+	}
+	root := &TreeNode{
+		Val:   1,
+		Left:  left,
+		Right: right,
+	}
+	assert.Equal(t, []int{1, 3, 4}, rightSideView(root))
+}
+
+func TestRightSideView2(t *testing.T) {
+	root := &TreeNode{
+		Val:   1,
+		Right: &TreeNode{Val: 3},
+	}
+	assert.Equal(t, []int{1, 3}, rightSideView(root))
+}

src/main/go/g0101_0200/s0199_binary_tree_right_side_view/solution_test.go

@@ -0,0 +1,7 @@
+package s0199_binary_tree_right_side_view
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}

src/main/go/g0101_0200/s0199_binary_tree_right_side_view/tree_node.go

@@ -0,0 +1,27 @@
+201\. Bitwise AND of Numbers Range
+
+Medium
+
+Given two integers `left` and `right` that represent the range `[left, right]`, return _the bitwise AND of all numbers in this range, inclusive_.
+
+**Example 1:**
+
+**Input:** left = 5, right = 7
+
+**Output:** 4
+
+**Example 2:**
+
+**Input:** left = 0, right = 0
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** left = 1, right = 2147483647
+
+**Output:** 0
+
+**Constraints:**
+
+*   <code>0 <= left <= right <= 2<sup>31</sup> - 1</code>

src/main/go/g0201_0300/s0201_bitwise_and_of_numbers_range/readme.md

@@ -0,0 +1,48 @@
+package s0201_bitwise_and_of_numbers_range
+
+// #Medium #Bit_Manipulation #Algorithm_II_Day_19_Bit_Manipulation
+// #Top_Interview_150_Bit_Manipulation #2025_05_22_Time_0_ms_(100.00%)_Space_6.79_MB_(39.31%)
+
+import "math/bits"
+
+var masks = []uint32{
+	0,
+	0x80000000,
+	0xC0000000,
+	0xE0000000,
+	0xF0000000,
+	0xF8000000,
+	0xFC000000,
+	0xFE000000,
+	0xFF000000,
+	0xFF800000,
+	0xFFC00000,
+	0xFFE00000,
+	0xFFF00000,
+	0xFFF80000,
+	0xFFFC0000,
+	0xFFFE0000,
+	0xFFFF0000,
+	0xFFFF8000,
+	0xFFFFC000,
+	0xFFFFE000,
+	0xFFFFF000,
+	0xFFFFF800,
+	0xFFFFFC00,
+	0xFFFFFE00,
+	0xFFFFFF00,
+	0xFFFFFF80,
+	0xFFFFFFC0,
+	0xFFFFFFE0,
+	0xFFFFFFF0,
+	0xFFFFFFF8,
+	0xFFFFFFFC,
+	0xFFFFFFFE,
+}
+
+func rangeBitwiseAnd(left int, right int) int {
+	if left == right {
+		return left
+	}
+	return right & int(masks[bits.LeadingZeros32(uint32(left^right))])
+}

src/main/go/g0201_0300/s0201_bitwise_and_of_numbers_range/solution.go

@@ -0,0 +1,18 @@
+package s0201_bitwise_and_of_numbers_range
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestRangeBitwiseAnd(t *testing.T) {
+	assert.Equal(t, 4, rangeBitwiseAnd(5, 7))
+}
+
+func TestRangeBitwiseAnd2(t *testing.T) {
+	assert.Equal(t, 0, rangeBitwiseAnd(0, 0))
+}
+
+func TestRangeBitwiseAnd3(t *testing.T) {
+	assert.Equal(t, 0, rangeBitwiseAnd(1, 2147483647))
+}

src/main/go/g0201_0300/s0201_bitwise_and_of_numbers_range/solution_test.go

@@ -0,0 +1,31 @@
+202\. Happy Number
+
+Easy
+
+Write an algorithm to determine if a number `n` is happy.
+
+A **happy number** is a number defined by the following process:
+
+*   Starting with any positive integer, replace the number by the sum of the squares of its digits.
+*   Repeat the process until the number equals 1 (where it will stay), or it **loops endlessly in a cycle** which does not include 1.
+*   Those numbers for which this process **ends in 1** are happy.
+
+Return `true` _if_ `n` _is a happy number, and_ `false` _if not_.
+
+**Example 1:**
+
+**Input:** n = 19
+
+**Output:** true
+
+**Explanation:** 1<sup>2</sup> + 9<sup>2</sup> = 82 8<sup>2</sup> + 2<sup>2</sup> = 68 6<sup>2</sup> + 8<sup>2</sup> = 100 1<sup>2</sup> + 0<sup>2</sup> + 0<sup>2</sup> = 1
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/main/go/g0201_0300/s0202_happy_number/readme.md

@@ -0,0 +1,25 @@
+package s0202_happy_number
+
+// #Easy #Top_Interview_Questions #Hash_Table #Math #Two_Pointers #Algorithm_II_Day_21_Others
+// #Programming_Skills_I_Day_4_Loop #Level_2_Day_1_Implementation/Simulation
+// #Top_Interview_150_Hashmap #2025_05_22_Time_0_ms_(100.00%)_Space_3.94_MB_(86.55%)
+
+func isHappy(n int) bool {
+	if n == 1 || n == 7 {
+		return true
+	}
+	if n > 1 && n < 10 {
+		return false
+	}
+	sum := 0
+	a := n
+	for a != 0 {
+		rem := a % 10
+		sum += rem * rem
+		a /= 10
+	}
+	if sum != 1 {
+		return isHappy(sum)
+	}
+	return true
+}