Added tasks 467, 468, 470, 472.

Author: ThanhNIT

README.md

@@ -1640,6 +1640,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 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
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
+| 0472 |[Concatenated Words](src/main/kotlin/g0401_0500/s0472_concatenated_words/Solution.kt)| Hard | Array, String, Dynamic_Programming, Depth_First_Search, Trie | 484 | 100.00
+| 0470 |[Implement Rand10() Using Rand7()](src/main/kotlin/g0401_0500/s0470_implement_rand10_using_rand7/Solution.kt)| Medium | Math, Randomized, Probability_and_Statistics, Rejection_Sampling | 220 | 100.00
+| 0468 |[Validate IP Address](src/main/kotlin/g0401_0500/s0468_validate_ip_address/Solution.kt)| |||
+| 0467 |[Unique Substrings in Wraparound String](src/main/kotlin/g0401_0500/s0467_unique_substrings_in_wraparound_string/Solution.kt)| Medium | String, Dynamic_Programming | 197 | 100.00
 | 0466 |[Count The Repetitions](src/main/kotlin/g0401_0500/s0466_count_the_repetitions/Solution.kt)| Hard | String, Dynamic_Programming | 147 | 100.00
 | 0464 |[Can I Win](src/main/kotlin/g0401_0500/s0464_can_i_win/Solution.kt)| Medium | Dynamic_Programming, Math, Bit_Manipulation, Bitmask, Memoization, Game_Theory | 213 | 100.00
 | 0463 |[Island Perimeter](src/main/kotlin/g0401_0500/s0463_island_perimeter/Solution.kt)| Easy | Array, Depth_First_Search, Breadth_First_Search, Matrix | 381 | 98.04

src/main/kotlin/g0401_0500/s0467_unique_substrings_in_wraparound_string/Solution.kt

@@ -0,0 +1,27 @@
+package g0401_0500.s0467_unique_substrings_in_wraparound_string
+
+// #Medium #String #Dynamic_Programming #2022_12_29_Time_197_ms_(100.00%)_Space_35.7_MB_(100.00%)
+
+class Solution {
+    fun findSubstringInWraproundString(p: String): Int {
+        val str = p.toCharArray()
+        val n = str.size
+        val map = IntArray(26)
+        var len = 0
+        for (i in 0 until n) {
+            if (i > 0 && (str[i - 1].code + 1 == str[i].code || str[i - 1] == 'z' && str[i] == 'a')) {
+                len += 1
+            } else {
+                len = 1
+            }
+            // we are storing the max len of string for each letter and then we will count all these
+            // length.
+            map[str[i].code - 'a'.code] = Math.max(map[str[i].code - 'a'.code], len)
+        }
+        var answer = 0
+        for (num in map) {
+            answer += num
+        }
+        return answer
+    }
+}

src/main/kotlin/g0401_0500/s0467_unique_substrings_in_wraparound_string/readme.md

@@ -0,0 +1,38 @@
+467\. Unique Substrings in Wraparound String
+
+Medium
+
+We define the string `base` to be the infinite wraparound string of `"abcdefghijklmnopqrstuvwxyz"`, so `base` will look like this:
+
+*   `"...zabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcd...."`.
+
+Given a string `s`, return _the number of **unique non-empty substrings** of_ `s` _are present in_ `base`.
+
+**Example 1:**
+
+**Input:** s = "a"
+
+**Output:** 1
+
+**Explanation:** Only the substring "a" of s is in base.
+
+**Example 2:**
+
+**Input:** s = "cac"
+
+**Output:** 2
+
+**Explanation:** There are two substrings ("a", "c") of s in base.
+
+**Example 3:**
+
+**Input:** s = "zab"
+
+**Output:** 6
+
+**Explanation:** There are six substrings ("z", "a", "b", "za", "ab", and "zab") of s in base.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

src/main/kotlin/g0401_0500/s0468_validate_ip_address/Solution.kt

@@ -0,0 +1,48 @@
+package g0401_0500.s0468_validate_ip_address
+
+// #Medium #String #2022_12_29_Time_192_ms_(62.50%)_Space_35.9_MB_(87.50%)
+
+class Solution {
+    fun validIPAddress(ip: String): String {
+        if (ip.length == 0) {
+            return NEITHER
+        }
+        val arr = ip.split("\\.".toRegex()).toTypedArray()
+        val arr1 = ip.split(":".toRegex()).toTypedArray()
+        if (arr.size == 4) {
+            for (num in arr) {
+                try {
+                    if (num.length > 1 && num.startsWith("0") || num.toInt() > 255) {
+                        return NEITHER
+                    }
+                } catch (e: Exception) {
+                    return NEITHER
+                }
+            }
+            return "IPv4"
+        } else if (arr1.size == 8) {
+            for (num in arr1) {
+                if (num.length < 1 || num.length > 4) {
+                    return NEITHER
+                }
+                for (j in 0 until num.length) {
+                    val ch = num[j]
+                    if (ch.code > 9 &&
+                        (
+                            Character.isLowerCase(ch) && ch > 'f' ||
+                                Character.isUpperCase(ch) && ch > 'F'
+                            )
+                    ) {
+                        return NEITHER
+                    }
+                }
+            }
+            return "IPv6"
+        }
+        return NEITHER
+    }
+
+    companion object {
+        private const val NEITHER = "Neither"
+    }
+}

src/main/kotlin/g0401_0500/s0468_validate_ip_address/readme.md

@@ -0,0 +1,43 @@
+468\. Validate IP Address
+
+Medium
+
+Given a string `queryIP`, return `"IPv4"` if IP is a valid IPv4 address, `"IPv6"` if IP is a valid IPv6 address or `"Neither"` if IP is not a correct IP of any type.
+
+**A valid IPv4** address is an IP in the form <code>"x<sub>1</sub>.x<sub>2</sub>.x<sub>3</sub>.x<sub>4</sub>"</code> where <code>0 <= x<sub>i</sub> <= 255</code> and <code>x<sub>i</sub></code> **cannot contain** leading zeros. For example, `"192.168.1.1"` and `"192.168.1.0"` are valid IPv4 addresses while `"192.168.01.1"`, `"192.168.1.00"`, and `"192.168@1.1"` are invalid IPv4 addresses.
+
+**A valid IPv6** address is an IP in the form <code>"x<sub>1</sub>:x<sub>2</sub>:x<sub>3</sub>:x<sub>4</sub>:x<sub>5</sub>:x<sub>6</sub>:x<sub>7</sub>:x<sub>8</sub>"</code> where:
+
+*   <code>1 <= x<sub>i</sub>.length <= 4</code>
+*   <code>x<sub>i</sub></code> is a **hexadecimal string** which may contain digits, lowercase English letter (`'a'` to `'f'`) and upper-case English letters (`'A'` to `'F'`).
+*   Leading zeros are allowed in <code>x<sub>i</sub></code>.
+
+For example, "`2001:0db8:85a3:0000:0000:8a2e:0370:7334"` and "`2001:db8:85a3:0:0:8A2E:0370:7334"` are valid IPv6 addresses, while "`2001:0db8:85a3::8A2E:037j:7334"` and "`02001:0db8:85a3:0000:0000:8a2e:0370:7334"` are invalid IPv6 addresses.
+
+**Example 1:**
+
+**Input:** queryIP = "172.16.254.1"
+
+**Output:** "IPv4"
+
+**Explanation:** This is a valid IPv4 address, return "IPv4".
+
+**Example 2:**
+
+**Input:** queryIP = "2001:0db8:85a3:0:0:8A2E:0370:7334"
+
+**Output:** "IPv6"
+
+**Explanation:** This is a valid IPv6 address, return "IPv6".
+
+**Example 3:**
+
+**Input:** queryIP = "256.256.256.256"
+
+**Output:** "Neither"
+
+**Explanation:** This is neither a IPv4 address nor a IPv6 address.
+
+**Constraints:**
+
+*   `queryIP` consists only of English letters, digits and the characters `'.'` and `':'`.

src/main/kotlin/g0401_0500/s0470_implement_rand10_using_rand7/Solution.kt

@@ -0,0 +1,29 @@
+package g0401_0500.s0470_implement_rand10_using_rand7
+
+// #Medium #Math #Randomized #Probability_and_Statistics #Rejection_Sampling
+// #2022_12_29_Time_220_ms_(100.00%)_Space_38_MB_(80.00%)
+
+import java.util.Random
+
+/*
+ * The rand7() API is already defined in the parent class SolBase.
+ * fun rand7(): Int {}
+ * @return a random integer in the range 1 to 7
+ */
+@Suppress("kotlin:S2245")
+class Solution {
+    private val random: Random = Random()
+    fun rand10(): Int {
+        var r1 = 0
+        do {
+            var r2 = 0
+            do { r2 = rand7() } while (r2 == 7)
+            if (r2 in 1..3) { r1 = rand7() } else { r1 = 7 + rand7() }
+        } while (r1 > 10)
+        return r1
+    }
+
+    private fun rand7(): Int {
+        return random.nextInt(7) + 1
+    }
+}

src/main/kotlin/g0401_0500/s0470_implement_rand10_using_rand7/readme.md

@@ -0,0 +1,34 @@
+470\. Implement Rand10() Using Rand7()
+
+Medium
+
+Given the **API** `rand7()` that generates a uniform random integer in the range `[1, 7]`, write a function `rand10()` that generates a uniform random integer in the range `[1, 10]`. You can only call the API `rand7()`, and you shouldn't call any other API. Please **do not** use a language's built-in random API.
+
+Each test case will have one **internal** argument `n`, the number of times that your implemented function `rand10()` will be called while testing. Note that this is **not an argument** passed to `rand10()`.
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** [2]
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** [2,8]
+
+**Example 3:**
+
+**Input:** n = 3
+
+**Output:** [3,8,10]
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+
+**Follow up:**
+
+*   What is the [expected value](https://en.wikipedia.org/wiki/Expected_value) for the number of calls to `rand7()` function?
+*   Could you minimize the number of calls to `rand7()`?

src/main/kotlin/g0401_0500/s0472_concatenated_words/Solution.kt

@@ -0,0 +1,67 @@
+package g0401_0500.s0472_concatenated_words
+
+// #Hard #Array #String #Dynamic_Programming #Depth_First_Search #Trie
+// #2022_12_29_Time_484_ms_(100.00%)_Space_48_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    private val ans: MutableList<String> = ArrayList()
+    private var root: Trie? = null
+    fun findAllConcatenatedWordsInADict(words: Array<String>): List<String> {
+        root = Trie()
+        Arrays.sort(
+            words
+        ) { a: String, b: String ->
+            Integer.compare(
+                a.length,
+                b.length
+            )
+        }
+        for (word in words) {
+            var ptr = root
+            if (search(word, 0, 0)) {
+                ans.add(word)
+            } else {
+                for (j in 0 until word.length) {
+                    if (ptr!!.nxt[word[j].code - 'a'.code] == null) {
+                        ptr.nxt[word[j].code - 'a'.code] = Trie()
+                    }
+                    ptr = ptr.nxt[word[j].code - 'a'.code]
+                }
+                ptr!!.endHere = true
+            }
+        }
+        return ans
+    }
+
+    private fun search(cur: String, idx: Int, wordCnt: Int): Boolean {
+        if (idx == cur.length) {
+            return wordCnt >= 2
+        }
+        var ptr = root
+        for (i in idx until cur.length) {
+            if (ptr!!.nxt[cur[i].code - 'a'.code] == null) {
+                return false
+            }
+            if (ptr.nxt[cur[i].code - 'a'.code]!!.endHere) {
+                val ret = search(cur, i + 1, wordCnt + 1)
+                if (ret) {
+                    return true
+                }
+            }
+            ptr = ptr.nxt[cur[i].code - 'a'.code]
+        }
+        return ptr!!.endHere && wordCnt >= 2
+    }
+
+    private class Trie internal constructor() {
+        var nxt: Array<Trie?>
+        var endHere: Boolean
+
+        init {
+            nxt = arrayOfNulls(26)
+            endHere = false
+        }
+    }
+}

src/main/kotlin/g0401_0500/s0472_concatenated_words/readme.md

@@ -0,0 +1,29 @@
+472\. Concatenated Words
+
+Hard
+
+Given an array of strings `words` (**without duplicates**), return _all the **concatenated words** in the given list of_ `words`.
+
+A **concatenated word** is defined as a string that is comprised entirely of at least two shorter words in the given array.
+
+**Example 1:**
+
+**Input:** words = ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]
+
+**Output:** ["catsdogcats","dogcatsdog","ratcatdogcat"]
+
+**Explanation:** "catsdogcats" can be concatenated by "cats", "dog" and "cats"; "dogcatsdog" can be concatenated by "dog", "cats" and "dog"; "ratcatdogcat" can be concatenated by "rat", "cat", "dog" and "cat".
+
+**Example 2:**
+
+**Input:** words = ["cat","dog","catdog"]
+
+**Output:** ["catdog"]
+
+**Constraints:**
+
+*   <code>1 <= words.length <= 10<sup>4</sup></code>
+*   `1 <= words[i].length <= 30`
+*   `words[i]` consists of only lowercase English letters.
+*   All the strings of `words` are **unique**.
+*   <code>1 <= sum(words[i].length) <= 10<sup>5</sup></code>

src/test/kotlin/g0401_0500/s0467_unique_substrings_in_wraparound_string/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0401_0500.s0467_unique_substrings_in_wraparound_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findSubstringInWraproundString() {
+        assertThat(Solution().findSubstringInWraproundString("a"), equalTo(1))
+    }
+
+    @Test
+    fun findSubstringInWraproundString2() {
+        assertThat(Solution().findSubstringInWraproundString("cac"), equalTo(2))
+    }
+
+    @Test
+    fun findSubstringInWraproundString3() {
+        assertThat(Solution().findSubstringInWraproundString("zab"), equalTo(6))
+    }
+}

src/test/kotlin/g0401_0500/s0468_validate_ip_address/SolutionTest.kt

@@ -0,0 +1,25 @@
+package g0401_0500.s0468_validate_ip_address
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun validIPAddress() {
+        assertThat(Solution().validIPAddress("172.16.254.1"), equalTo("IPv4"))
+    }
+
+    @Test
+    fun validIPAddress2() {
+        assertThat(
+            Solution().validIPAddress("2001:0db8:85a3:0:0:8A2E:0370:7334"),
+            equalTo("IPv6")
+        )
+    }
+
+    @Test
+    fun validIPAddress3() {
+        assertThat(Solution().validIPAddress("256.256.256.256"), equalTo("Neither"))
+    }
+}