Added tasks 564, 565, 566, 567

Author: ThanhNIT

README.md

@@ -89,6 +89,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0566 |[Reshape the Matrix](src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/Solution.kt)| Easy | Array, Matrix, Simulation | 239 | 99.05
 
 #### Day 8 String
 
@@ -849,6 +850,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0566 |[Reshape the Matrix](src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/Solution.kt)| Easy | Array, Matrix, Simulation | 239 | 99.05
 | 0118 |[Pascal's Triangle](src.save/main/kotlin/g0101_0200/s0118_pascals_triangle/Solution.kt)| Easy | Top_Interview_Questions, Array, Dynamic_Programming | 277 | 33.22
 
 #### Day 5 Array
@@ -1112,6 +1114,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0003 |[Longest Substring Without Repeating Characters](src.save/main/kotlin/g0001_0100/s0003_longest_substring_without_repeating_characters/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Sliding_Window | 258 | 91.09
+| 0567 |[Permutation in String](src/main/kotlin/g0501_0600/s0567_permutation_in_string/Solution.kt)| Medium | String, Hash_Table, Two_Pointers, Sliding_Window | 169 | 100.00
 
 #### Day 7 Breadth First Search Depth First Search
 
@@ -1655,6 +1658,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0567 |[Permutation in String](src/main/kotlin/g0501_0600/s0567_permutation_in_string/Solution.kt)| Medium | String, Hash_Table, Two_Pointers, Sliding_Window, Algorithm_I_Day_6_Sliding_Window | 169 | 100.00
+| 0566 |[Reshape the Matrix](src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/Solution.kt)| Easy | Array, Matrix, Simulation, Data_Structure_I_Day_4_Array, Programming_Skills_I_Day_7_Array | 239 | 99.05
+| 0565 |[Array Nesting](src/main/kotlin/g0501_0600/s0565_array_nesting/Solution.kt)| Medium | Array, Depth_First_Search | 553 | 100.00
+| 0564 |[Find the Closest Palindrome](src/main/kotlin/g0501_0600/s0564_find_the_closest_palindrome/Solution.kt)| Hard | String, Math | 179 | 100.00
 | 0563 |[Binary Tree Tilt](src/main/kotlin/g0501_0600/s0563_binary_tree_tilt/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree | 197 | 100.00
 | 0561 |[Array Partition](src/main/kotlin/g0501_0600/s0561_array_partition_i/Solution.kt)| Easy | Array, Sorting, Greedy, Counting_Sort | 337 | 90.48
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27

src/main/kotlin/g0501_0600/s0564_find_the_closest_palindrome/Solution.kt

@@ -0,0 +1,54 @@
+package g0501_0600.s0564_find_the_closest_palindrome
+
+// #Hard #String #Math #2023_01_21_Time_179_ms_(100.00%)_Space_33.7_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun nearestPalindromic(n: String): String {
+        if (n.length == 1) {
+            return (n.toInt() - 1).toString()
+        }
+        val num = n.toLong()
+        val offset = Math.pow(10.0, (n.length / 2).toDouble()).toInt()
+        val first =
+            if (isPalindrome(n)) palindromeGenerator(num + offset, n.length) else palindromeGenerator(num, n.length)
+        val second = if (first < num) palindromeGenerator(num + offset, n.length) else palindromeGenerator(
+            num - offset,
+            n.length
+        )
+        if (first + second == 2 * num) {
+            return if (first < second) first.toString() else second.toString()
+        }
+        return if (Math.abs(num - first) > Math.abs(num - second)) second.toString() else first.toString()
+    }
+
+    private fun palindromeGenerator(num: Long, length: Int): Long {
+        var num = num
+        if (num < 10) {
+            return 9
+        }
+        val numOfDigits = num.toString().length
+        if (numOfDigits > length) {
+            return Math.pow(10.0, (numOfDigits - 1).toDouble()).toLong() + 1
+        } else if (numOfDigits < length) {
+            return Math.pow(10.0, numOfDigits.toDouble()).toLong() - 1
+        }
+        num = num - num % Math.pow(10.0, (numOfDigits / 2).toDouble()).toLong()
+        var temp = num
+        for (j in 0 until numOfDigits / 2) {
+            val digit = Math.pow(10.0, (numOfDigits - j - 1).toDouble()).toLong()
+            num += (temp / digit * Math.pow(10.0, j.toDouble())).toInt().toLong()
+            temp = temp % digit
+        }
+        return num
+    }
+
+    private fun isPalindrome(str: String): Boolean {
+        for (i in 0 until str.length / 2) {
+            if (str[i] != str[str.length - 1 - i]) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g0501_0600/s0564_find_the_closest_palindrome/readme.md

@@ -0,0 +1,28 @@
+564\. Find the Closest Palindrome
+
+Hard
+
+Given a string `n` representing an integer, return _the closest integer (not including itself), which is a palindrome_. If there is a tie, return _**the smaller one**_.
+
+The closest is defined as the absolute difference minimized between two integers.
+
+**Example 1:**
+
+**Input:** n = "123"
+
+**Output:** "121"
+
+**Example 2:**
+
+**Input:** n = "1"
+
+**Output:** "0"
+
+**Explanation:** 0 and 2 are the closest palindromes but we return the smallest which is 0.
+
+**Constraints:**
+
+*   `1 <= n.length <= 18`
+*   `n` consists of only digits.
+*   `n` does not have leading zeros.
+*   `n` is representing an integer in the range <code>[1, 10<sup>18</sup> - 1]</code>.

src/main/kotlin/g0501_0600/s0565_array_nesting/Solution.kt

@@ -0,0 +1,26 @@
+package g0501_0600.s0565_array_nesting
+
+// #Medium #Array #Depth_First_Search #2023_01_21_Time_553_ms_(100.00%)_Space_52.8_MB_(100.00%)
+
+class Solution {
+    fun arrayNesting(nums: IntArray): Int {
+        var index: Int
+        var value: Int
+        var maxLen = 0
+        var len: Int
+        for (i in nums.indices) {
+            if (nums[i] != -1) {
+                index = i
+                len = 0
+                while (nums[index] != -1) {
+                    value = nums[index]
+                    nums[index] = -1
+                    index = value
+                    len++
+                }
+                maxLen = Math.max(len, maxLen)
+            }
+        }
+        return maxLen
+    }
+}

src/main/kotlin/g0501_0600/s0565_array_nesting/readme.md

@@ -0,0 +1,33 @@
+565\. Array Nesting
+
+Medium
+
+You are given an integer array `nums` of length `n` where `nums` is a permutation of the numbers in the range `[0, n - 1]`.
+
+You should build a set `s[k] = {nums[k], nums[nums[k]], nums[nums[nums[k]]], ... }` subjected to the following rule:
+
+*   The first element in `s[k]` starts with the selection of the element `nums[k]` of `index = k`.
+*   The next element in `s[k]` should be `nums[nums[k]]`, and then `nums[nums[nums[k]]]`, and so on.
+*   We stop adding right before a duplicate element occurs in `s[k]`.
+
+Return _the longest length of a set_ `s[k]`.
+
+**Example 1:**
+
+**Input:** nums = [5,4,0,3,1,6,2]
+
+**Output:** 4
+
+**Explanation:** nums[0] = 5, nums[1] = 4, nums[2] = 0, nums[3] = 3, nums[4] = 1, nums[5] = 6, nums[6] = 2. One of the longest sets s[k]: s[0] = {nums[0], nums[5], nums[6], nums[2]} = {5, 6, 2, 0}
+
+**Example 2:**
+
+**Input:** nums = [0,1,2]
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   `0 <= nums[i] < nums.length`
+*   All the values of `nums` are **unique**.

src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/Solution.kt

@@ -0,0 +1,27 @@
+package g0501_0600.s0566_reshape_the_matrix
+
+// #Easy #Array #Matrix #Simulation #Data_Structure_I_Day_4_Array #Programming_Skills_I_Day_7_Array
+// #2023_01_23_Time_239_ms_(99.05%)_Space_36.7_MB_(99.05%)
+
+class Solution {
+    fun matrixReshape(mat: Array<IntArray>, r: Int, c: Int): Array<IntArray> {
+        if (mat.size * mat[0].size != r * c) {
+            return mat
+        }
+        var p = 0
+        val flatArr = IntArray(mat.size * mat[0].size)
+        for (ints in mat) {
+            for (anInt in ints) {
+                flatArr[p++] = anInt
+            }
+        }
+        val ansMat = Array(r) { IntArray(c) }
+        var k = 0
+        for (i in ansMat.indices) {
+            for (j in ansMat[i].indices) {
+                ansMat[i][j] = flatArr[k++]
+            }
+        }
+        return ansMat
+    }
+}

src/main/kotlin/g0501_0600/s0566_reshape_the_matrix/readme.md

@@ -0,0 +1,35 @@
+566\. Reshape the Matrix
+
+Easy
+
+In MATLAB, there is a handy function called `reshape` which can reshape an `m x n` matrix into a new one with a different size `r x c` keeping its original data.
+
+You are given an `m x n` matrix `mat` and two integers `r` and `c` representing the number of rows and the number of columns of the wanted reshaped matrix.
+
+The reshaped matrix should be filled with all the elements of the original matrix in the same row-traversing order as they were.
+
+If the `reshape` operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/04/24/reshape1-grid.jpg)
+
+**Input:** mat = [[1,2],[3,4]], r = 1, c = 4
+
+**Output:** [[1,2,3,4]]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/04/24/reshape2-grid.jpg)
+
+**Input:** mat = [[1,2],[3,4]], r = 2, c = 4
+
+**Output:** [[1,2],[3,4]]
+
+**Constraints:**
+
+*   `m == mat.length`
+*   `n == mat[i].length`
+*   `1 <= m, n <= 100`
+*   `-1000 <= mat[i][j] <= 1000`
+*   `1 <= r, c <= 300`

src/main/kotlin/g0501_0600/s0567_permutation_in_string/Solution.kt

@@ -0,0 +1,42 @@
+package g0501_0600.s0567_permutation_in_string
+
+// #Medium #String #Hash_Table #Two_Pointers #Sliding_Window #Algorithm_I_Day_6_Sliding_Window
+// #2023_01_23_Time_169_ms_(100.00%)_Space_35.6_MB_(85.86%)
+
+class Solution {
+    fun checkInclusion(s1: String, s2: String): Boolean {
+        val n = s1.length
+        val m = s2.length
+        if (n > m) {
+            return false
+        }
+        val cntS1 = IntArray(26)
+        val cntS2 = IntArray(26)
+        for (i in 0 until n) {
+            cntS1[s1[i].code - 'a'.code]++
+        }
+        for (i in 0 until n) {
+            cntS2[s2[i].code - 'a'.code]++
+        }
+        if (check(cntS1, cntS2)) {
+            return true
+        }
+        for (i in n until m) {
+            cntS2[s2[i - n].code - 'a'.code]--
+            cntS2[s2[i].code - 'a'.code]++
+            if (check(cntS1, cntS2)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun check(cnt1: IntArray, cnt2: IntArray): Boolean {
+        for (i in 0..25) {
+            if (cnt1[i] != cnt2[i]) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g0501_0600/s0567_permutation_in_string/readme.md

@@ -0,0 +1,26 @@
+567\. Permutation in String
+
+Medium
+
+Given two strings `s1` and `s2`, return `true` _if_ `s2` _contains a permutation of_ `s1`_, or_ `false` _otherwise_.
+
+In other words, return `true` if one of `s1`'s permutations is the substring of `s2`.
+
+**Example 1:**
+
+**Input:** s1 = "ab", s2 = "eidbaooo"
+
+**Output:** true
+
+**Explanation:** s2 contains one permutation of s1 ("ba").
+
+**Example 2:**
+
+**Input:** s1 = "ab", s2 = "eidboaoo"
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= s1.length, s2.length <= 10<sup>4</sup></code>
+*   `s1` and `s2` consist of lowercase English letters.

src/test/kotlin/g0501_0600/s0564_find_the_closest_palindrome/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0501_0600.s0564_find_the_closest_palindrome
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun nearestPalindromic() {
+        assertThat(Solution().nearestPalindromic("123"), equalTo("121"))
+    }
+
+    @Test
+    fun nearestPalindromic2() {
+        assertThat(Solution().nearestPalindromic("1"), equalTo("0"))
+    }
+}