Added tasks 12-54

Author: javadev

README.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 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`
+
+## Solution
+
+```typescript
+function intToRoman(num: number): string {
+    const values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
+    const symbols = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
+    let result = ''
+    let i = 0
+    while (num > 0) {
+        if (num >= values[i]) {
+            result += symbols[i]
+            num -= values[i]
+        } else {
+            i++
+        }
+    }
+    return result
+}
+
+export { intToRoman }
+```

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

@@ -0,0 +1,118 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 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]`.
+
+## Solution
+
+```typescript
+function romanToInt(s: string): number {
+    let x = 0
+    let y: string
+    for (let i = 0; i < s.length; i++) {
+        y = s.charAt(i)
+        switch (y) {
+            case 'I':
+                x = getX(s, x, i, 1, 'V', 'X')
+                break
+            case 'V':
+                x += 5
+                break
+            case 'X':
+                x = getX(s, x, i, 10, 'L', 'C')
+                break
+            case 'L':
+                x += 50
+                break
+            case 'C':
+                x = getX(s, x, i, 100, 'D', 'M')
+                break
+            case 'D':
+                x += 500
+                break
+            case 'M':
+                x += 1000
+                break
+            default:
+                break
+        }
+    }
+    return x
+}
+
+function getX(s: string, x: number, i: number, i2: number, v: string, x2: string): number {
+    if (i + 1 === s.length) {
+        x += i2
+    } else if (s.charAt(i + 1) === v || s.charAt(i + 1) === x2) {
+        x -= i2
+    } else {
+        x += i2
+    }
+    return x
+}
+
+export { romanToInt }
+```

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

@@ -0,0 +1,60 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 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.
+
+## Solution
+
+```typescript
+function longestCommonPrefix(strs: string[]): string {
+    if (strs.length < 1) {
+        return ''
+    }
+    if (strs.length === 1) {
+        return strs[0]
+    }
+    let temp = strs[0]
+    let i = 1
+    let cur: string
+    while (temp.length > 0 && i < strs.length) {
+        if (temp.length > strs[i].length) {
+            temp = temp.substring(0, strs[i].length)
+        }
+        cur = strs[i].substring(0, temp.length)
+        if (cur !== temp) {
+            temp = temp.substring(0, temp.length - 1)
+        } else {
+            i++
+        }
+    }
+    return temp
+}
+
+export { longestCommonPrefix }
+```

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

@@ -0,0 +1,75 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Stars&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript)
+[![](https://img.shields.io/github/forks/LeetCode-in-TypeScript/LeetCode-in-TypeScript?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-TypeScript/LeetCode-in-TypeScript/fork)
+
+## 26\. Remove Duplicates from Sorted Array
+
+Easy
+
+Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**.
+
+Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+
+Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
+
+Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+
+**Custom Judge:**
+
+The judge will test your solution with the following code:
+
+    int[] nums = [...]; // Input array
+    int[] expectedNums = [...]; // The expected answer with correct length
+
+    int k = removeDuplicates(nums); // Calls your implementation
+
+    assert k == expectedNums.length;
+    for (int i = 0; i < k; i++) {
+        assert nums[i] == expectedNums[i];
+    } 
+
+If all assertions pass, then your solution will be **accepted**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** 2, nums = [1,2,\_]
+
+**Explanation:** Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively. It does not matter what you leave beyond the returned k (hence they are underscores). 
+
+**Example 2:**
+
+**Input:** nums = [0,0,1,1,1,2,2,3,3,4]
+
+**Output:** 5, nums = [0,1,2,3,4,\_,\_,\_,\_,\_]
+
+**Explanation:** Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively. It does not matter what you leave beyond the returned k (hence they are underscores). 
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   `-100 <= nums[i] <= 100`
+*   `nums` is sorted in **non-decreasing** order.
+
+## Solution
+
+```typescript
+function removeDuplicates(nums: number[]): number {
+    let n = nums.length
+    let i = 0
+    let j = 1
+    if (n <= 1) {
+        return n
+    }
+    while (j <= n - 1) {
+        if (nums[i] !== nums[j]) {
+            nums[i + 1] = nums[j]
+            i++
+        }
+        j++
+    }
+    return i + 1
+}
+
+export { removeDuplicates }
+```