Added tasks 6-1143

Author: javadev

README.md

@@ -42,7 +42,6 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 ```scala
 import com_github_leetcode.ListNode
 
-
 /*
  * Definition for singly-linked list.
  * class ListNode(_x: Int = 0, _next: ListNode = null) {

src/main/scala/g0001_0100/s0002_add_two_numbers/readme.md

@@ -0,0 +1,68 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 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`
+
+## Solution
+
+```scala
+import scala.collection.mutable
+
+object Solution {
+    def convert(s: String, numRows: Int): String = {
+        if (numRows == 1) return s
+        val map = new mutable.HashMap[Int, String]()
+        var string = ""
+        var counter = 0
+        var counterBool = true
+        for (i <- s) {
+            val currentValue = map.getOrElse(counter, "")
+            map(counter) = currentValue + i.toString
+            counterBool = if (counter == numRows - 1) false else if (counter == 0) true else counterBool
+            counter = if (counterBool) counter + 1 else counter - 1
+        }
+        map.foreach {
+            case (_, value) => string += value
+        }
+        string
+    }
+}
+```

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

@@ -0,0 +1,57 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 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>
+
+## Solution
+
+```scala
+object Solution {
+    def reverse(x: Int): Int = {
+        var rev: Long = 0
+        var remaining = x
+        while (remaining != 0) {
+            rev = (rev * 10) + (remaining % 10)
+            remaining /= 10
+        }
+        if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE) {
+            return 0
+        }
+        rev.toInt
+    }
+}
+```

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

@@ -0,0 +1,167 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 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 `'.'`.
+
+## Solution
+
+```scala
+object Solution {
+    @SuppressWarnings(Array("scala:S3776"))
+    def myAtoi(str: String): Int = {
+        if (str == null || str.isEmpty) {
+            return 0
+        }
+
+        var i = 0
+        var negativeSign = false
+        val input = str.toCharArray
+
+        while (i < input.length && input(i) == ' ') {
+            i += 1
+        }
+
+        if (i == input.length) {
+            return 0
+        } else if (input(i) == '+') {
+            i += 1
+        } else if (input(i) == '-') {
+            i += 1
+            negativeSign = true
+        }
+
+        var num = 0
+        while (i < input.length && input(i) <= '9' && input(i) >= '0') {
+            // current char
+            val temp = input(i) - '0'
+            val tempValue = if (negativeSign) -temp else temp
+
+            // avoid invalid numbers like 038
+            if (num == 0 && tempValue == 0) {
+                i += 1
+            } else if (num == Integer.MIN_VALUE / 10 && tempValue <= -8 || num < Integer.MIN_VALUE / 10) {
+                return Integer.MIN_VALUE
+            } else if (num == Integer.MAX_VALUE / 10 && tempValue >= 7 || num > Integer.MAX_VALUE / 10) {
+                return Integer.MAX_VALUE
+            } else {
+                num = num * 10 + tempValue
+                i += 1
+            }
+        }
+
+        num
+    }
+}
+```

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

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Scala/LeetCode-in-Scala?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala)
+[![](https://img.shields.io/github/forks/LeetCode-in-Scala/LeetCode-in-Scala?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Scala/LeetCode-in-Scala/fork)
+
+## 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?
+
+## Solution
+
+```scala
+object Solution {
+    def isPalindrome(x: Int): Boolean = {
+        if (x < 0) {
+            false
+        } else {
+            var rev = 0
+            var localX = x
+            while (localX > 0) {
+                rev *= 10
+                rev += localX % 10
+                localX /= 10
+            }
+            rev == x
+        }
+    }
+}
+```

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

@@ -41,6 +41,13 @@ Given the `head` of a linked list, return _the list after sorting it in **ascend
 ```scala
 import com_github_leetcode.ListNode
 
+/*
+ * Definition for singly-linked list.
+ * class ListNode(_x: Int = 0, _next: ListNode = null) {
+ *   var next: ListNode = _next
+ *   var x: Int = _x
+ * }
+ */
 object Solution {
     def sortList(head: ListNode): ListNode = {
         if (head == null || head.next == null) {