Added tasks 12-27

Author: ThanhNIT

src/main/python/g0001_0100/s0012_integer_to_roman/Solution0012.py

@@ -0,0 +1,45 @@
+# #Medium #String #Hash_Table #Math #Top_Interview_150_Array/String #Big_O_Time_O(1)_Space_O(1)
+# #2025_09_12_Time_0_ms_(100.00%)_Space_17.69_MB_(91.96%)
+
+class Solution:
+    def intToRoman(self, num: int) -> str:
+        sb: list[str] = []
+
+        def numerals(remaining: int, one: int, c_ten: str, c_five: str, c_one: str) -> int:
+            div = remaining // one
+            if div == 9:
+                sb.append(c_one)
+                sb.append(c_ten)
+            elif div == 8:
+                sb.append(c_five)
+                sb.append(c_one)
+                sb.append(c_one)
+                sb.append(c_one)
+            elif div == 7:
+                sb.append(c_five)
+                sb.append(c_one)
+                sb.append(c_one)
+            elif div == 6:
+                sb.append(c_five)
+                sb.append(c_one)
+            elif div == 5:
+                sb.append(c_five)
+            elif div == 4:
+                sb.append(c_one)
+                sb.append(c_five)
+            elif div == 3:
+                sb.append(c_one)
+                sb.append(c_one)
+                sb.append(c_one)
+            elif div == 2:
+                sb.append(c_one)
+                sb.append(c_one)
+            elif div == 1:
+                sb.append(c_one)
+            return remaining - (div * one)
+
+        num = numerals(num, 1000, ' ', ' ', 'M')
+        num = numerals(num, 100, 'M', 'D', 'C')
+        num = numerals(num, 10, 'C', 'L', 'X')
+        numerals(num, 1, 'X', 'V', 'I')
+        return "".join(sb)

src/main/python/g0001_0100/s0012_integer_to_roman/Solution0012_test.py

@@ -0,0 +1,20 @@
+import unittest
+from Solution0012 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_intToRoman(self):
+        self.assertEqual(Solution().intToRoman(3), "III")
+
+    def test_intToRoman2(self):
+        self.assertEqual(Solution().intToRoman(4), "IV")
+
+    def test_intToRoman3(self):
+        self.assertEqual(Solution().intToRoman(9), "IX")
+
+    def test_intToRoman4(self):
+        self.assertEqual(Solution().intToRoman(58), "LVIII")
+
+    def test_intToRoman5(self):
+        self.assertEqual(Solution().intToRoman(1994), "MCMXCIV")
+
+

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

@@ -0,0 +1,62 @@
+12\. Integer to Roman
+
+Medium
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+    Symbol   Value
+     I        1
+     V        5
+     X        10
+     L        50
+     C        100
+     D        500
+     M        1000
+
+For example, `2` is written as `II` in Roman numeral, just two one's added together. `12` is written as `XII`, which is simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+*   `I` can be placed before `V` (5) and `X` (10) to make 4 and 9.
+*   `X` can be placed before `L` (50) and `C` (100) to make 40 and 90.
+*   `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given an integer, convert it to a roman numeral.
+
+**Example 1:**
+
+**Input:** num = 3
+
+**Output:** "III" 
+
+**Example 2:**
+
+**Input:** num = 4
+
+**Output:** "IV" 
+
+**Example 3:**
+
+**Input:** num = 9
+
+**Output:** "IX" 
+
+**Example 4:**
+
+**Input:** num = 58
+
+**Output:** "LVIII"
+
+**Explanation:** L = 50, V = 5, III = 3. 
+
+**Example 5:**
+
+**Input:** num = 1994
+
+**Output:** "MCMXCIV"
+
+**Explanation:** M = 1000, CM = 900, XC = 90 and IV = 4. 
+
+**Constraints:**
+
+*   `1 <= num <= 3999`

src/main/python/g0001_0100/s0013_roman_to_integer/Solution0013.py

@@ -0,0 +1,33 @@
+# #Easy #Top_Interview_Questions #String #Hash_Table #Math #Top_Interview_150_Array/String
+# #Big_O_Time_O(n)_Space_O(1) #2025_09_12_Time_1_ms_(86.91%)_Space_17.75_MB_(64.49%)
+
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        x = 0
+        for i, ch in enumerate(s):
+            if ch == 'I':
+                x = self._accumulate(s, x, i, 1, 'V', 'X')
+            elif ch == 'V':
+                x += 5
+            elif ch == 'X':
+                x = self._accumulate(s, x, i, 10, 'L', 'C')
+            elif ch == 'L':
+                x += 50
+            elif ch == 'C':
+                x = self._accumulate(s, x, i, 100, 'D', 'M')
+            elif ch == 'D':
+                x += 500
+            elif ch == 'M':
+                x += 1000
+        return x
+
+    def _accumulate(self, s: str, x: int, i: int, unit: int, five: str, ten: str) -> int:
+        if i + 1 == len(s):
+            x += unit
+        elif s[i + 1] == five:
+            x -= unit
+        elif s[i + 1] == ten:
+            x -= unit
+        else:
+            x += unit
+        return x

src/main/python/g0001_0100/s0013_roman_to_integer/Solution0013_test.py

@@ -0,0 +1,18 @@
+import unittest
+from Solution0013 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_romanToInt(self):
+        self.assertEqual(Solution().romanToInt("III"), 3)
+
+    def test_romanToInt2(self):
+        self.assertEqual(Solution().romanToInt("IV"), 4)
+
+    def test_romanToInt3(self):
+        self.assertEqual(Solution().romanToInt("IX"), 9)
+
+    def test_romanToInt4(self):
+        self.assertEqual(Solution().romanToInt("LVIII"), 58)
+
+    def test_romanToInt5(self):
+        self.assertEqual(Solution().romanToInt("MCMXCIV"), 1994)

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

@@ -0,0 +1,64 @@
+13\. Roman to Integer
+
+Easy
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+    Symbol  Value
+     I       1
+     V       5
+     X       10
+     L       50
+     C       100
+     D       500
+     M       1000
+
+For example, `2` is written as `II` in Roman numeral, just two one's added together. `12` is written as `XII`, which is simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+*   `I` can be placed before `V` (5) and `X` (10) to make 4 and 9.
+*   `X` can be placed before `L` (50) and `C` (100) to make 40 and 90.
+*   `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given a roman numeral, convert it to an integer.
+
+**Example 1:**
+
+**Input:** s = "III"
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** s = "IV"
+
+**Output:** 4 
+
+**Example 3:**
+
+**Input:** s = "IX"
+
+**Output:** 9 
+
+**Example 4:**
+
+**Input:** s = "LVIII"
+
+**Output:** 58
+
+**Explanation:** L = 50, V= 5, III = 3. 
+
+**Example 5:**
+
+**Input:** s = "MCMXCIV"
+
+**Output:** 1994
+
+**Explanation:** M = 1000, CM = 900, XC = 90 and IV = 4. 
+
+**Constraints:**
+
+*   `1 <= s.length <= 15`
+*   `s` contains only the characters `('I', 'V', 'X', 'L', 'C', 'D', 'M')`.
+*   It is **guaranteed** that `s` is a valid roman numeral in the range `[1, 3999]`.

src/main/python/g0001_0100/s0014_longest_common_prefix/Solution0014.py

@@ -0,0 +1,23 @@
+# #Easy #Top_Interview_Questions #String #Level_2_Day_2_String #Udemy_Strings
+# #Top_Interview_150_Array/String #Big_O_Time_O(n*m)_Space_O(m)
+# #2025_09_12_Time_0_ms_(100.00%)_Space_17.73_MB_(78.70%)
+
+from typing import List
+
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        if len(strs) < 1:
+            return ""
+        if len(strs) == 1:
+            return strs[0]
+        temp = strs[0]
+        i = 1
+        while temp and i < len(strs):
+            if len(temp) > len(strs[i]):
+                temp = temp[: len(strs[i])]
+            cur = strs[i][: len(temp)]
+            if cur != temp:
+                temp = temp[: len(temp) - 1]
+            else:
+                i += 1
+        return temp

src/main/python/g0001_0100/s0014_longest_common_prefix/Solution0014_test.py

@@ -0,0 +1,9 @@
+import unittest
+from Solution0014 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_longestCommonPrefix(self):
+        self.assertEqual(Solution().longestCommonPrefix(["flower", "flow", "flight"]), "fl")
+
+    def test_longestCommonPrefix2(self):
+        self.assertEqual(Solution().longestCommonPrefix(["dog", "racecar", "car"]), "")

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

@@ -0,0 +1,27 @@
+14\. Longest Common Prefix
+
+Easy
+
+Write a function to find the longest common prefix string amongst an array of strings.
+
+If there is no common prefix, return an empty string `""`.
+
+**Example 1:**
+
+**Input:** strs = ["flower","flow","flight"]
+
+**Output:** "fl" 
+
+**Example 2:**
+
+**Input:** strs = ["dog","racecar","car"]
+
+**Output:** ""
+
+**Explanation:** There is no common prefix among the input strings. 
+
+**Constraints:**
+
+*   `1 <= strs.length <= 200`
+*   `0 <= strs[i].length <= 200`
+*   `strs[i]` consists of only lower-case English letters.

src/main/python/g0001_0100/s0026_remove_duplicates_from_sorted_array/Solution0026.py

@@ -0,0 +1,18 @@
+# #Easy #Top_Interview_Questions #Array #Two_Pointers #Udemy_Two_Pointers
+# #Top_Interview_150_Array/String #2025_09_12_Time_0_ms_(100.00%)_Space_18.78_MB_(94.72%)
+
+from typing import List
+
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        n = len(nums)
+        i = 0
+        j = 1
+        if n <= 1:
+            return n
+        while j <= n - 1:
+            if nums[i] != nums[j]:
+                nums[i + 1] = nums[j]
+                i += 1
+            j += 1
+        return i + 1