Added tasks 61-82

Author: ThanhNIT

README.md

@@ -0,0 +1,6 @@
+package list_node
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}

src/main/go/com_github_leetcode/list_node/list_node.go

@@ -0,0 +1,27 @@
+61\. Rotate List
+
+Medium
+
+Given the `head` of a linked list, rotate the list to the right by `k` places.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 2
+
+**Output:** [4,5,1,2,3]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg)
+
+**Input:** head = [0,1,2], k = 4
+
+**Output:** [2,0,1]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 500]`.
+*   `-100 <= Node.val <= 100`
+*   <code>0 <= k <= 2 * 10<sup>9</sup></code>

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

@@ -0,0 +1,42 @@
+package s0061_rotate_list
+
+// #Medium #Two_Pointers #Linked_List #Programming_Skills_II_Day_16 #Udemy_Linked_List
+// #Top_Interview_150_Linked_List #2025_03_04_Time_0_ms_(100.00%)_Space_42.42_MB_(78.37%)
+
+import (
+	"github.com/LeetCode-in-Go/LeetCode-in-Go/src/main/go/com_github_leetcode/list_node"
+)
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func rotateRight(head *list_node.ListNode, k int) *list_node.ListNode {
+	if head == nil || k == 0 {
+		return head
+	}
+	tail := head
+	count := 1
+	for tail != nil && tail.Next != nil {
+		count++
+		tail = tail.Next
+	}
+	times := k % count
+	if times == 0 {
+		return head
+	}
+	temp := head
+	for i := 1; i <= count-times-1 && temp != nil; i++ {
+		temp = temp.Next
+	}
+	var newHead *list_node.ListNode
+	if temp != nil && tail != nil {
+		newHead = temp.Next
+		temp.Next = nil
+		tail.Next = head
+	}
+	return newHead
+}

src/main/go/g0001_0100/s0061_rotate_list/solution.go

@@ -0,0 +1,26 @@
+package s0061_rotate_list
+
+import (
+	"testing"
+
+	"github.com/LeetCode-in-Go/LeetCode-in-Go/src/main/go/com_github_leetcode/list_node"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRotateRight(t *testing.T) {
+	head := &list_node.ListNode{Val: 1, Next: &list_node.ListNode{Val: 2, Next: &list_node.ListNode{Val: 3, Next: &list_node.ListNode{Val: 4, Next: &list_node.ListNode{Val: 5}}}}}
+	result := rotateRight(head, 2)
+	assert.Equal(t, 4, result.Val)
+	assert.Equal(t, 5, result.Next.Val)
+	assert.Equal(t, 1, result.Next.Next.Val)
+	assert.Equal(t, 2, result.Next.Next.Next.Val)
+	assert.Equal(t, 3, result.Next.Next.Next.Next.Val)
+}
+
+func TestRotateRight2(t *testing.T) {
+	head := &list_node.ListNode{Val: 0, Next: &list_node.ListNode{Val: 1, Next: &list_node.ListNode{Val: 2}}}
+	result := rotateRight(head, 4)
+	assert.Equal(t, 2, result.Val)
+	assert.Equal(t, 0, result.Next.Val)
+	assert.Equal(t, 1, result.Next.Next.Val)
+}

src/main/go/g0001_0100/s0061_rotate_list/solution_test.go

@@ -0,0 +1,42 @@
+63\. Unique Paths II
+
+Medium
+
+You are given an `m x n` integer array `grid`. There is a robot initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m-1][n-1]`). The robot can only move either down or right at any point in time.
+
+An obstacle and space are marked as `1` or `0` respectively in `grid`. A path that the robot takes cannot include **any** square that is an obstacle.
+
+Return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The testcases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg)
+
+**Input:** obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+
+**Output:** 2
+
+**Explanation:** There is one obstacle in the middle of the 3x3 grid above. 
+
+There are two ways to reach the bottom-right corner: 
+
+1. Right -> Right -> Down -> Down 
+
+2. Down -> Down -> Right -> Right
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg)
+
+**Input:** obstacleGrid = [[0,1],[0,0]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `m == obstacleGrid.length`
+*   `n == obstacleGrid[i].length`
+*   `1 <= m, n <= 100`
+*   `obstacleGrid[i][j]` is `0` or `1`.

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

@@ -0,0 +1,37 @@
+package s0063_unique_paths_ii
+
+// #Medium #Array #Dynamic_Programming #Matrix #Dynamic_Programming_I_Day_15
+// #Top_Interview_150_Multidimensional_DP #2025_05_14_Time_0_ms_(100.00%)_Space_4.14_MB_(96.06%)
+
+func uniquePathsWithObstacles(obstacleGrid [][]int) int {
+	if obstacleGrid[0][0] == 1 {
+		return 0
+	}
+	obstacleGrid[0][0] = 1
+	m := len(obstacleGrid)
+	n := len(obstacleGrid[0])
+	for i := 1; i < m; i++ {
+		if obstacleGrid[i][0] == 1 {
+			obstacleGrid[i][0] = 0
+		} else {
+			obstacleGrid[i][0] = obstacleGrid[i-1][0]
+		}
+	}
+	for j := 1; j < n; j++ {
+		if obstacleGrid[0][j] == 1 {
+			obstacleGrid[0][j] = 0
+		} else {
+			obstacleGrid[0][j] = obstacleGrid[0][j-1]
+		}
+	}
+	for i := 1; i < m; i++ {
+		for j := 1; j < n; j++ {
+			if obstacleGrid[i][j] == 1 {
+				obstacleGrid[i][j] = 0
+			} else {
+				obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1]
+			}
+		}
+	}
+	return obstacleGrid[m-1][n-1]
+}

src/main/go/g0001_0100/s0063_unique_paths_ii/solution.go

@@ -0,0 +1,24 @@
+package s0063_unique_paths_ii
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUniquePathsWithObstacles(t *testing.T) {
+	obstacleGrid := [][]int{
+		{0, 0, 0},
+		{0, 1, 0},
+		{0, 0, 0},
+	}
+	assert.Equal(t, 2, uniquePathsWithObstacles(obstacleGrid))
+}
+
+func TestUniquePathsWithObstacles2(t *testing.T) {
+	obstacleGrid := [][]int{
+		{0, 1},
+		{0, 0},
+	}
+	assert.Equal(t, 1, uniquePathsWithObstacles(obstacleGrid))
+}

src/main/go/g0001_0100/s0063_unique_paths_ii/solution_test.go

@@ -0,0 +1,55 @@
+66\. Plus One
+
+Easy
+
+You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the <code>i<sup>th</sup></code> digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0`'s.
+
+Increment the large integer by one and return _the resulting array of digits_.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3]
+
+**Output:** [1,2,4]
+
+**Explanation:** 
+
+The array represents the integer 123. 
+
+Incrementing by one gives 123 + 1 = 124. 
+
+Thus, the result should be [1,2,4].
+
+**Example 2:**
+
+**Input:** digits = [4,3,2,1]
+
+**Output:** [4,3,2,2]
+
+**Explanation:** 
+
+The array represents the integer 4321. 
+
+Incrementing by one gives 4321 + 1 = 4322. 
+
+Thus, the result should be [4,3,2,2].
+
+**Example 3:**
+
+**Input:** digits = [9]
+
+**Output:** [1,0]
+
+**Explanation:** 
+
+The array represents the integer 9. 
+
+Incrementing by one gives 9 + 1 = 10. 
+
+Thus, the result should be [1,0].
+
+**Constraints:**
+
+*   `1 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`
+*   `digits` does not contain any leading `0`'s.

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

@@ -0,0 +1,26 @@
+package s0066_plus_one
+
+// #Easy #Top_Interview_Questions #Array #Math #Programming_Skills_II_Day_3 #Udemy_Arrays
+// #Top_Interview_150_Math #2025_05_14_Time_0_ms_(100.00%)_Space_3.99_MB_(76.14%)
+
+func plusOne(digits []int) []int {
+	num := 1
+	carry := 0
+	var sum int
+	for i := len(digits) - 1; i >= 0; i-- {
+		if i == len(digits)-1 {
+			sum = digits[i] + carry + num
+		} else {
+			sum = digits[i] + carry
+		}
+		carry = sum / 10
+		digits[i] = sum % 10
+	}
+	if carry != 0 {
+		ans := make([]int, len(digits)+1)
+		ans[0] = carry
+		copy(ans[1:], digits)
+		return ans
+	}
+	return digits
+}