Added tasks 3136-3149

Author: javadev

README.md

@@ -0,0 +1,93 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3136\. Valid Word
+
+Easy
+
+A word is considered **valid** if:
+
+*   It contains a **minimum** of 3 characters.
+*   It contains only digits (0-9), and English letters (uppercase and lowercase).
+*   It includes **at least** one **vowel**.
+*   It includes **at least** one **consonant**.
+
+You are given a string `word`.
+
+Return `true` if `word` is valid, otherwise, return `false`.
+
+**Notes:**
+
+*   `'a'`, `'e'`, `'i'`, `'o'`, `'u'`, and their uppercases are **vowels**.
+*   A **consonant** is an English letter that is not a vowel.
+
+**Example 1:**
+
+**Input:** word = "234Adas"
+
+**Output:** true
+
+**Explanation:**
+
+This word satisfies the conditions.
+
+**Example 2:**
+
+**Input:** word = "b3"
+
+**Output:** false
+
+**Explanation:**
+
+The length of this word is fewer than 3, and does not have a vowel.
+
+**Example 3:**
+
+**Input:** word = "a3$e"
+
+**Output:** false
+
+**Explanation:**
+
+This word contains a `'$'` character and does not have a consonant.
+
+**Constraints:**
+
+*   `1 <= word.length <= 20`
+*   `word` consists of English uppercase and lowercase letters, digits, `'@'`, `'#'`, and `'$'`.
+
+## Solution
+
+```kotlin
+class Solution {
+    fun isValid(word: String): Boolean {
+        if (word.length < 3) {
+            return false
+        }
+        if (word.contains("@") || word.contains("#") || word.contains("$")) {
+            return false
+        }
+        val vowels = charArrayOf('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U')
+        val consonants = charArrayOf(
+            'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v',
+            'w', 'x', 'y', 'z', 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q',
+            'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z'
+        )
+        var flag1 = false
+        var flag2 = false
+        for (c in vowels) {
+            if (word.indexOf(c) != -1) {
+                flag1 = true
+                break
+            }
+        }
+        for (c in consonants) {
+            if (word.indexOf(c) != -1) {
+                flag2 = true
+                break
+            }
+        }
+        return flag1 && flag2
+    }
+}
+```

src/main/kotlin/g3101_3200/s3136_valid_word/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3137\. Minimum Number of Operations to Make Word K-Periodic
+
+Medium
+
+You are given a string `word` of size `n`, and an integer `k` such that `k` divides `n`.
+
+In one operation, you can pick any two indices `i` and `j`, that are divisible by `k`, then replace the substring of length `k` starting at `i` with the substring of length `k` starting at `j`. That is, replace the substring `word[i..i + k - 1]` with the substring `word[j..j + k - 1]`.
+
+Return _the **minimum** number of operations required to make_ `word` _**k-periodic**_.
+
+We say that `word` is **k-periodic** if there is some string `s` of length `k` such that `word` can be obtained by concatenating `s` an arbitrary number of times. For example, if `word == “ababab”`, then `word` is 2-periodic for `s = "ab"`.
+
+**Example 1:**
+
+**Input:** word = "leetcodeleet", k = 4
+
+**Output:** 1
+
+**Explanation:**
+
+We can obtain a 4-periodic string by picking i = 4 and j = 0. After this operation, word becomes equal to "leetleetleet".
+
+**Example 2:**
+
+**Input:** word = "leetcoleet", k = 2
+
+**Output:** 3
+
+**Explanation:**
+
+We can obtain a 2-periodic string by applying the operations in the table below.
+
+    i  j  word
+    0  2  etetcoleet
+    4  0  etetetleet
+    6  0  etetetetet
+
+**Constraints:**
+
+*   <code>1 <= n == word.length <= 10<sup>5</sup></code>
+*   `1 <= k <= word.length`
+*   `k` divides `word.length`.
+*   `word` consists only of lowercase English letters.
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+
+class Solution {
+    fun minimumOperationsToMakeKPeriodic(word: String, k: Int): Int {
+        val map: MutableMap<Int, Int> = HashMap()
+        val n = word.length
+        var max = 0
+        var i = 0
+        while (i < n) {
+            var hash = 0
+            for (j in i until i + k) {
+                val idx = word[j].code - 'a'.code
+                hash = hash * 26 + idx
+            }
+            var count = map.getOrDefault(hash, 0)
+            count++
+            map[hash] = count
+            max = max(max, count)
+            i += k
+        }
+        return n / k - max
+    }
+}
+```

src/main/kotlin/g3101_3200/s3137_minimum_number_of_operations_to_make_word_k_periodic/readme.md

@@ -0,0 +1,96 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3138\. Minimum Length of Anagram Concatenation
+
+Medium
+
+You are given a string `s`, which is known to be a concatenation of **anagrams** of some string `t`.
+
+Return the **minimum** possible length of the string `t`.
+
+An **anagram** is formed by rearranging the letters of a string. For example, "aab", "aba", and, "baa" are anagrams of "aab".
+
+**Example 1:**
+
+**Input:** s = "abba"
+
+**Output:** 2
+
+**Explanation:**
+
+One possible string `t` could be `"ba"`.
+
+**Example 2:**
+
+**Input:** s = "cdef"
+
+**Output:** 4
+
+**Explanation:**
+
+One possible string `t` could be `"cdef"`, notice that `t` can be equal to `s`.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consist only of lowercase English letters.
+
+## Solution
+
+```kotlin
+import kotlin.math.sqrt
+
+class Solution {
+    fun minAnagramLength(s: String): Int {
+        val n = s.length
+        val sq = IntArray(n)
+        for (i in s.indices) {
+            val ch = s[i].code
+            if (i == 0) {
+                sq[i] = ch * ch
+            } else {
+                sq[i] = sq[i - 1] + ch * ch
+            }
+        }
+        val factors = getAllFactorsVer2(n)
+        factors.sort()
+        for (j in factors.indices) {
+            val factor = factors[j]
+            if (factor == 1) {
+                if (sq[0] * n == sq[n - 1]) {
+                    return 1
+                }
+            } else {
+                val sum = sq[factor - 1]
+                var start = 0
+                var i = factor - 1
+                while (i < n) {
+                    if (start + sum != sq[i]) {
+                        break
+                    }
+                    start += sum
+                    if (i == n - 1) {
+                        return factor
+                    }
+                    i += factor
+                }
+            }
+        }
+        return n - 1
+    }
+
+    private fun getAllFactorsVer2(n: Int): MutableList<Int> {
+        val factors: MutableList<Int> = ArrayList()
+        var i = 1
+        while (i <= sqrt(n.toDouble())) {
+            if (n % i == 0) {
+                factors.add(i)
+                factors.add(n / i)
+            }
+            i++
+        }
+        return factors
+    }
+}
+```

src/main/kotlin/g3101_3200/s3138_minimum_length_of_anagram_concatenation/readme.md

@@ -0,0 +1,123 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 3139\. Minimum Cost to Equalize Array
+
+Hard
+
+You are given an integer array `nums` and two integers `cost1` and `cost2`. You are allowed to perform **either** of the following operations **any** number of times:
+
+*   Choose an index `i` from `nums` and **increase** `nums[i]` by `1` for a cost of `cost1`.
+*   Choose two **different** indices `i`, `j`, from `nums` and **increase** `nums[i]` and `nums[j]` by `1` for a cost of `cost2`.
+
+Return the **minimum** **cost** required to make all elements in the array **equal**_._
+
+Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [4,1], cost1 = 5, cost2 = 2
+
+**Output:** 15
+
+**Explanation:**
+
+The following operations can be performed to make the values equal:
+
+*   Increase `nums[1]` by 1 for a cost of 5. `nums` becomes `[4,2]`.
+*   Increase `nums[1]` by 1 for a cost of 5. `nums` becomes `[4,3]`.
+*   Increase `nums[1]` by 1 for a cost of 5. `nums` becomes `[4,4]`.
+
+The total cost is 15.
+
+**Example 2:**
+
+**Input:** nums = [2,3,3,3,5], cost1 = 2, cost2 = 1
+
+**Output:** 6
+
+**Explanation:**
+
+The following operations can be performed to make the values equal:
+
+*   Increase `nums[0]` and `nums[1]` by 1 for a cost of 1. `nums` becomes `[3,4,3,3,5]`.
+*   Increase `nums[0]` and `nums[2]` by 1 for a cost of 1. `nums` becomes `[4,4,4,3,5]`.
+*   Increase `nums[0]` and `nums[3]` by 1 for a cost of 1. `nums` becomes `[5,4,4,4,5]`.
+*   Increase `nums[1]` and `nums[2]` by 1 for a cost of 1. `nums` becomes `[5,5,5,4,5]`.
+*   Increase `nums[3]` by 1 for a cost of 2. `nums` becomes `[5,5,5,5,5]`.
+
+The total cost is 6.
+
+**Example 3:**
+
+**Input:** nums = [3,5,3], cost1 = 1, cost2 = 3
+
+**Output:** 4
+
+**Explanation:**
+
+The following operations can be performed to make the values equal:
+
+*   Increase `nums[0]` by 1 for a cost of 1. `nums` becomes `[4,5,3]`.
+*   Increase `nums[0]` by 1 for a cost of 1. `nums` becomes `[5,5,3]`.
+*   Increase `nums[2]` by 1 for a cost of 1. `nums` becomes `[5,5,4]`.
+*   Increase `nums[2]` by 1 for a cost of 1. `nums` becomes `[5,5,5]`.
+
+The total cost is 4.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
+*   <code>1 <= cost1 <= 10<sup>6</sup></code>
+*   <code>1 <= cost2 <= 10<sup>6</sup></code>
+
+## Solution
+
+```kotlin
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun minCostToEqualizeArray(nums: IntArray, cost1: Int, cost2: Int): Int {
+        var max = 0L
+        var min = Long.MAX_VALUE
+        var sum = 0L
+        for (num in nums) {
+            if (num > max) {
+                max = num.toLong()
+            }
+            if (num < min) {
+                min = num.toLong()
+            }
+            sum += num
+        }
+        val n = nums.size
+        var total = max * n - sum
+        // When operation one is always better:
+        if ((cost1 shl 1) <= cost2 || n <= 2) {
+            return (total * cost1 % LMOD).toInt()
+        }
+        // When operation two is moderately better:
+        var op1 = max(0L, (((max - min) shl 1L.toInt()) - total))
+        var op2 = total - op1
+        var result = (op1 + (op2 and 1L)) * cost1 + (op2 shr 1L.toInt()) * cost2
+        // When operation two is significantly better:
+        total += op1 / (n - 2L) * n
+        op1 %= n - 2L
+        op2 = total - op1
+        result = min(result, ((op1 + (op2 and 1L)) * cost1 + (op2 shr 1L.toInt()) * cost2))
+        // When operation two is always better:
+        for (i in 0..1) {
+            total += n.toLong()
+            result = min(result, ((total and 1L) * cost1 + (total shr 1L.toInt()) * cost2))
+        }
+        return (result % LMOD).toInt()
+    }
+
+    companion object {
+        private const val MOD = 1000000007
+        private const val LMOD = MOD.toLong()
+    }
+}
+```