Added tasks 222-392

Author: ThanhNIT

README.md

@@ -0,0 +1,35 @@
+222\. Count Complete Tree Nodes
+
+Medium
+
+Given the `root` of a **complete** binary tree, return the number of the nodes in the tree.
+
+According to **[Wikipedia](http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees)**, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between `1` and <code>2<sup>h</sup></code> nodes inclusive at the last level `h`.
+
+Design an algorithm that runs in less than `O(n)` time complexity.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/14/complete.jpg)
+
+**Input:** root = [1,2,3,4,5,6]
+
+**Output:** 6
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** 0
+
+**Example 3:**
+
+**Input:** root = [1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 5 * 10<sup>4</sup></code>
+*   The tree is guaranteed to be **complete**.

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

@@ -0,0 +1,40 @@
+package s0222_count_complete_tree_nodes
+
+// #Easy #Depth_First_Search #Tree #Binary_Search #Binary_Tree #Binary_Search_II_Day_10
+// #Top_Interview_150_Binary_Tree_General #2025_05_24_Time_0_ms_(100.00%)_Space_9.18_MB_(74.02%)
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func countNodes(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	leftHeight := leftHeight(root)
+	rightHeight := rightHeight(root)
+	// case 1: When Height(Left sub-tree) = Height(right sub-tree) 2^h - 1
+	if leftHeight == rightHeight {
+		return (1 << leftHeight) - 1
+	} else {
+		return 1 + countNodes(root.Left) + countNodes(root.Right)
+	}
+}
+
+func leftHeight(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	return 1 + leftHeight(root.Left)
+}
+
+func rightHeight(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	return 1 + rightHeight(root.Right)
+}

src/main/go/g0201_0300/s0222_count_complete_tree_nodes/solution.go

@@ -0,0 +1,51 @@
+package s0222_count_complete_tree_nodes
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestCountNodes(t *testing.T) {
+	root := &TreeNode{
+		Val: 1,
+		Left: &TreeNode{
+			Val: 2,
+			Left: &TreeNode{
+				Val: 4,
+			},
+			Right: &TreeNode{
+				Val: 5,
+			},
+		},
+		Right: &TreeNode{
+			Val: 3,
+			Left: &TreeNode{
+				Val: 6,
+			},
+		},
+	}
+	assert.Equal(t, 6, countNodes(root))
+}
+
+func TestCountNodes2(t *testing.T) {
+	root := &TreeNode{
+		Val: 1,
+		Left: &TreeNode{
+			Val: 2,
+			Left: &TreeNode{
+				Val: 4,
+			},
+			Right: &TreeNode{
+				Val: 5,
+			},
+		},
+		Right: &TreeNode{
+			Val: 3,
+		},
+	}
+	assert.Equal(t, 5, countNodes(root))
+}
+
+func TestCountNodes3(t *testing.T) {
+	assert.Equal(t, 0, countNodes(nil))
+}

src/main/go/g0201_0300/s0222_count_complete_tree_nodes/solution_test.go

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

src/main/go/g0201_0300/s0222_count_complete_tree_nodes/tree_node.go

@@ -0,0 +1,53 @@
+228\. Summary Ranges
+
+Easy
+
+You are given a **sorted unique** integer array `nums`.
+
+Return _the **smallest sorted** list of ranges that **cover all the numbers in the array exactly**_. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`.
+
+Each range `[a,b]` in the list should be output as:
+
+*   `"a->b"` if `a != b`
+*   `"a"` if `a == b`
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,4,5,7]
+
+**Output:** ["0->2","4->5","7"]
+
+**Explanation:** The ranges are: [0,2] --> "0->2" [4,5] --> "4->5" [7,7] --> "7"
+
+**Example 2:**
+
+**Input:** nums = [0,2,3,4,6,8,9]
+
+**Output:** ["0","2->4","6","8->9"]
+
+**Explanation:** The ranges are: [0,0] --> "0" [2,4] --> "2->4" [6,6] --> "6" [8,9] --> "8->9"
+
+**Example 3:**
+
+**Input:** nums = []
+
+**Output:** []
+
+**Example 4:**
+
+**Input:** nums = [-1]
+
+**Output:** ["-1"]
+
+**Example 5:**
+
+**Input:** nums = [0]
+
+**Output:** ["0"]
+
+**Constraints:**
+
+*   `0 <= nums.length <= 20`
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   All the values of `nums` are **unique**.
+*   `nums` is sorted in ascending order.

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

@@ -0,0 +1,52 @@
+package s0228_summary_ranges
+
+// #Easy #Array #Top_Interview_150_Intervals #2025_05_24_Time_0_ms_(100.00%)_Space_3.94_MB_(33.05%)
+
+import (
+	"fmt"
+)
+
+func summaryRanges(nums []int) []string {
+	ranges := make([]string, 0)
+	if len(nums) == 0 {
+		return ranges
+	}
+	// size of array
+	n := len(nums)
+	// start of range
+	a := nums[0]
+	// end of range
+	b := a
+	for i := 1; i < n; i++ {
+		// we need to make a decision if the next element
+		// will expand the range
+		// i starts at 1, not 0, because 1 is the next
+		// candidate for expanding the range
+		if nums[i] != b+1 {
+			// only when our next element does not expand the range
+			// do we add the range a->b to our list of ranges
+			if a == b {
+				ranges = append(ranges, fmt.Sprintf("%d", a))
+			} else {
+				ranges = append(ranges, fmt.Sprintf("%d->%d", a, b))
+			}
+			// since nums[i] is not accounted for by our range a->b
+			// because nums[i] is not b+1, we need to set a and b
+			// to this new range start point of bigger than b+1
+			// maybe it is b+2? b+3? b+4? all we know is it is not b+1
+			a = nums[i]
+			b = a
+		} else {
+			// if the next element expands our range we do so
+			b++
+		}
+	}
+	// the only range that is not accounted for at this point is the last range
+	// if our a and b are not equal then we add the range accordingly
+	if a == b {
+		ranges = append(ranges, fmt.Sprintf("%d", a))
+	} else {
+		ranges = append(ranges, fmt.Sprintf("%d->%d", a, b))
+	}
+	return ranges
+}

src/main/go/g0201_0300/s0228_summary_ranges/solution.go

@@ -0,0 +1,24 @@
+package s0228_summary_ranges
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSummaryRanges(t *testing.T) {
+	nums := []int{0, 1, 2, 4, 5, 7}
+	expected := []string{"0->2", "4->5", "7"}
+	assert.Equal(t, expected, summaryRanges(nums))
+}
+
+func TestSummaryRanges2(t *testing.T) {
+	nums := []int{0, 2, 3, 4, 6, 8, 9}
+	expected := []string{"0", "2->4", "6", "8->9"}
+	assert.Equal(t, expected, summaryRanges(nums))
+}
+
+func TestSummaryRanges3(t *testing.T) {
+	nums := []int{}
+	expected := []string{}
+	assert.Equal(t, expected, summaryRanges(nums))
+}

src/main/go/g0201_0300/s0228_summary_ranges/solution_test.go

@@ -0,0 +1,26 @@
+242\. Valid Anagram
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if_ `t` _is an anagram of_ `s`_, and_ `false` _otherwise_.
+
+An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+**Example 1:**
+
+**Input:** s = "anagram", t = "nagaram"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "rat", t = "car"
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= s.length, t.length <= 5 * 10<sup>4</sup></code>
+*   `s` and `t` consist of lowercase English letters.
+
+**Follow up:** What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

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

@@ -0,0 +1,22 @@
+package s0242_valid_anagram
+
+// #Easy #String #Hash_Table #Sorting #Data_Structure_I_Day_6_String
+// #Programming_Skills_I_Day_11_Containers_and_Libraries #Udemy_Strings #Top_Interview_150_Hashmap
+// #2025_05_24_Time_0_ms_(100.00%)_Space_4.81_MB_(36.79%)
+
+func isAnagram(s string, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	charFreqMap := make([]int, 26)
+	for _, c := range s {
+		charFreqMap[c-'a']++
+	}
+	for _, c := range t {
+		if charFreqMap[c-'a'] == 0 {
+			return false
+		}
+		charFreqMap[c-'a']--
+	}
+	return true
+}