Added tasks 58-63

Author: ThanhNIT

README.md

@@ -0,0 +1,13 @@
+# #Easy #String #Programming_Skills_II_Day_6 #Udemy_Arrays #Top_Interview_150_Array/String
+# #2025_09_13_Time_0_ms_(100.00%)_Space_12.78_MB_(7.53%)
+
+class Solution:
+    def lengthOfLastWord(self, s: str) -> int:
+        length = 0
+        for i in range(len(s) - 1, -1, -1):
+            ch = s[i]
+            if ch == ' ' and length > 0:
+                break
+            elif ch != ' ':
+                length += 1
+        return length

src/main/python/g0001_0100/s0058_length_of_last_word/Solution0058.py

@@ -0,0 +1,12 @@
+import unittest
+from Solution0058 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_lengthOfLastWord(self):
+        self.assertEqual(Solution().lengthOfLastWord("Hello World"), 5)
+
+    def test_lengthOfLastWord2(self):
+        self.assertEqual(Solution().lengthOfLastWord("   fly me   to   the moon  "), 4)
+
+    def test_lengthOfLastWord3(self):
+        self.assertEqual(Solution().lengthOfLastWord("luffy is still joyboy"), 6)

src/main/python/g0001_0100/s0058_length_of_last_word/Solution0058_test.py

@@ -0,0 +1,37 @@
+58\. Length of Last Word
+
+Easy
+
+Given a string `s` consisting of some words separated by some number of spaces, return _the length of the **last** word in the string._
+
+A **word** is a maximal substring consisting of non-space characters only.
+
+**Example 1:**
+
+**Input:** s = "Hello World"
+
+**Output:** 5
+
+**Explanation:** The last word is "World" with length 5. 
+
+**Example 2:**
+
+**Input:** s = " fly me to the moon "
+
+**Output:** 4
+
+**Explanation:** The last word is "moon" with length 4. 
+
+**Example 3:**
+
+**Input:** s = "luffy is still joyboy"
+
+**Output:** 6
+
+**Explanation:** The last word is "joyboy" with length 6. 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of only English letters and spaces `' '`.
+*   There will be at least one word in `s`.

src/main/python/g0001_0100/s0058_length_of_last_word/readme.md

@@ -0,0 +1,35 @@
+# #Medium #Two_Pointers #Linked_List #Programming_Skills_II_Day_16 #Udemy_Linked_List
+# #Top_Interview_150_Linked_List #2025_09_13_Time_0_ms_(100.00%)_Space_12.50_MB_(74.08%)
+
+from typing import Optional
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
+        if head is None or k == 0:
+            return head
+        tail = head
+        # find the count and let tail points to last node
+        count = 1
+        while tail is not None and tail.next is not None:
+            count += 1
+            tail = tail.next
+        # calculate number of times to rotate by count modulas
+        times = k % count
+        if times == 0:
+            return head
+        temp = head
+        # iterate and go to the K+1 th node from the end or count - K - 1 node from start
+        for i in range(1, count - times):
+            if temp is not None:
+                temp = temp.next
+        new_head = None
+        if temp is not None and tail is not None:
+            new_head = temp.next
+            temp.next = None
+            tail.next = head
+        return new_head

src/main/python/g0001_0100/s0061_rotate_list/Solution0061.py

@@ -0,0 +1,31 @@
+import unittest
+from Solution0061 import Solution, ListNode
+
+class SolutionTest(unittest.TestCase):
+    def test_rotateRight(self):
+        head = ListNode(1)
+        head.next = ListNode(2)
+        head.next.next = ListNode(3)
+        head.next.next.next = ListNode(4)
+        head.next.next.next.next = ListNode(5)
+        result = Solution().rotateRight(head, 2)
+        # Convert to list for comparison
+        result_list = []
+        current = result
+        while current:
+            result_list.append(current.val)
+            current = current.next
+        self.assertEqual(result_list, [4, 5, 1, 2, 3])
+
+    def test_rotateRight2(self):
+        head = ListNode(0)
+        head.next = ListNode(1)
+        head.next.next = ListNode(2)
+        result = Solution().rotateRight(head, 4)
+        # Convert to list for comparison
+        result_list = []
+        current = result
+        while current:
+            result_list.append(current.val)
+            current = current.next
+        self.assertEqual(result_list, [2, 0, 1])

src/main/python/g0001_0100/s0061_rotate_list/Solution0061_test.py

@@ -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/python/g0001_0100/s0061_rotate_list/readme.md

@@ -0,0 +1,30 @@
+# #Medium #Array #Dynamic_Programming #Matrix #Dynamic_Programming_I_Day_15
+# #Top_Interview_150_Multidimensional_DP #2025_09_13_Time_0_ms_(100.00%)_Space_12.44_MB_(66.99%)
+
+from typing import List
+
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        # if start point has obstacle, there's no path
+        if obstacleGrid[0][0] == 1:
+            return 0
+        obstacleGrid[0][0] = 1
+        m = len(obstacleGrid)
+        n = len(obstacleGrid[0])
+        for i in range(1, m):
+            if obstacleGrid[i][0] == 1:
+                obstacleGrid[i][0] = 0
+            else:
+                obstacleGrid[i][0] = obstacleGrid[i - 1][0]
+        for j in range(1, n):
+            if obstacleGrid[0][j] == 1:
+                obstacleGrid[0][j] = 0
+            else:
+                obstacleGrid[0][j] = obstacleGrid[0][j - 1]
+        for i in range(1, m):
+            for j in range(1, n):
+                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/python/g0001_0100/s0063_unique_paths_ii/Solution0063.py

@@ -0,0 +1,15 @@
+import unittest
+from Solution0063 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_uniquePathsWithObstacles(self):
+        obstacle_grid = [
+            [0, 0, 0],
+            [0, 1, 0],
+            [0, 0, 0]
+        ]
+        self.assertEqual(Solution().uniquePathsWithObstacles(obstacle_grid), 2)
+
+    def test_uniquePathsWithObstacles2(self):
+        obstacle_grid = [[0, 1], [0, 0]]
+        self.assertEqual(Solution().uniquePathsWithObstacles(obstacle_grid), 1)

src/main/python/g0001_0100/s0063_unique_paths_ii/Solution0063_test.py

@@ -0,0 +1,36 @@
+63\. Unique Paths II
+
+Medium
+
+A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+Now consider if some obstacles are added to the grids. How many unique paths would there be?
+
+An obstacle and space is marked as `1` and `0` respectively in the grid.
+
+**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`.