Added tasks 2951-2961

Author: javadev

src/main/kotlin/g2901_3000/s2951_find_the_peaks/Solution.kt

@@ -0,0 +1,15 @@
+package g2901_3000.s2951_find_the_peaks
+
+// #Easy #Array #Enumeration #2024_01_16_Time_188_ms_(93.75%)_Space_37.5_MB_(72.50%)
+
+class Solution {
+    fun findPeaks(mountain: IntArray): List<Int> {
+        val list: MutableList<Int> = ArrayList()
+        for (i in 1 until mountain.size - 1) {
+            if ((mountain[i - 1] < mountain[i]) && (mountain[i] > mountain[i + 1])) {
+                list.add(i)
+            }
+        }
+        return list
+    }
+}

src/main/kotlin/g2901_3000/s2951_find_the_peaks/readme.md

@@ -0,0 +1,41 @@
+2951\. Find the Peaks
+
+Easy
+
+You are given a **0-indexed** array `mountain`. Your task is to find all the **peaks** in the `mountain` array.
+
+Return _an array that consists of_ indices _of **peaks** in the given array in **any order**._
+
+**Notes:**
+
+*   A **peak** is defined as an element that is **strictly greater** than its neighboring elements.
+*   The first and last elements of the array are **not** a peak.
+
+**Example 1:**
+
+**Input:** mountain = [2,4,4]
+
+**Output:** []
+
+**Explanation:** mountain[0] and mountain[2] can not be a peak because they are first and last elements of the array. 
+
+mountain[1] also can not be a peak because it is not strictly greater than mountain[2]. 
+
+So the answer is [].
+
+**Example 2:**
+
+**Input:** mountain = [1,4,3,8,5]
+
+**Output:** [1,3]
+
+**Explanation:** mountain[0] and mountain[4] can not be a peak because they are first and last elements of the array. 
+
+mountain[2] also can not be a peak because it is not strictly greater than mountain[3] and mountain[1]. 
+
+But mountain [1] and mountain[3] are strictly greater than their neighboring elements. So the answer is [1,3].
+
+**Constraints:**
+
+*   `3 <= mountain.length <= 100`
+*   `1 <= mountain[i] <= 100`

src/main/kotlin/g2901_3000/s2952_minimum_number_of_coins_to_be_added/Solution.kt

@@ -0,0 +1,22 @@
+package g2901_3000.s2952_minimum_number_of_coins_to_be_added
+
+// #Medium #Array #Sorting #Greedy #2024_01_16_Time_439_ms_(87.10%)_Space_59.3_MB_(61.29%)
+
+class Solution {
+    fun minimumAddedCoins(coins: IntArray, target: Int): Int {
+        var res = 0
+        var num = 0
+        var i = 0
+        coins.sort()
+        while (num < target) {
+            if (i < coins.size && coins[i] <= num + 1) {
+                num += coins[i]
+                i++
+            } else {
+                res += 1
+                num += num + 1
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/g2901_3000/s2952_minimum_number_of_coins_to_be_added/readme.md

@@ -0,0 +1,47 @@
+2952\. Minimum Number of Coins to be Added
+
+Medium
+
+You are given a **0-indexed** integer array `coins`, representing the values of the coins available, and an integer `target`.
+
+An integer `x` is **obtainable** if there exists a subsequence of `coins` that sums to `x`.
+
+Return _the **minimum** number of coins **of any value** that need to be added to the array so that every integer in the range_ `[1, target]` _is **obtainable**_.
+
+A **subsequence** of an array is a new **non-empty** array that is formed from the original array by deleting some (**possibly none**) of the elements without disturbing the relative positions of the remaining elements.
+
+**Example 1:**
+
+**Input:** coins = [1,4,10], target = 19
+
+**Output:** 2
+
+**Explanation:** We need to add coins 2 and 8. The resulting array will be [1,2,4,8,10]. 
+
+It can be shown that all integers from 1 to 19 are obtainable from the resulting array, and that 2 is the minimum number of coins that need to be added to the array.
+
+**Example 2:**
+
+**Input:** coins = [1,4,10,5,7,19], target = 19
+
+**Output:** 1
+
+**Explanation:** We only need to add the coin 2. The resulting array will be [1,2,4,5,7,10,19]. 
+
+It can be shown that all integers from 1 to 19 are obtainable from the resulting array, and that 1 is the minimum number of coins that need to be added to the array.
+
+**Example 3:**
+
+**Input:** coins = [1,1,1], target = 20
+
+**Output:** 3
+
+**Explanation:** We need to add coins 4, 8, and 16. The resulting array will be [1,1,1,4,8,16].
+
+It can be shown that all integers from 1 to 20 are obtainable from the resulting array, and that 3 is the minimum number of coins that need to be added to the array.
+
+**Constraints:**
+
+*   <code>1 <= target <= 10<sup>5</sup></code>
+*   <code>1 <= coins.length <= 10<sup>5</sup></code>
+*   `1 <= coins[i] <= target`

src/main/kotlin/g2901_3000/s2953_count_complete_substrings/Solution.kt

@@ -0,0 +1,56 @@
+package g2901_3000.s2953_count_complete_substrings
+
+// #Hard #String #Hash_Table #Sliding_Window
+// #2024_01_16_Time_315_ms_(100.00%)_Space_38.7_MB_(100.00%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun countCompleteSubstrings(word: String, k: Int): Int {
+        val arr = word.toCharArray()
+        val n = arr.size
+        var result = 0
+        var last = 0
+        for (i in 1..n) {
+            if (i == n || abs((arr[i].code - arr[i - 1].code).toDouble()) > 2) {
+                result += getCount(arr, k, last, i - 1)
+                last = i
+            }
+        }
+        return result
+    }
+
+    private fun getCount(arr: CharArray, k: Int, start: Int, end: Int): Int {
+        var result = 0
+        var i = 1
+        while (i <= 26 && i * k <= end - start + 1) {
+            val cnt = IntArray(26)
+            var good = 0
+            for (j in start..end) {
+                val cR = arr[j]
+                cnt[cR.code - 'a'.code]++
+                if (cnt[cR.code - 'a'.code] == k) {
+                    good++
+                }
+                if (cnt[cR.code - 'a'.code] == k + 1) {
+                    good--
+                }
+                if (j >= start + i * k) {
+                    val cL = arr[j - i * k]
+                    if (cnt[cL.code - 'a'.code] == k) {
+                        good--
+                    }
+                    if (cnt[cL.code - 'a'.code] == k + 1) {
+                        good++
+                    }
+                    cnt[cL.code - 'a'.code]--
+                }
+                if (good == i) {
+                    result++
+                }
+            }
+            i++
+        }
+        return result
+    }
+}

src/main/kotlin/g2901_3000/s2953_count_complete_substrings/readme.md

@@ -0,0 +1,36 @@
+2953\. Count Complete Substrings
+
+Hard
+
+You are given a string `word` and an integer `k`.
+
+A substring `s` of `word` is **complete** if:
+
+*   Each character in `s` occurs **exactly** `k` times.
+*   The difference between two adjacent characters is **at most** `2`. That is, for any two adjacent characters `c1` and `c2` in `s`, the absolute difference in their positions in the alphabet is **at most** `2`.
+
+Return _the number of **complete** substrings of_ `word`.
+
+A **substring** is a **non-empty** contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** word = "igigee", k = 2
+
+**Output:** 3
+
+**Explanation:** The complete substrings where each character appears exactly twice and the difference between adjacent characters is at most 2 are: <ins>**igig**</ins>ee, igig<ins>**ee**</ins>, <ins>**igigee**</ins>.
+
+**Example 2:**
+
+**Input:** word = "aaabbbccc", k = 3
+
+**Output:** 6
+
+**Explanation:** The complete substrings where each character appears exactly three times and the difference between adjacent characters is at most 2 are: **<ins>aaa</ins>**bbbccc, aaa<ins>**bbb**</ins>ccc, aaabbb<ins>**ccc**</ins>, **<ins>aaabbb</ins>**ccc, aaa<ins>**bbbccc**</ins>, <ins>**aaabbbccc**</ins>.
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 10<sup>5</sup></code>
+*   `word` consists only of lowercase English letters.
+*   `1 <= k <= word.length`

src/main/kotlin/g2901_3000/s2954_count_the_number_of_infection_sequences/Solution.kt

@@ -0,0 +1,53 @@
+package g2901_3000.s2954_count_the_number_of_infection_sequences
+
+// #Hard #Array #Math #Combinatorics #2024_01_16_Time_1446_ms_(14.29%)_Space_69.1_MB_(14.29%)
+
+import kotlin.math.max
+
+class Solution {
+    private val fact = LongArray(M + 1)
+    private val invFact = LongArray(M + 1)
+    private var init: Long = 0
+
+    private fun modPow(x: Int, y: Int, mod: Int): Int {
+        if (y == 0) {
+            return 1
+        }
+        var p = (modPow(x, y / 2, mod) % mod).toLong()
+        p = (p * p) % mod
+        return if (y % 2 == 1) (p * x % mod).toInt() else p.toInt()
+    }
+
+    private fun binomCoeff(n: Int, k: Int): Long {
+        return max(
+            1.0,
+            (fact[n] * invFact[k] % MOD * invFact[n - k] % MOD).toDouble()
+        ).toLong()
+    }
+
+    fun numberOfSequence(n: Int, sick: IntArray): Int {
+        if (init == 0L) {
+            init = 1
+            fact[0] = 1
+            for (i in 1..M) {
+                fact[i] = fact[i - 1] * i % MOD
+            }
+            invFact[M] = modPow(fact[M].toInt(), MOD - 2, MOD).toLong()
+            for (i in M - 1 downTo 1) {
+                invFact[i] = invFact[i + 1] * (i + 1) % MOD
+            }
+        }
+        var res: Long = 1
+        for (i in 1 until sick.size) {
+            val group = sick[i] - sick[i - 1] - 1
+            res = res * modPow(2, max(0.0, (group - 1).toDouble()).toInt(), MOD) % MOD
+            res = res * binomCoeff(sick[i] - i, group) % MOD
+        }
+        return (res * binomCoeff(n - sick.size, n - sick[sick.size - 1] - 1) % MOD).toInt()
+    }
+
+    companion object {
+        private const val M = 100000
+        private const val MOD = 1000000007
+    }
+}

src/main/kotlin/g2901_3000/s2954_count_the_number_of_infection_sequences/readme.md

@@ -0,0 +1,49 @@
+2954\. Count the Number of Infection Sequences
+
+Hard
+
+You are given an integer `n` and a **0-indexed** integer array `sick` which is **sorted** in **increasing** order.
+
+There are `n` children standing in a queue with positions `0` to `n - 1` assigned to them. The array `sick` contains the positions of the children who are infected with an infectious disease. An infected child at position `i` can spread the disease to either of its immediate neighboring children at positions `i - 1` and `i + 1` **if** they exist and are currently not infected. **At most one** child who was previously not infected can get infected with the disease in one second.
+
+It can be shown that after a finite number of seconds, all the children in the queue will get infected with the disease. An **infection sequence** is the sequential order of positions in which **all** of the non-infected children get infected with the disease. Return _the total number of possible infection sequences_.
+
+Since the answer may be large, return it modulo <code>10<sup>9</sup> + 7</code>.
+
+**Note** that an infection sequence **does not** contain positions of children who were already infected with the disease in the beginning.
+
+**Example 1:**
+
+**Input:** n = 5, sick = [0,4]
+
+**Output:** 4
+
+**Explanation:** Children at positions 1, 2, and 3 are not infected in the beginning. There are 4 possible infection sequences: 
+- The children at positions 1 and 3 can get infected since their positions are adjacent to the infected children 0 and 4. The child at position 1 gets infected first. 
+
+Now, the child at position 2 is adjacent to the child at position 1 who is infected and the child at position 3 is adjacent to the child at position 4 who is infected, hence either of them can get infected. The child at position 2 gets infected. Finally, the child at position 3 gets infected because it is adjacent to children at positions 2 and 4 who are infected. The infection sequence is [1,2,3]. 
+- The children at positions 1 and 3 can get infected because their positions are adjacent to the infected children 0 and 4. The child at position 1 gets infected first. 
+
+Now, the child at position 2 is adjacent to the child at position 1 who is infected and the child at position 3 is adjacent to the child at position 4 who is infected, hence either of them can get infected. The child at position 3 gets infected. 
+
+Finally, the child at position 2 gets infected because it is adjacent to children at positions 1 and 3 who are infected. The infection sequence is [1,3,2]. 
+- The infection sequence is [3,1,2]. The order of infection of disease in the children can be seen as: [<ins>0</ins>,1,2,3,<ins>4</ins>] => [<ins>0</ins>,1,2,<ins>3</ins>,<ins>4</ins>] => [<ins>0</ins>,<ins>1</ins>,2,<ins>3</ins>,<ins>4</ins>] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>,<ins>4</ins>]. 
+- The infection sequence is [3,2,1]. The order of infection of disease in the children can be seen as: [<ins>0</ins>,1,2,3,<ins>4</ins>] => [<ins>0</ins>,1,2,<ins>3</ins>,<ins>4</ins>] => [<ins>0</ins>,1,<ins>2</ins>,<ins>3</ins>,<ins>4</ins>] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>,<ins>4</ins>].
+
+**Example 2:**
+
+**Input:** n = 4, sick = [1]
+
+**Output:** 3
+
+**Explanation:** Children at positions 0, 2, and 3 are not infected in the beginning. There are 3 possible infection sequences: 
+- The infection sequence is [0,2,3]. The order of infection of disease in the children can be seen as: [0,<ins>1</ins>,2,3] => [<ins>0</ins>,<ins>1</ins>,2,3] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,3] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>]. 
+- The infection sequence is [2,0,3]. The order of infection of disease in the children can be seen as: [0,<ins>1</ins>,2,3] => [0,<ins>1</ins>,<ins>2</ins>,3] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,3] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>]. 
+- The infection sequence is [2,3,0]. The order of infection of disease in the children can be seen as: [0,<ins>1</ins>,2,3] => [0,<ins>1</ins>,<ins>2</ins>,3] => [0,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>] => [<ins>0</ins>,<ins>1</ins>,<ins>2</ins>,<ins>3</ins>].
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   `1 <= sick.length <= n - 1`
+*   `0 <= sick[i] <= n - 1`
+*   `sick` is sorted in increasing order.

src/main/kotlin/g2901_3000/s2956_find_common_elements_between_two_arrays/Solution.kt

@@ -0,0 +1,22 @@
+package g2901_3000.s2956_find_common_elements_between_two_arrays
+
+// #Easy #Array #Hash_Table #2024_01_16_Time_271_ms_(94.20%)_Space_40.7_MB_(95.65%)
+
+class Solution {
+    fun findIntersectionValues(nums1: IntArray, nums2: IntArray): IntArray {
+        val freq2 = IntArray(101)
+        val freq1 = IntArray(101)
+        val ans = IntArray(2)
+        for (j in nums2) {
+            freq2[j] = 1
+        }
+        for (j in nums1) {
+            freq1[j] = 1
+            ans[0] = ans[0] + freq2[j]
+        }
+        for (j in nums2) {
+            ans[1] = ans[1] + freq1[j]
+        }
+        return ans
+    }
+}

src/main/kotlin/g2901_3000/s2956_find_common_elements_between_two_arrays/readme.md

@@ -0,0 +1,37 @@
+2956\. Find Common Elements Between Two Arrays
+
+Easy
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of sizes `n` and `m`, respectively.
+
+Consider calculating the following values:
+
+*   The number of indices `i` such that `0 <= i < n` and `nums1[i]` occurs **at least** once in `nums2`.
+*   The number of indices `i` such that `0 <= i < m` and `nums2[i]` occurs **at least** once in `nums1`.
+
+Return _an integer array_ `answer` _of size_ `2` _containing the two values **in the above order**_.
+
+**Example 1:**
+
+**Input:** nums1 = [4,3,2,3,1], nums2 = [2,2,5,2,3,6]
+
+**Output:** [3,4]
+
+**Explanation:** We calculate the values as follows: 
+- The elements at indices 1, 2, and 3 in nums1 occur at least once in nums2. So the first value is 3. 
+- The elements at indices 0, 1, 3, and 4 in nums2 occur at least once in nums1. So the second value is 4.
+
+**Example 2:**
+
+**Input:** nums1 = [3,4,2,3], nums2 = [1,5]
+
+**Output:** [0,0]
+
+**Explanation:** There are no common elements between the two arrays, so the two values will be 0.
+
+**Constraints:**
+
+*   `n == nums1.length`
+*   `m == nums2.length`
+*   `1 <= n, m <= 100`
+*   `1 <= nums1[i], nums2[i] <= 100`