Added tasks 2778-2784

Author: javadev

src/main/kotlin/g2701_2800/s2778_sum_of_squares_of_special_elements/Solution.kt

@@ -0,0 +1,13 @@
+package g2701_2800.s2778_sum_of_squares_of_special_elements
+
+// #Easy #Array #Simulation #2023_08_09_Time_183_ms_(86.44%)_Space_36.9_MB_(84.75%)
+
+class Solution {
+    fun sumOfSquares(nums: IntArray): Int {
+        var sum = 0
+        for (i in nums.indices) {
+            if (nums.size % (i + 1) == 0) sum += nums[i] * nums[i]
+        }
+        return sum
+    }
+}

src/main/kotlin/g2701_2800/s2778_sum_of_squares_of_special_elements/readme.md

@@ -0,0 +1,38 @@
+2778\. Sum of Squares of Special Elements
+
+Easy
+
+You are given a **1-indexed** integer array `nums` of length `n`.
+
+An element `nums[i]` of `nums` is called **special** if `i` divides `n`, i.e. `n % i == 0`.
+
+Return _the **sum of the squares** of all **special** elements of_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** 21
+
+**Explanation:**
+
+There are exactly 3 special elements in nums: nums[1] since 1 divides 4, nums[2] since 2 divides 4, and nums[4] since 4 divides 4.
+
+Hence, the sum of the squares of all special elements of nums is nums[1] \* nums[1] + nums[2] \* nums[2] + nums[4] \* nums[4] = 1 \* 1 + 2 \* 2 + 4 \* 4 = 21. 
+
+**Example 2:**
+
+**Input:** nums = [2,7,1,19,18,3]
+
+**Output:** 63
+
+**Explanation:**
+
+There are exactly 4 special elements in nums: nums[1] since 1 divides 6, nums[2] since 2 divides 6, nums[3] since 3 divides 6, and nums[6] since 6 divides 6.
+
+Hence, the sum of the squares of all special elements of nums is nums[1] \* nums[1] + nums[2] \* nums[2] + nums[3] \* nums[3] + nums[6] \* nums[6] = 2 \* 2 + 7 \* 7 + 1 \* 1 + 3 \* 3 = 63. 
+
+**Constraints:**
+
+*   `1 <= nums.length == n <= 50`
+*   `1 <= nums[i] <= 50`

src/main/kotlin/g2701_2800/s2779_maximum_beauty_of_an_array_after_applying_operation/Solution.kt

@@ -0,0 +1,20 @@
+package g2701_2800.s2779_maximum_beauty_of_an_array_after_applying_operation
+
+// #Medium #Array #Sorting #Binary_Search #Sliding_Window
+// #2023_08_09_Time_649_ms_(96.97%)_Space_58.8_MB_(81.82%)
+
+class Solution {
+    fun maximumBeauty(nums: IntArray, k: Int): Int {
+        nums.sort()
+        var i = 0
+        val n = nums.size
+        var j = 0
+        while (j < n) {
+            if (nums[j] - nums[i] > k * 2) {
+                i++
+            }
+            ++j
+        }
+        return j - i
+    }
+}

src/main/kotlin/g2701_2800/s2779_maximum_beauty_of_an_array_after_applying_operation/readme.md

@@ -0,0 +1,53 @@
+2779\. Maximum Beauty of an Array After Applying Operation
+
+Medium
+
+You are given a **0-indexed** array `nums` and a **non-negative** integer `k`.
+
+In one operation, you can do the following:
+
+*   Choose an index `i` that **hasn't been chosen before** from the range `[0, nums.length - 1]`.
+*   Replace `nums[i]` with any integer from the range `[nums[i] - k, nums[i] + k]`.
+
+The **beauty** of the array is the length of the longest subsequence consisting of equal elements.
+
+Return _the **maximum** possible beauty of the array_ `nums` _after applying the operation any number of times._
+
+**Note** that you can apply the operation to each index **only once**.
+
+A **subsequence** of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** nums = [4,6,1,2], k = 2
+
+**Output:** 3
+
+**Explanation:**
+
+In this example, we apply the following operations:
+
+- Choose index 1, replace it with 4 (from range [4,8]), nums = [4,4,1,2].
+
+- Choose index 3, replace it with 4 (from range [0,4]), nums = [4,4,1,4].
+
+After the applied operations, the beauty of the array nums is 3 (subsequence consisting of indices 0, 1, and 3).
+
+It can be proven that 3 is the maximum possible length we can achieve. 
+
+**Example 2:**
+
+**Input:** nums = [1,1,1,1], k = 10
+
+**Output:** 4
+
+**Explanation:**
+
+In this example we don't have to apply any operations.
+
+The beauty of the array nums is 4 (whole array). 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i], k <= 10<sup>5</sup></code>

src/main/kotlin/g2701_2800/s2780_minimum_index_of_a_valid_split/Solution.kt

@@ -0,0 +1,28 @@
+package g2701_2800.s2780_minimum_index_of_a_valid_split
+
+// #Medium #Array #Hash_Table #Sorting #2023_08_09_Time_640_ms_(91.67%)_Space_61.6_MB_(95.83%)
+
+class Solution {
+    fun minimumIndex(nums: List<Int>): Int {
+        val map = HashMap<Int, Int>()
+        map[0] = 0
+        var max = 0
+        val m = nums.size
+        for (n in nums) {
+            map[n] = map.getOrDefault(n, 0) + 1
+            if (map[n]!! > map[max]!!) {
+                max = n
+            }
+        }
+        var freq = 0
+        for (i in 0 until m) {
+            if (nums[i] == max) {
+                freq++
+            }
+            if (freq * 2 > i + 1 && (map[max]!! - freq) * 2 > m - i - 1) {
+                return i
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g2701_2800/s2780_minimum_index_of_a_valid_split/readme.md

@@ -0,0 +1,68 @@
+2780\. Minimum Index of a Valid Split
+
+Medium
+
+An element `x` of an integer array `arr` of length `m` is **dominant** if `freq(x) * 2 > m`, where `freq(x)` is the number of occurrences of `x` in `arr`. Note that this definition implies that `arr` can have **at most one** dominant element.
+
+You are given a **0-indexed** integer array `nums` of length `n` with one dominant element.
+
+You can split `nums` at an index `i` into two arrays `nums[0, ..., i]` and `nums[i + 1, ..., n - 1]`, but the split is only **valid** if:
+
+*   `0 <= i < n - 1`
+*   `nums[0, ..., i]`, and `nums[i + 1, ..., n - 1]` have the same dominant element.
+
+Here, `nums[i, ..., j]` denotes the subarray of `nums` starting at index `i` and ending at index `j`, both ends being inclusive. Particularly, if `j < i` then `nums[i, ..., j]` denotes an empty subarray.
+
+Return _the **minimum** index of a **valid split**_. If no valid split exists, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,2]
+
+**Output:** 2
+
+**Explanation:**
+
+We can split the array at index 2 to obtain arrays [1,2,2] and [2].
+
+In array [1,2,2], element 2 is dominant since it occurs twice in the array and 2 \* 2 > 3.
+
+In array [2], element 2 is dominant since it occurs once in the array and 1 \* 2 > 1.
+
+Both [1,2,2] and [2] have the same dominant element as nums, so this is a valid split.
+
+It can be shown that index 2 is the minimum index of a valid split. 
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,1,1,1,7,1,2,1]
+
+**Output:** 4
+
+**Explanation:**
+
+We can split the array at index 4 to obtain arrays [2,1,3,1,1] and [1,7,1,2,1].
+
+In array [2,1,3,1,1], element 1 is dominant since it occurs thrice in the array and 3 \* 2 > 5.
+
+In array [1,7,1,2,1], element 1 is dominant since it occurs thrice in the array and 3 \* 2 > 5.
+
+Both [2,1,3,1,1] and [1,7,1,2,1] have the same dominant element as nums, so this is a valid split.
+
+It can be shown that index 4 is the minimum index of a valid split.
+
+**Example 3:**
+
+**Input:** nums = [3,3,3,3,7,2,2]
+
+**Output:** -1
+
+**Explanation:**
+
+It can be shown that there is no valid split. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>
+*   `nums` has exactly one dominant element.

src/main/kotlin/g2701_2800/s2781_length_of_the_longest_valid_substring/Solution.kt

@@ -0,0 +1,30 @@
+package g2701_2800.s2781_length_of_the_longest_valid_substring
+
+// #Hard #Array #String #Hash_Table #Sliding_Window
+// #2023_08_09_Time_647_ms_(100.00%)_Space_60.3_MB_(100.00%)
+
+class Solution {
+    fun longestValidSubstring(word: String, forbidden: List<String>): Int {
+        val set = HashSet<String>()
+        for (s in forbidden) {
+            set.add(s)
+        }
+        val n = word.length
+        var ans = 0
+        var i = 0
+        var j = 0
+        while (j < n) {
+            var k = j
+            while (k > j - 10 && k >= i) {
+                if (set.contains(word.substring(k, j + 1))) {
+                    i = k + 1
+                    break
+                }
+                k--
+            }
+            ans = Math.max(j - i + 1, ans)
+            j++
+        }
+        return ans
+    }
+}

src/main/kotlin/g2701_2800/s2781_length_of_the_longest_valid_substring/readme.md

@@ -0,0 +1,43 @@
+2781\. Length of the Longest Valid Substring
+
+Hard
+
+You are given a string `word` and an array of strings `forbidden`.
+
+A string is called **valid** if none of its substrings are present in `forbidden`.
+
+Return _the length of the **longest valid substring** of the string_ `word`.
+
+A **substring** is a contiguous sequence of characters in a string, possibly empty.
+
+**Example 1:**
+
+**Input:** word = "cbaaaabc", forbidden = ["aaa","cb"]
+
+**Output:** 4
+
+**Explanation:**
+
+There are 9 valid substrings in word: "c", "b", "a", "ba", "aa", "bc", "baa", "aab", "ab", "abc"and "aabc". The length of the longest valid substring is 4.
+
+It can be shown that all other substrings contain either "aaa" or "cb" as a substring. 
+
+**Example 2:**
+
+**Input:** word = "leetcode", forbidden = ["de","le","e"]
+
+**Output:** 4
+
+**Explanation:**
+
+There are 11 valid substrings in word: "l", "t", "c", "o", "d", "tc", "co", "od", "tco", "cod", and "tcod". The length of the longest valid substring is 4.
+
+It can be shown that all other substrings contain either "de", "le", or "e" as a substring. 
+
+**Constraints:**
+
+*   <code>1 <= word.length <= 10<sup>5</sup></code>
+*   `word` consists only of lowercase English letters.
+*   <code>1 <= forbidden.length <= 10<sup>5</sup></code>
+*   `1 <= forbidden[i].length <= 10`
+*   `forbidden[i]` consists only of lowercase English letters.

src/main/kotlin/g2701_2800/s2784_check_if_array_is_good/Solution.kt

@@ -0,0 +1,30 @@
+package g2701_2800.s2784_check_if_array_is_good
+
+// #Easy #Array #Hash_Table #Sorting #2023_08_09_Time_177_ms_(88.89%)_Space_36.3_MB_(93.33%)
+
+class Solution {
+    fun isGood(nums: IntArray): Boolean {
+        var max = Int.MIN_VALUE
+        var sum = 0
+        for (i in nums) {
+            if (i > max) {
+                max = i
+            }
+            sum += i
+        }
+        if (max != nums.size - 1) {
+            return false
+        }
+        val newSum = max * (max + 1) / 2 + max
+        if (sum != newSum) {
+            return false
+        }
+        var count = 0
+        for (i in nums) {
+            if (i == max) {
+                count++
+            }
+        }
+        return count == 2
+    }
+}

src/main/kotlin/g2701_2800/s2784_check_if_array_is_good/readme.md

@@ -0,0 +1,48 @@
+2784\. Check if Array is Good
+
+Easy
+
+You are given an integer array `nums`. We consider an array **good** if it is a permutation of an array `base[n]`.
+
+`base[n] = [1, 2, ..., n - 1, n, n]` (in other words, it is an array of length `n + 1` which contains `1` to `n - 1` exactly once, plus two occurrences of `n`). For example, `base[1] = [1, 1]` and `base[3] = [1, 2, 3, 3]`.
+
+Return `true` _if the given array is good, otherwise return_ `false`.
+
+**Note:** A permutation of integers represents an arrangement of these numbers.
+
+**Example 1:**
+
+**Input:** nums = [2, 1, 3]
+
+**Output:** false
+
+**Explanation:** Since the maximum element of the array is 3, the only candidate n for which this array could be a permutation of base[n], is n = 3. However, base[3] has four elements but array nums has three. Therefore, it can not be a permutation of base[3] = [1, 2, 3, 3]. So the answer is false. 
+
+**Example 2:**
+
+**Input:** nums = [1, 3, 3, 2]
+
+**Output:** true
+
+**Explanation:** Since the maximum element of the array is 3, the only candidate n for which this array could be a permutation of base[n], is n = 3. It can be seen that nums is a permutation of base[3] = [1, 2, 3, 3] (by swapping the second and fourth elements in nums, we reach base[3]). Therefore, the answer is true.
+
+**Example 3:**
+
+**Input:** nums = [1, 1]
+
+**Output:** true
+
+**Explanation:** Since the maximum element of the array is 1, the only candidate n for which this array could be a permutation of base[n], is n = 1. It can be seen that nums is a permutation of base[1] = [1, 1]. Therefore, the answer is true.
+
+**Example 4:**
+
+**Input:** nums = [3, 4, 4, 1, 2, 1]
+
+**Output:** false
+
+**Explanation:** Since the maximum element of the array is 4, the only candidate n for which this array could be a permutation of base[n], is n = 4. However, base[4] has five elements but array nums has six. Therefore, it can not be a permutation of base[4] = [1, 2, 3, 4, 4]. So the answer is false. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= num[i] <= 200`