Added tasks 43-58.

Author: javadev

README.md

@@ -37,6 +37,15 @@ Given a linked list, swap every two adjacent nodes and return its head. You must
 ```kotlin
 import com_github_leetcode.ListNode
 
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
 class Solution {
     fun swapPairs(head: ListNode?): ListNode? {
         if (head == null) {

src/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/readme.md

@@ -0,0 +1,84 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 43\. Multiply Strings
+
+Medium
+
+Given two non-negative integers `num1` and `num2` represented as strings, return the product of `num1` and `num2`, also represented as a string.
+
+**Note:** You must not use any built-in BigInteger library or convert the inputs to integer directly.
+
+**Example 1:**
+
+**Input:** num1 = "2", num2 = "3"
+
+**Output:** "6"
+
+**Example 2:**
+
+**Input:** num1 = "123", num2 = "456"
+
+**Output:** "56088"
+
+**Constraints:**
+
+*   `1 <= num1.length, num2.length <= 200`
+*   `num1` and `num2` consist of digits only.
+*   Both `num1` and `num2` do not contain any leading zero, except the number `0` itself.
+
+## Solution
+
+```kotlin
+class Solution {
+    private fun getIntArray(s: String): IntArray {
+        val chars = s.toCharArray()
+        val arr = IntArray(chars.size)
+        for (i in chars.indices) {
+            arr[i] = chars[i] - '0'
+        }
+        return arr
+    }
+
+    private fun convertToStr(res: IntArray, i: Int): String {
+        var index = i
+        val chars = StringBuffer()
+        while (index < res.size) {
+            chars.append(res[index].toString())
+            index++
+        }
+        System.out.println(chars)
+        return chars.toString()
+    }
+
+    fun multiply(num1: String, num2: String): String {
+        val arr1 = getIntArray(num1)
+        val arr2 = getIntArray(num2)
+        val res = IntArray(arr1.size + arr2.size)
+        var index = arr1.size + arr2.size - 1
+        for (i in arr2.indices.reversed()) {
+            var k = index--
+            for (j in arr1.indices.reversed()) {
+                res[k] += arr2[i] * arr1[j]
+                k--
+            }
+        }
+        index = arr1.size + arr2.size - 1
+        var carry = 0
+        for (i in index downTo 0) {
+            val temp = res[i] + carry
+            res[i] = temp % 10
+            carry = temp / 10
+        }
+        var i = 0
+        while (i < res.size && res[i] == 0) {
+            i++
+        }
+        return if (i > index) {
+            "0"
+        } else {
+            convertToStr(res, i)
+        }
+    }
+}
+```

src/main/kotlin/g0001_0100/s0043_multiply_strings/readme.md

@@ -0,0 +1,88 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 44\. Wildcard Matching
+
+Hard
+
+Given an input string (`s`) and a pattern (`p`), implement wildcard pattern matching with support for `'?'` and `'*'` where:
+
+*   `'?'` Matches any single character.
+*   `'*'` Matches any sequence of characters (including the empty sequence).
+
+The matching should cover the **entire** input string (not partial).
+
+**Example 1:**
+
+**Input:** s = "aa", p = "a"
+
+**Output:** false
+
+**Explanation:** "a" does not match the entire string "aa".
+
+**Example 2:**
+
+**Input:** s = "aa", p = "\*"
+
+**Output:** true
+
+**Explanation:** '\*' matches any sequence.
+
+**Example 3:**
+
+**Input:** s = "cb", p = "?a"
+
+**Output:** false
+
+**Explanation:** '?' matches 'c', but the second letter is 'a', which does not match 'b'.
+
+**Constraints:**
+
+*   `0 <= s.length, p.length <= 2000`
+*   `s` contains only lowercase English letters.
+*   `p` contains only lowercase English letters, `'?'` or `'*'`.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun isMatch(inputString: String, pattern: String): Boolean {
+        var i = 0
+        var j = 0
+        var starIdx = -1
+        var lastMatch = -1
+        while (i < inputString.length) {
+            if (j < pattern.length &&
+                (inputString[i] == pattern[j] || pattern[j] == '?')
+            ) {
+                i++
+                j++
+            } else if (j < pattern.length && pattern[j] == '*') {
+                starIdx = j
+                lastMatch = i
+                j++
+            } else if (starIdx != -1) {
+                // there is a no match and there was a previous star, we will reset the j to indx
+                // after star_index
+                // lastMatch will tell from which index we start comparing the string if we
+                // encounter * in pattern
+                j = starIdx + 1
+                // we are saying we included more characters in * so we incremented the
+                lastMatch++
+                // index
+                i = lastMatch
+            } else {
+                return false
+            }
+        }
+        var isMatch = true
+        while (j < pattern.length && pattern[j] == '*') {
+            j++
+        }
+        if (i != inputString.length || j != pattern.length) {
+            isMatch = false
+        }
+        return isMatch
+    }
+}
+```

src/main/kotlin/g0001_0100/s0044_wildcard_matching/readme.md

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 47\. Permutations II
+
+Medium
+
+Given a collection of numbers, `nums`, that might contain duplicates, return _all possible unique permutations **in any order**._
+
+**Example 1:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** [[1,1,2], [1,2,1], [2,1,1]]
+
+**Example 2:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 8`
+*   `-10 <= nums[i] <= 10`
+
+## Solution
+
+```kotlin
+class Solution {
+    private var ans: MutableList<List<Int>>? = null
+    fun permuteUnique(nums: IntArray): List<List<Int>> {
+        ans = ArrayList()
+        permute(nums, 0)
+        return ans as ArrayList<List<Int>>
+    }
+
+    private fun permute(nums: IntArray, p: Int) {
+        if (p >= nums.size - 1) {
+            val t: MutableList<Int> = ArrayList(nums.size)
+            for (n in nums) {
+                t.add(n)
+            }
+            ans!!.add(t)
+            return
+        }
+        permute(nums, p + 1)
+        val used = BooleanArray(30)
+        for (i in p + 1 until nums.size) {
+            if (nums[i] != nums[p] && !used[10 + nums[i]]) {
+                used[10 + nums[i]] = true
+                swap(nums, p, i)
+                permute(nums, p + 1)
+                swap(nums, p, i)
+            }
+        }
+    }
+
+    private fun swap(nums: IntArray, i: Int, j: Int) {
+        val t = nums[i]
+        nums[i] = nums[j]
+        nums[j] = t
+    }
+}
+```

src/main/kotlin/g0001_0100/s0047_permutations_ii/readme.md

@@ -0,0 +1,62 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 50\. Pow(x, n)
+
+Medium
+
+Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., <code>x<sup>n</sup></code>).
+
+**Example 1:**
+
+**Input:** x = 2.00000, n = 10
+
+**Output:** 1024.00000
+
+**Example 2:**
+
+**Input:** x = 2.10000, n = 3
+
+**Output:** 9.26100
+
+**Example 3:**
+
+**Input:** x = 2.00000, n = -2
+
+**Output:** 0.25000
+
+**Explanation:** 2<sup>\-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25
+
+**Constraints:**
+
+*   `-100.0 < x < 100.0`
+*   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code>
+*   `n` is an integer.
+*   <code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code>
+
+## Solution
+
+```kotlin
+class Solution {
+    fun myPow(x: Double, n: Int): Double {
+        var x = x
+        var nn = n.toLong()
+        var res = 1.0
+        if (n < 0) {
+            nn *= -1
+        }
+        while (nn > 0) {
+            if (nn % 2 == 1L) {
+                nn--
+                res *= x
+            } else {
+                x *= x
+                nn /= 2
+            }
+        }
+        return if (n < 0) {
+            1.0 / res
+        } else res
+    }
+}
+```

src/main/kotlin/g0001_0100/s0050_powx_n/readme.md

@@ -0,0 +1,72 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 52\. N-Queens II
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _the number of distinct solutions to the **n-queens puzzle**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Explanation:** There are two distinct solutions to the 4-queens puzzle as shown.
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= n <= 9`
+
+## Solution
+
+```kotlin
+class Solution {
+    fun totalNQueens(n: Int): Int {
+        val row = BooleanArray(n)
+        val col = BooleanArray(n)
+        val diagonal = BooleanArray(n + n - 1)
+        val antiDiagonal = BooleanArray(n + n - 1)
+        return totalNQueens(n, 0, row, col, diagonal, antiDiagonal)
+    }
+
+    private fun totalNQueens(
+        n: Int,
+        r: Int,
+        row: BooleanArray,
+        col: BooleanArray,
+        diagonal: BooleanArray,
+        antiDiagonal: BooleanArray
+    ): Int {
+        if (r == n) {
+            return 1
+        }
+        var count = 0
+        for (c in 0 until n) {
+            if (!row[r] && !col[c] && !diagonal[r + c] && !antiDiagonal[r - c + n - 1]) {
+                antiDiagonal[r - c + n - 1] = true
+                diagonal[r + c] = antiDiagonal[r - c + n - 1]
+                col[c] = diagonal[r + c]
+                row[r] = col[c]
+                count += totalNQueens(n, r + 1, row, col, diagonal, antiDiagonal)
+                antiDiagonal[r - c + n - 1] = false
+                diagonal[r + c] = antiDiagonal[r - c + n - 1]
+                col[c] = diagonal[r + c]
+                row[r] = col[c]
+            }
+        }
+        return count
+    }
+}
+```