Added java and kotlin tasks 6, 7, 8, 9

src/main/java/g0001_0100/s0006_zigzag_conversion/Solution.java

@@ -0,0 +1,34 @@
+package g0001_0100.s0006_zigzag_conversion;
+
+// #Medium #String
+
+public class Solution {
+    public String convert(String s, int numRows) {
+        int sLen = s.length();
+        if (numRows == 1) {
+            return s;
+        }
+        int maxDist = numRows * 2 - 2;
+        StringBuilder buf = new StringBuilder();
+        for (int i = 0; i < numRows; i++) {
+            int index = i;
+            if (i == 0 || i == numRows - 1) {
+                while (index < sLen) {
+                    buf.append(s.charAt(index));
+                    index += maxDist;
+                }
+            } else {
+                while (index < sLen) {
+                    buf.append(s.charAt(index));
+                    index += maxDist - i * 2;
+                    if (index >= sLen) {
+                        break;
+                    }
+                    buf.append(s.charAt(index));
+                    index += i * 2;
+                }
+            }
+        }
+        return buf.toString();
+    }
+}

src/main/java/g0001_0100/s0006_zigzag_conversion/readme.md

@@ -0,0 +1,39 @@
+6\. Zigzag Conversion
+
+Medium
+
+The string `"PAYPALISHIRING"` is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
+
+P A H N A P L S I I G Y I R 
+
+And then read line by line: `"PAHNAPLSIIGYIR"`
+
+Write the code that will take a string and make this conversion given a number of rows:
+
+string convert(string s, int numRows); 
+
+**Example 1:**
+
+**Input:** s = "PAYPALISHIRING", numRows = 3
+
+**Output:** "PAHNAPLSIIGYIR" 
+
+**Example 2:**
+
+**Input:** s = "PAYPALISHIRING", numRows = 4
+
+**Output:** "PINALSIGYAHRPI"
+
+**Explanation:** P I N A L S I G Y A H R P I 
+
+**Example 3:**
+
+**Input:** s = "A", numRows = 1
+
+**Output:** "A" 
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s` consists of English letters (lower-case and upper-case), `','` and `'.'`.
+*   `1 <= numRows <= 1000`

src/main/java/g0001_0100/s0007_reverse_integer/Solution.java

@@ -0,0 +1,17 @@
+package g0001_0100.s0007_reverse_integer;
+
+// #Medium #Top_Interview_Questions #Math #Udemy_Integers
+
+public class Solution {
+    public int reverse(int x) {
+        long rev = 0;
+        while (x != 0) {
+            rev = (rev * 10) + (x % 10);
+            x /= 10;
+        }
+        if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE) {
+            return 0;
+        }
+        return (int) rev;
+    }
+}

src/main/java/g0001_0100/s0007_reverse_integer/readme.md

@@ -0,0 +1,35 @@
+7\. Reverse Integer
+
+Medium
+
+Given a signed 32-bit integer `x`, return `x` _with its digits reversed_. If reversing `x` causes the value to go outside the signed 32-bit integer range <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then return `0`.
+
+**Assume the environment does not allow you to store 64-bit integers (signed or unsigned).**
+
+**Example 1:**
+
+**Input:** x = 123
+
+**Output:** 321 
+
+**Example 2:**
+
+**Input:** x = -123
+
+**Output:** -321 
+
+**Example 3:**
+
+**Input:** x = 120
+
+**Output:** 21 
+
+**Example 4:**
+
+**Input:** x = 0
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code>

src/main/java/g0001_0100/s0008_string_to_integer_atoi/Solution.java

@@ -0,0 +1,43 @@
+package g0001_0100.s0008_string_to_integer_atoi;
+
+// #Medium #Top_Interview_Questions #String
+
+public class Solution {
+    public int myAtoi(String str) {
+        if (str == null || str.length() == 0) {
+            return 0;
+        }
+        int i = 0;
+        boolean negetiveSign = false;
+        char[] input = str.toCharArray();
+        while (i < input.length && input[i] == ' ') {
+            i++;
+        }
+        if (i == input.length) {
+            return 0;
+        } else if (input[i] == '+') {
+            i++;
+        } else if (input[i] == '-') {
+            i++;
+            negetiveSign = true;
+        }
+        int num = 0;
+        while (i < input.length && input[i] <= '9' && input[i] >= '0') {
+            // current char
+            int tem = input[i] - '0';
+            tem = negetiveSign ? -tem : tem;
+            // avoid invalid number like 038
+            if (num == 0 && tem == '0') {
+                i++;
+            } else if (num == Integer.MIN_VALUE / 10 && tem <= -8 || num < Integer.MIN_VALUE / 10) {
+                return Integer.MIN_VALUE;
+            } else if (num == Integer.MAX_VALUE / 10 && tem >= 7 || num > Integer.MAX_VALUE / 10) {
+                return Integer.MAX_VALUE;
+            } else {
+                num = num * 10 + tem;
+                i++;
+            }
+        }
+        return num;
+    }
+}

src/main/java/g0001_0100/s0008_string_to_integer_atoi/readme.md

@@ -0,0 +1,113 @@
+8\. String to Integer (atoi)
+
+Medium
+
+Implement the `myAtoi(string s)` function, which converts a string to a 32-bit signed integer (similar to C/C++'s `atoi` function).
+
+The algorithm for `myAtoi(string s)` is as follows:
+
+1.  Read in and ignore any leading whitespace.
+2.  Check if the next character (if not already at the end of the string) is `'-'` or `'+'`. Read this character in if it is either. This determines if the final result is negative or positive respectively. Assume the result is positive if neither is present.
+3.  Read in next the characters until the next non-digit character or the end of the input is reached. The rest of the string is ignored.
+4.  Convert these digits into an integer (i.e. `"123" -> 123`, `"0032" -> 32`). If no digits were read, then the integer is `0`. Change the sign as necessary (from step 2).
+5.  If the integer is out of the 32-bit signed integer range <code>[-2<sup>31</sup>, 2<sup>31</sup> - 1]</code>, then clamp the integer so that it remains in the range. Specifically, integers less than <code>-2<sup>31</sup></code> should be clamped to <code>-2<sup>31</sup></code>, and integers greater than <code>2<sup>31</sup> - 1</code> should be clamped to <code>2<sup>31</sup> - 1</code>.
+6.  Return the integer as the final result.
+
+**Note:**
+
+*   Only the space character `' '` is considered a whitespace character.
+*   **Do not ignore** any characters other than the leading whitespace or the rest of the string after the digits.
+
+**Example 1:**
+
+**Input:** s = "42"
+
+**Output:** 42
+
+**Explanation:** The underlined characters are what is read in, the caret is the current reader position.
+
+    Step 1: "42" (no characters read because there is no leading whitespace)
+             ^ 
+    Step 2: "42" (no characters read because there is neither a '-' nor '+')
+             ^
+    Step 3: "42" ("42" is read in)
+               ^
+
+The parsed integer is 42. Since 42 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is 42. 
+
+**Example 2:**
+
+**Input:** s = " -42"
+
+**Output:** -42
+
+**Explanation:**
+
+    Step 1: " -42" (leading whitespace is read and ignored)
+              ^ 
+    Step 2: " -42" ('-' is read, so the result should be negative)
+               ^
+    Step 3: " -42" ("42" is read in)
+                 ^
+    The parsed integer is -42.
+
+Since -42 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is -42. 
+
+**Example 3:**
+
+**Input:** s = "4193 with words"
+
+**Output:** 4193
+
+**Explanation:**
+
+    Step 1: "4193 with words" (no characters read because there is no leading whitespace)
+             ^
+    Step 2: "4193 with words" (no characters read because there is neither a '-' nor '+')
+             ^
+    Step 3: "4193 with words" ("4193" is read in; reading stops because the next character is a non-digit)
+                 ^ 
+    The parsed integer is 4193.
+
+Since 4193 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is 4193. 
+
+**Example 4:**
+
+**Input:** s = "words and 987"
+
+**Output:** 0
+
+**Explanation:**
+
+    Step 1: "words and 987" (no characters read because there is no leading whitespace)
+             ^
+    Step 2: "words and 987" (no characters read because there is neither a '-' nor '+')
+             ^
+    Step 3: "words and 987" (reading stops immediately because there is a non-digit 'w')
+             ^
+    The parsed integer is 0 because no digits were read.
+
+Since 0 is in the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is 0. 
+
+**Example 5:**
+
+**Input:** s = "-91283472332"
+
+**Output:** -2147483648
+
+**Explanation:**
+
+    Step 1: "-91283472332" (no characters read because there is no leading whitespace)
+            ^
+    Step 2: "-91283472332" ('-' is read, so the result should be negative)
+              ^
+    Step 3: "-91283472332" ("91283472332" is read in)
+                         ^
+    The parsed integer is -91283472332.
+
+Since -91283472332 is less than the lower bound of the range [-2<sup>31</sup>, 2<sup>31</sup> - 1], the final result is clamped to -2<sup>31</sup> = -2147483648.  
+
+**Constraints:**
+
+*   `0 <= s.length <= 200`
+*   `s` consists of English letters (lower-case and upper-case), digits (`0-9`), `' '`, `'+'`, `'-'`, and `'.'`.

src/main/java/g0001_0100/s0009_palindrome_number/Solution.java

@@ -0,0 +1,19 @@
+package g0001_0100.s0009_palindrome_number;
+
+// #Easy #Math #Udemy_Integers
+
+public class Solution {
+    public boolean isPalindrome(int x) {
+        if (x < 0) {
+            return false;
+        }
+        int rev = 0;
+        int localX = x;
+        while (localX > 0) {
+            rev *= 10;
+            rev += localX % 10;
+            localX /= 10;
+        }
+        return rev == x;
+    }
+}

src/main/java/g0001_0100/s0009_palindrome_number/readme.md

@@ -0,0 +1,41 @@
+9\. Palindrome Number
+
+Easy
+
+Given an integer `x`, return `true` if `x` is palindrome integer.
+
+An integer is a **palindrome** when it reads the same backward as forward. For example, `121` is palindrome while `123` is not.
+
+**Example 1:**
+
+**Input:** x = 121
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:** x = -121
+
+**Output:** false
+
+**Explanation:** From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome. 
+
+**Example 3:**
+
+**Input:** x = 10
+
+**Output:** false
+
+**Explanation:** Reads 01 from right to left. Therefore it is not a palindrome. 
+
+**Example 4:**
+
+**Input:** x = -101
+
+**Output:** false 
+
+**Constraints:**
+
+*   <code>-2<sup>31</sup> <= x <= 2<sup>31</sup> - 1</code>
+
+**Follow up:** Could you solve it without converting the integer to a string?

src/main/kotlin/g0001_0100/s0001_two_sum/Solution.kt

@@ -1,4 +1,4 @@
-package g0001_0100.s0001_two_sum;
+package g0001_0100.s0001_two_sum
 
 // #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table
 // #Data_Structure_I_Day_2_Array #Level_1_Day_13_Hashmap #Udemy_Arrays #Big_O_Time_O(n)_Space_O(n)

src/main/kotlin/g0001_0100/s0002_add_two_numbers/Solution.kt

@@ -1,4 +1,4 @@
-package g0001_0100.s0002_add_two_numbers;
+package g0001_0100.s0002_add_two_numbers
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Math #Linked_List #Recursion
 // #Data_Structure_II_Day_10_Linked_List #Programming_Skills_II_Day_15

src/main/kotlin/g0001_0100/s0003_longest_substring_without_repeating_characters/Solution.kt

@@ -1,4 +1,4 @@
-package g0001_0100.s0003_longest_substring_without_repeating_characters;
+package g0001_0100.s0003_longest_substring_without_repeating_characters
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Sliding_Window
 // #Algorithm_I_Day_6_Sliding_Window #Level_2_Day_14_Sliding_Window/Two_Pointer #Udemy_Strings

src/main/kotlin/g0001_0100/s0004_median_of_two_sorted_arrays/Solution.kt

@@ -1,4 +1,4 @@
-package g0001_0100.s0004_median_of_two_sorted_arrays;
+package g0001_0100.s0004_median_of_two_sorted_arrays
 
 // #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search #Divide_and_Conquer
 // #Big_O_Time_O(log(min(N,M)))_Space_O(1)

src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/Solution.kt

@@ -1,4 +1,4 @@
-package g0001_0100.s0005_longest_palindromic_substring;
+package g0001_0100.s0005_longest_palindromic_substring
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
 // #Data_Structure_II_Day_9_String #Algorithm_II_Day_14_Dynamic_Programming