Added tasks 2151-2200

Author: javadev

src/main/kotlin/g2101_2200/s2151_maximum_good_people_based_on_statements/Solution.kt

@@ -0,0 +1,48 @@
+package g2101_2200.s2151_maximum_good_people_based_on_statements
+
+// #Hard #Array #Bit_Manipulation #Backtracking #Enumeration
+// #2023_06_26_Time_308_ms_(100.00%)_Space_46.3_MB_(100.00%)
+
+class Solution {
+    fun maximumGood(statements: Array<IntArray>): Int {
+        val known = IntArray(statements.size)
+        known.fill(2)
+        return max(statements, known, 0)
+    }
+
+    private fun max(statements: Array<IntArray>, known: IntArray, position: Int): Int {
+        return if (position == statements.size) {
+            known.asSequence().filter { a: Int -> a == 1 }.count()
+        } else when (known[position]) {
+            0 -> assumeBad(statements, known, position)
+            1 -> assumeGood(statements, known, position)
+            else -> Math.max(
+                assumeBad(statements, known, position),
+                assumeGood(statements, known, position)
+            )
+        }
+    }
+
+    private fun assumeBad(statements: Array<IntArray>, known: IntArray, position: Int): Int {
+        val updatedKnown = known.clone()
+        updatedKnown[position] = 0
+        return max(statements, updatedKnown, position + 1)
+    }
+
+    private fun assumeGood(statements: Array<IntArray>, known: IntArray, position: Int): Int {
+        val updatedKnown = known.clone()
+        var conflictDetected = false
+        updatedKnown[position] = 1
+        for (i in statements[position].indices) {
+            val answer = statements[position][i]
+            if (answer != 2) {
+                if (known[i] != 2 && answer != known[i]) {
+                    conflictDetected = true
+                    break
+                }
+                updatedKnown[i] = answer
+            }
+        }
+        return if (conflictDetected) 0 else max(statements, updatedKnown, position + 1)
+    }
+}

src/main/kotlin/g2101_2200/s2151_maximum_good_people_based_on_statements/readme.md

@@ -0,0 +1,84 @@
+2151\. Maximum Good People Based on Statements
+
+Hard
+
+There are two types of persons:
+
+*   The **good person**: The person who always tells the truth.
+*   The **bad person**: The person who might tell the truth and might lie.
+
+You are given a **0-indexed** 2D integer array `statements` of size `n x n` that represents the statements made by `n` people about each other. More specifically, `statements[i][j]` could be one of the following:
+
+*   `0` which represents a statement made by person `i` that person `j` is a **bad** person.
+*   `1` which represents a statement made by person `i` that person `j` is a **good** person.
+*   `2` represents that **no statement** is made by person `i` about person `j`.
+
+Additionally, no person ever makes a statement about themselves. Formally, we have that `statements[i][i] = 2` for all `0 <= i < n`.
+
+Return _the **maximum** number of people who can be **good** based on the statements made by the_ `n` _people_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/01/15/logic1.jpg)
+
+**Input:** statements = [[2,1,2],[1,2,2],[2,0,2]]
+
+**Output:** 2
+
+**Explanation:**
+
+    Each person makes a single statement.
+    - Person 0 states that person 1 is good.
+    - Person 1 states that person 0 is good.
+    - Person 2 states that person 1 is bad.
+    Let's take person 2 as the key.
+    - Assuming that person 2 is a good person:
+        - Based on the statement made by person 2, person 1 is a bad person.
+        - Now we know for sure that person 1 is bad and person 2 is good.
+        - Based on the statement made by person 1, and since person 1 is bad, they could be:
+            - telling the truth. There will be a contradiction in this case and this assumption is invalid.
+            - lying. In this case, person 0 is also a bad person and lied in their statement.
+        - Following that person 2 is a good person, there will be only one good person in the group.
+    - Assuming that person 2 is a bad person:
+        - Based on the statement made by person 2, and since person 2 is bad, they could be:
+            - telling the truth. Following this scenario, person 0 and 1 are both bad as explained before.
+                - Following that person 2 is bad but told the truth, there will be no good persons in the group.
+            - lying. In this case person 1 is a good person.
+                - Since person 1 is a good person, person 0 is also a good person.
+                - Following that person 2 is bad and lied, there will be two good persons in the group.
+                
+    We can see that at most 2 persons are good in the best case, so we return 2.
+    Note that there is more than one way to arrive at this conclusion. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/01/15/logic2.jpg)
+
+**Input:** statements = [[2,0],[0,2]]
+
+**Output:** 1
+
+**Explanation:**
+
+    Each person makes a single statement.
+    - Person 0 states that person 1 is bad.
+    - Person 1 states that person 0 is bad.
+    Let's take person 0 as the key.
+    - Assuming that person 0 is a good person:
+        - Based on the statement made by person 0, person 1 is a bad person and was lying.
+        - Following that person 0 is a good person, there will be only one good person in the group.
+    - Assuming that person 0 is a bad person:
+        - Based on the statement made by person 0, and since person 0 is bad, they could be:
+            - telling the truth. Following this scenario, person 0 and 1 are both bad.
+                - Following that person 0 is bad but told the truth, there will be no good persons in the group.
+            - lying. In this case person 1 is a good person.
+                - Following that person 0 is bad and lied, there will be only one good person in the group.
+    We can see that at most, one person is good in the best case, so we return 1.
+    Note that there is more than one way to arrive at this conclusion. 
+
+**Constraints:**
+
+*   `n == statements.length == statements[i].length`
+*   `2 <= n <= 15`
+*   `statements[i][j]` is either `0`, `1`, or `2`.
+*   `statements[i][i] == 2`

src/main/kotlin/g2101_2200/s2154_keep_multiplying_found_values_by_two/Solution.kt

@@ -0,0 +1,20 @@
+package g2101_2200.s2154_keep_multiplying_found_values_by_two
+
+// #Easy #Array #Hash_Table #Sorting #Simulation
+// #2023_06_26_Time_183_ms_(85.71%)_Space_36.9_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun findFinalValue(nums: IntArray, original: Int): Int {
+        var original = original
+        var i = 0
+        while (i < nums.size) {
+            if (nums[i] == original) {
+                original = original * 2
+                i = -1
+            }
+            i++
+        }
+        return original
+    }
+}

src/main/kotlin/g2101_2200/s2154_keep_multiplying_found_values_by_two/readme.md

@@ -0,0 +1,45 @@
+2154\. Keep Multiplying Found Values by Two
+
+Easy
+
+You are given an array of integers `nums`. You are also given an integer `original` which is the first number that needs to be searched for in `nums`.
+
+You then do the following steps:
+
+1.  If `original` is found in `nums`, **multiply** it by two (i.e., set `original = 2 * original`).
+2.  Otherwise, **stop** the process.
+3.  **Repeat** this process with the new number as long as you keep finding the number.
+
+Return _the **final** value of_ `original`.
+
+**Example 1:**
+
+**Input:** nums = [5,3,6,1,12], original = 3
+
+**Output:** 24
+
+**Explanation:** 
+- 3 is found in nums. 3 is multiplied by 2 to obtain 6. 
+
+- 6 is found in nums. 6 is multiplied by 2 to obtain 12. 
+
+- 12 is found in nums. 12 is multiplied by 2 to obtain 24. 
+
+- 24 is not found in nums. 
+Thus, 24 is returned. 
+
+**Example 2:**
+
+**Input:** nums = [2,7,9], original = 4
+
+**Output:** 4
+
+**Explanation:** 
+- 4 is not found in nums. 
+
+Thus, 4 is returned. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i], original <= 1000`

src/main/kotlin/g2101_2200/s2155_all_divisions_with_the_highest_score_of_a_binary_array/Solution.kt

@@ -0,0 +1,36 @@
+package g2101_2200.s2155_all_divisions_with_the_highest_score_of_a_binary_array
+
+// #Medium #Array #2023_06_26_Time_1171_ms_(100.00%)_Space_56.5_MB_(100.00%)
+
+class Solution {
+    fun maxScoreIndices(nums: IntArray): List<Int> {
+        var curone = 0
+        var curzero = 0
+        var max = 0
+        for (i in nums) {
+            curone += i
+        }
+        val list: MutableList<Int> = ArrayList()
+        for (i in nums.indices) {
+            if (curzero + curone > max) {
+                list.clear()
+                list.add(i)
+                max = curzero + curone
+            } else if (curzero + curone == max) {
+                list.add(i)
+            }
+            if (nums[i] == 1) {
+                curone--
+            } else {
+                curzero++
+            }
+        }
+        if (curzero > max) {
+            list.clear()
+            list.add(nums.size)
+        } else if (curzero == max) {
+            list.add(nums.size)
+        }
+        return list
+    }
+}

src/main/kotlin/g2101_2200/s2155_all_divisions_with_the_highest_score_of_a_binary_array/readme.md

@@ -0,0 +1,72 @@
+2155\. All Divisions With the Highest Score of a Binary Array
+
+Medium
+
+You are given a **0-indexed** binary array `nums` of length `n`. `nums` can be divided at index `i` (where `0 <= i <= n)` into two arrays (possibly empty) <code>nums<sub>left</sub></code> and <code>nums<sub>right</sub></code>:
+
+*   <code>nums<sub>left</sub></code> has all the elements of `nums` between index `0` and `i - 1` **(inclusive)**, while <code>nums<sub>right</sub></code> has all the elements of nums between index `i` and `n - 1` **(inclusive)**.
+*   If `i == 0`, <code>nums<sub>left</sub></code> is **empty**, while <code>nums<sub>right</sub></code> has all the elements of `nums`.
+*   If `i == n`, <code>nums<sub>left</sub></code> has all the elements of nums, while <code>nums<sub>right</sub></code> is **empty**.
+
+The **division score** of an index `i` is the **sum** of the number of `0`'s in <code>nums<sub>left</sub></code> and the number of `1`'s in <code>nums<sub>right</sub></code>.
+
+Return _**all distinct indices** that have the **highest** possible **division score**_. You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [0,0,1,0]
+
+**Output:** [2,4]
+
+**Explanation:** Division at index 
+- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [0,0,**1**,0]. The score is 0 + 1 = 1. 
+
+- 1: nums<sub>left</sub> is [**0**]. nums<sub>right</sub> is [0,**1**,0]. The score is 1 + 1 = 2. 
+
+- 2: nums<sub>left</sub> is [**0**,**0**]. nums<sub>right</sub> is [**1**,0]. The score is 2 + 1 = 3. 
+
+- 3: nums<sub>left</sub> is [**0**,**0**,1]. nums<sub>right</sub> is [0]. The score is 2 + 0 = 2. 
+
+- 4: nums<sub>left</sub> is [**0**,**0**,1,**0**]. nums<sub>right</sub> is []. The score is 3 + 0 = 3. 
+
+Indices 2 and 4 both have the highest possible division score 3. 
+
+Note the answer [4,2] would also be accepted.
+
+**Example 2:**
+
+**Input:** nums = [0,0,0]
+
+**Output:** [3]
+
+**Explanation:** Division at index 
+- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [0,0,0]. The score is 0 + 0 = 0. 
+
+- 1: nums<sub>left</sub> is [**0**]. nums<sub>right</sub> is [0,0]. The score is 1 + 0 = 1. 
+
+- 2: nums<sub>left</sub> is [**0**,**0**]. nums<sub>right</sub> is [0]. The score is 2 + 0 = 2. 
+
+- 3: nums<sub>left</sub> is [**0**,**0**,**0**]. nums<sub>right</sub> is []. The score is 3 + 0 = 3. 
+
+Only index 3 has the highest possible division score 3. 
+
+**Example 3:**
+
+**Input:** nums = [1,1]
+
+**Output:** [0]
+
+**Explanation:** Division at index 
+- 0: nums<sub>left</sub> is []. nums<sub>right</sub> is [**1**,**1**]. The score is 0 + 2 = 2. 
+
+- 1: nums<sub>left</sub> is [1]. nums<sub>right</sub> is [**1**]. The score is 0 + 1 = 1. 
+
+- 2: nums<sub>left</sub> is [1,1]. nums<sub>right</sub> is []. The score is 0 + 0 = 0. 
+
+Only index 0 has the highest possible division score 2. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `nums[i]` is either `0` or `1`.

src/main/kotlin/g2101_2200/s2156_find_substring_with_given_hash_value/Solution.kt

@@ -0,0 +1,29 @@
+package g2101_2200.s2156_find_substring_with_given_hash_value
+
+// #Hard #String #Sliding_Window #Hash_Function #Rolling_Hash
+// #2023_06_26_Time_248_ms_(100.00%)_Space_37.5_MB_(100.00%)
+
+class Solution {
+    fun subStrHash(s: String, power: Int, modulo: Int, k: Int, hashValue: Int): String {
+        var mul1: Long = 1
+        var times = k - 1
+        while (times-- > 0) {
+            mul1 = mul1 * power % modulo
+        }
+        var index = -1
+        var hash: Long = 0
+        var end = s.length - 1
+        for (i in s.length - 1 downTo 0) {
+            val `val` = s[i].code - 96
+            hash = (hash * power % modulo + `val`) % modulo
+            if (end - i + 1 == k) {
+                if (hash == hashValue.toLong()) {
+                    index = i
+                }
+                hash = (hash - (s[end].code - 96) * mul1 % modulo + modulo) % modulo
+                end--
+            }
+        }
+        return s.substring(index, index + k)
+    }
+}

src/main/kotlin/g2101_2200/s2156_find_substring_with_given_hash_value/readme.md

@@ -0,0 +1,43 @@
+2156\. Find Substring With Given Hash Value
+
+Hard
+
+The hash of a **0-indexed** string `s` of length `k`, given integers `p` and `m`, is computed using the following function:
+
+*   <code>hash(s, p, m) = (val(s[0]) * p<sup>0</sup> + val(s[1]) * p<sup>1</sup> + ... + val(s[k-1]) * p<sup>k-1</sup>) mod m</code>.
+
+Where `val(s[i])` represents the index of `s[i]` in the alphabet from `val('a') = 1` to `val('z') = 26`.
+
+You are given a string `s` and the integers `power`, `modulo`, `k`, and `hashValue.` Return `sub`, _the **first** **substring** of_ `s` _of length_ `k` _such that_ `hash(sub, power, modulo) == hashValue`.
+
+The test cases will be generated such that an answer always **exists**.
+
+A **substring** is a contiguous non-empty sequence of characters within a string.
+
+**Example 1:**
+
+**Input:** s = "leetcode", power = 7, modulo = 20, k = 2, hashValue = 0
+
+**Output:** "ee"
+
+**Explanation:** The hash of "ee" can be computed to be hash("ee", 7, 20) = (5 \* 1 + 5 \* 7) mod 20 = 40 mod 20 = 0. "ee" is the first substring of length 2 with hashValue 0. Hence, we return "ee".
+
+**Example 2:**
+
+**Input:** s = "fbxzaad", power = 31, modulo = 100, k = 3, hashValue = 32
+
+**Output:** "fbx"
+
+**Explanation:** The hash of "fbx" can be computed to be hash("fbx", 31, 100) = (6 \* 1 + 2 \* 31 + 24 \* 31<sup>2</sup>) mod 100 = 23132 mod 100 = 32. 
+
+The hash of "bxz" can be computed to be hash("bxz", 31, 100) = (2 \* 1 + 24 \* 31 + 26 \* 31<sup>2</sup>) mod 100 = 25732 mod 100 = 32. "fbx" is the first substring of length 3 with hashValue 32. Hence, we return "fbx". 
+
+Note that "bxz" also has a hash of 32 but it appears later than "fbx".
+
+**Constraints:**
+
+*   <code>1 <= k <= s.length <= 2 * 10<sup>4</sup></code>
+*   <code>1 <= power, modulo <= 10<sup>9</sup></code>
+*   `0 <= hashValue < modulo`
+*   `s` consists of lowercase English letters only.
+*   The test cases are generated such that an answer always **exists**.