Added tasks 822, 823, 824, 825

Author: ThanhNIT

README.md

@@ -1712,6 +1712,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.10'
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
+| 0825 |[Friends Of Appropriate Ages](src/main/kotlin/g0801_0900/s0825_friends_of_appropriate_ages/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers | 278 | 100.00
+| 0824 |[Goat Latin](src/main/kotlin/g0801_0900/s0824_goat_latin/Solution.kt)| Easy | String | 146 | 100.00
+| 0823 |[Binary Trees With Factors](src/main/kotlin/g0801_0900/s0823_binary_trees_with_factors/Solution.kt)| Medium | Array, Hash_Table, Dynamic_Programming | 298 | 100.00
+| 0822 |[Card Flipping Game](src/main/kotlin/g0801_0900/s0822_card_flipping_game/Solution.kt)| Medium | Array, Hash_Table | 186 | 100.00
 | 0821 |[Shortest Distance to a Character](src/main/kotlin/g0801_0900/s0821_shortest_distance_to_a_character/Solution.kt)| Easy | Array, String, Two_Pointers | 168 | 88.00
 | 0820 |[Short Encoding of Words](src/main/kotlin/g0801_0900/s0820_short_encoding_of_words/Solution.kt)| Medium | Array, String, Hash_Table, Trie | 231 | 100.00
 | 0819 |[Most Common Word](src/main/kotlin/g0801_0900/s0819_most_common_word/Solution.kt)| Easy | String, Hash_Table, Counting | 211 | 83.33

src/main/kotlin/g0801_0900/s0822_card_flipping_game/Solution.kt

@@ -0,0 +1,47 @@
+package g0801_0900.s0822_card_flipping_game
+
+// #Medium #Array #Hash_Table #2023_03_25_Time_186_ms_(100.00%)_Space_41.2_MB_(33.33%)
+
+class Solution {
+    fun flipgame(fronts: IntArray, backs: IntArray): Int {
+        val max = findMax(fronts, backs)
+        var value = 10000
+        val twinCardHash = IntArray(max + 1)
+        val existingNumbersHash = IntArray(max + 1)
+        for (i in fronts.indices) {
+            if (fronts[i] == backs[i]) {
+                twinCardHash[fronts[i]]++
+            }
+            existingNumbersHash[fronts[i]]++
+            existingNumbersHash[backs[i]]++
+        }
+        for (i in 1..max) {
+            if (twinCardHash[i] == 0 && i < value && existingNumbersHash[i] != 0) {
+                value = i
+                break
+            }
+        }
+        return if (value == 10000) {
+            0
+        } else {
+            value
+        }
+    }
+
+    companion object {
+        private fun findMax(fronts: IntArray, backs: IntArray): Int {
+            var max = 0
+            for (front in fronts) {
+                if (max < front) {
+                    max = front
+                }
+            }
+            for (back in backs) {
+                if (max < back) {
+                    max = back
+                }
+            }
+            return max
+        }
+    }
+}

src/main/kotlin/g0801_0900/s0822_card_flipping_game/readme.md

@@ -0,0 +1,37 @@
+822\. Card Flipping Game
+
+Medium
+
+You are given two **0-indexed** integer arrays `fronts` and `backs` of length `n`, where the <code>i<sup>th</sup></code> card has the positive integer `fronts[i]` printed on the front and `backs[i]` printed on the back. Initially, each card is placed on a table such that the front number is facing up and the other is facing down. You may flip over any number of cards (possibly zero).
+
+After flipping the cards, an integer is considered **good** if it is facing down on some card and **not** facing up on any card.
+
+Return _the minimum possible good integer after flipping the cards_. If there are no good integers, return `0`.
+
+**Example 1:**
+
+**Input:** fronts = [1,2,4,4,7], backs = [1,3,4,1,3]
+
+**Output:** 2
+
+**Explanation:**
+
+If we flip the second card, the face up numbers are [1,3,4,4,7] and the face down are [1,2,4,1,3]. 
+
+2 is the minimum good integer as it appears facing down but not facing up. 
+
+It can be shown that 2 is the minimum possible good integer obtainable after flipping some cards.
+
+**Example 2:**
+
+**Input:** fronts = [1], backs = [1]
+
+**Output:** 0
+
+**Explanation:** There are no good integers no matter how we flip the cards, so we return 0.
+
+**Constraints:**
+
+*   `n == fronts.length == backs.length`
+*   `1 <= n <= 1000`
+*   `1 <= fronts[i], backs[i] <= 2000`

src/main/kotlin/g0801_0900/s0823_binary_trees_with_factors/Solution.kt

@@ -0,0 +1,49 @@
+package g0801_0900.s0823_binary_trees_with_factors
+
+// #Medium #Array #Hash_Table #Dynamic_Programming
+// #2023_03_25_Time_298_ms_(100.00%)_Space_45.1_MB_(100.00%)dsecx
+
+import java.util.Arrays
+
+class Solution {
+    private val dp: MutableMap<Int, Long> = HashMap()
+    private val nums: MutableMap<Int, Int> = HashMap()
+    fun numFactoredBinaryTrees(arr: IntArray): Int {
+        Arrays.sort(arr)
+        for (i in arr.indices) {
+            nums[arr[i]] = i
+        }
+        var ans: Long = 0
+        for (i in arr.indices.reversed()) {
+            ans = (ans % MOD + recursion(arr, arr[i], i) % MOD) % MOD
+        }
+        return ans.toInt()
+    }
+
+    private fun recursion(arr: IntArray, v: Int, idx: Int): Long {
+        if (dp.containsKey(v)) {
+            return dp[v]!!
+        }
+        var ret: Long = 1
+        for (i in 0 until idx) {
+            val child = arr[i]
+            if (v % child == 0 && nums.containsKey(v / child)) {
+                ret += (
+                    (
+                        recursion(arr, child, nums[arr[i]]!!) %
+                            MOD
+                            * recursion(arr, v / child, nums[v / child]!!) %
+                            MOD
+                        ) %
+                        MOD
+                    )
+            }
+        }
+        dp[v] = ret
+        return ret
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+    }
+}

src/main/kotlin/g0801_0900/s0823_binary_trees_with_factors/readme.md

@@ -0,0 +1,31 @@
+823\. Binary Trees With Factors
+
+Medium
+
+Given an array of unique integers, `arr`, where each integer `arr[i]` is strictly greater than `1`.
+
+We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.
+
+Return _the number of binary trees we can make_. The answer may be too large so return the answer **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** arr = [2,4]
+
+**Output:** 3
+
+**Explanation:** We can make these trees: `[2], [4], [4, 2, 2]`
+
+**Example 2:**
+
+**Input:** arr = [2,4,5,10]
+
+**Output:** 7
+
+**Explanation:** We can make these trees: `[2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2]`.
+
+**Constraints:**
+
+*   `1 <= arr.length <= 1000`
+*   <code>2 <= arr[i] <= 10<sup>9</sup></code>
+*   All the values of `arr` are **unique**.

src/main/kotlin/g0801_0900/s0824_goat_latin/Solution.kt

@@ -0,0 +1,28 @@
+package g0801_0900.s0824_goat_latin
+
+// #Easy #String #2023_03_25_Time_146_ms_(100.00%)_Space_35.8_MB_(90.00%)
+
+class Solution {
+    fun toGoatLatin(sentence: String): String {
+        val splits = sentence.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+        val sb = StringBuilder()
+        val a = StringBuilder()
+        for (word in splits) {
+            if (isVowel(word[0])) {
+                sb.append(word).append("ma")
+            } else {
+                val firstChar = word[0]
+                sb.append(word.substring(1)).append(firstChar).append("ma")
+            }
+            a.append("a")
+            sb.append(a)
+            sb.append(" ")
+        }
+        return sb.toString().trim { it <= ' ' }
+    }
+
+    private fun isVowel(c: Char): Boolean {
+        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
+            c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U'
+    }
+}

src/main/kotlin/g0801_0900/s0824_goat_latin/readme.md

@@ -0,0 +1,35 @@
+824\. Goat Latin
+
+Easy
+
+You are given a string `sentence` that consist of words separated by spaces. Each word consists of lowercase and uppercase letters only.
+
+We would like to convert the sentence to "Goat Latin" (a made-up language similar to Pig Latin.) The rules of Goat Latin are as follows:
+
+*   If a word begins with a vowel (`'a'`, `'e'`, `'i'`, `'o'`, or `'u'`), append `"ma"` to the end of the word.
+    *   For example, the word `"apple"` becomes `"applema"`.
+*   If a word begins with a consonant (i.e., not a vowel), remove the first letter and append it to the end, then add `"ma"`.
+    *   For example, the word `"goat"` becomes `"oatgma"`.
+*   Add one letter `'a'` to the end of each word per its word index in the sentence, starting with `1`.
+    *   For example, the first word gets `"a"` added to the end, the second word gets `"aa"` added to the end, and so on.
+
+Return _the final sentence representing the conversion from sentence to Goat Latin_.
+
+**Example 1:**
+
+**Input:** sentence = "I speak Goat Latin"
+
+**Output:** "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
+
+**Example 2:**
+
+**Input:** sentence = "The quick brown fox jumped over the lazy dog"
+
+**Output:** "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"
+
+**Constraints:**
+
+*   `1 <= sentence.length <= 150`
+*   `sentence` consists of English letters and spaces.
+*   `sentence` has no leading or trailing spaces.
+*   All the words in `sentence` are separated by a single space.

src/main/kotlin/g0801_0900/s0825_friends_of_appropriate_ages/Solution.kt

@@ -0,0 +1,26 @@
+package g0801_0900.s0825_friends_of_appropriate_ages
+
+// #Medium #Array #Sorting #Binary_Search #Two_Pointers
+// #2023_03_25_Time_278_ms_(100.00%)_Space_39.8_MB_(100.00%)
+
+class Solution {
+    fun numFriendRequests(ages: IntArray): Int {
+        val counter = IntArray(121)
+        for (k in ages) {
+            counter[k]++
+        }
+        var result = 0
+        for (k in 15 until counter.size) {
+            if (counter[k] == 0) {
+                continue
+            }
+            result += counter[k] * (counter[k] - 1)
+            var y = k - 1
+            while (y > k / 2.0 + 7) {
+                result += counter[k] * counter[y]
+                y--
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g0801_0900/s0825_friends_of_appropriate_ages/readme.md

@@ -0,0 +1,47 @@
+825\. Friends Of Appropriate Ages
+
+Medium
+
+There are `n` persons on a social media website. You are given an integer array `ages` where `ages[i]` is the age of the <code>i<sup>th</sup></code> person.
+
+A Person `x` will not send a friend request to a person `y` (`x != y`) if any of the following conditions is true:
+
+*   `age[y] <= 0.5 * age[x] + 7`
+*   `age[y] > age[x]`
+*   `age[y] > 100 && age[x] < 100`
+
+Otherwise, `x` will send a friend request to `y`.
+
+Note that if `x` sends a request to `y`, `y` will not necessarily send a request to `x`. Also, a person will not send a friend request to themself.
+
+Return _the total number of friend requests made_.
+
+**Example 1:**
+
+**Input:** ages = [16,16]
+
+**Output:** 2
+
+**Explanation:** 2 people friend request each other.
+
+**Example 2:**
+
+**Input:** ages = [16,17,18]
+
+**Output:** 2
+
+**Explanation:** Friend requests are made 17 -> 16, 18 -> 17.
+
+**Example 3:**
+
+**Input:** ages = [20,30,100,110,120]
+
+**Output:** 3
+
+**Explanation:** Friend requests are made 110 -> 100, 120 -> 110, 120 -> 100.
+
+**Constraints:**
+
+*   `n == ages.length`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   `1 <= ages[i] <= 120`

src/test/kotlin/g0801_0900/s0822_card_flipping_game/SolutionTest.kt

@@ -0,0 +1,20 @@
+package g0801_0900.s0822_card_flipping_game
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun flipame() {
+        assertThat(
+            Solution().flipgame(intArrayOf(1, 2, 4, 4, 7), intArrayOf(1, 3, 4, 1, 3)),
+            equalTo(2)
+        )
+    }
+
+    @Test
+    fun flipame2() {
+        assertThat(Solution().flipgame(intArrayOf(1), intArrayOf(1)), equalTo(0))
+    }
+}