Merge pull request #212

add new part of problems

Author: Ashwagandha-coder

app/src/main/java/com/leetcode_kotlin/Executing.kt

@@ -1,7 +1,5 @@
 package com.leetcode_kotlin
 
-import java.util.concurrent.ConcurrentHashMap
-
 
 /**
  * Executing
@@ -10,10 +8,6 @@ import java.util.concurrent.ConcurrentHashMap
 
 fun main() {
 
-    val concurrentHashMap = ConcurrentHashMap<Int, Int>()
-
-    concurrentHashMap.put(1, 5)
-
 
 }
 

contest/src/main/java/com/github/contest/Execute.kt

@@ -1,11 +1,12 @@
 package com.github.contest
 
 
+import com.github.contest.bitManipulation.hammingWeight
 import com.github.contest.math.numberOfPowerfulInt
 import com.github.contest.slidingWindow.customStructure.rabinKarpMultiPattern
 import com.github.contest.slidingWindow.customStructure.slidingWindowClassic
 import com.github.contest.strings.fullJustify
-import com.github.contest.strings.subStrHash
+
 import java.util.TreeMap
 
 
@@ -15,10 +16,11 @@ import java.util.TreeMap
 
 fun main() {
 
-    val list = mutableListOf<Int>(-1)
-    println(list)
+    val str: String? = "ghdirfghdi"
+
 }
 
+
 infix fun Int.myRange(to: Int): IntRange {
     return this..to
 }
@@ -96,9 +98,6 @@ fun fullJustifyData() {
     }
 }
 
-fun subStrHashData() {
-    subStrHash("xxterzixjqrghqyeketqeynekvqhc", 15, 94, 4, 16).also { println(it) }
-}
 
 fun numberOfPowerfulIntData() {
     val start = 141L

contest/src/main/java/com/github/contest/bitManipulation/BitManipulationLeetcode.kt

@@ -22,4 +22,36 @@ fun subsetXORSum(nums: IntArray): Int {
 
     calculateSubsetXOR(0, 0)
     return totalXORSum
+}
+
+/**
+ * 191. Number of 1 Bits
+ */
+
+fun hammingWeight(n: Int): Int {
+    var num = n
+    var count = 0
+
+    while (num != 0) {
+        count += num and 1
+        num = num ushr 1
+    }
+
+    return count
+}
+
+/**
+ * 461. Hamming Distance
+ */
+
+fun hammingDistance(x: Int, y: Int): Int {
+    var res = x xor y
+    var count = 0
+
+    while (res != 0) {
+        count += res and 1
+        res = res ushr 1
+    }
+
+    return count
 }

contest/src/main/java/com/github/contest/design/DesignLeetcode.kt

@@ -40,8 +40,7 @@ class ProductOfNumbers() {
 class WordDictionary() {
 
     data class TrieNode(
-        val children: MutableMap<Char, TrieNode> = mutableMapOf(),
-        var isEndOfWord: Boolean = false
+        val children: MutableMap<Char, TrieNode> = mutableMapOf(), var isEndOfWord: Boolean = false
     )
 
     private val root = TrieNode()
@@ -226,11 +225,7 @@ class CombinationIterator(characters: String, combinationLength: Int) {
     fun hasNext(): Boolean = store.isNotEmpty()
 
     private fun combine(
-        index: Int,
-        str: String,
-        subset: StringBuilder,
-        store: MutableList<String>,
-        limit: Int
+        index: Int, str: String, subset: StringBuilder, store: MutableList<String>, limit: Int
     ) {
 
         if (subset.length == limit) {
@@ -370,4 +365,42 @@ class StockSpanner() {
         return span
     }
 
+}
+
+/**
+ * 1865. Finding Pairs With a Certain Sum
+ */
+
+class FindSumPairs(private val nums1: IntArray, private val nums2: IntArray) {
+
+    private val second = mutableListOf<Long>()
+    private val freq = mutableMapOf<Long, Int>()
+
+    init {
+        for (elem in nums2) {
+            val e = elem.toLong()
+            second.add(e)
+            freq[e] = freq.getOrDefault(e, 0) + 1
+        }
+    }
+
+    fun add(index: Int, `val`: Int) {
+        val old = second[index]
+        second[index] = second[index] + `val`
+        val new = second[index]
+        freq[old] = freq.getOrDefault(old, 0) - 1
+        if (freq[old] == 0) freq.remove(old)
+        freq[new] = freq.getOrDefault(new, 0) + 1
+    }
+
+    fun count(tot: Int): Int {
+        var c = 0
+        for (elem in nums1) {
+            val target = tot - elem
+            if (freq.contains(target.toLong())) c += freq.getOrDefault(target.toLong(), 0)
+        }
+
+        return c
+    }
+
 }

contest/src/main/java/com/github/contest/slidingWindow/SlidingWindowLeetcode.kt

@@ -768,7 +768,30 @@ private fun String.eachCount(): MutableMap<Char, Int> {
     return count
 }
 
+/**
+ * 713. Subarray Product Less Than K
+ */
+
+fun numSubarrayProductLessThanK(nums: IntArray, k: Int): Int = atMostKProduct(nums, k - 1)
+
+private fun atMostKProduct(nums: IntArray, k: Int): Int {
+    var left = 0
+    var product = 1
+    var count = 0
+
+    for (right in nums.indices) {
+        product *= nums[right]
 
+        while (left <= right && product > k) {
+            product /= nums[left]
+            left++
+        }
+
+        count += (right - left + 1)
+    }
+
+    return count
+}
 
 
 

contest/src/main/java/com/github/contest/strings/StringsLeetcode.kt

@@ -1,7 +1,5 @@
 package com.github.contest.strings
 
-import java.math.BigInteger
-
 /**
  * 848. Shifting Letters
  */
@@ -390,38 +388,87 @@ fun lengthOfLastWord(s: String): Int {
 
 
 /**
- *
+ * 2138. Divide a String Into Groups of Size k
  */
 
-fun subStrHash(s: String, power: Int, modulo: Int, k: Int, hashValue: Int): String {
-    var left = 0
+fun divideString(s: String, k: Int, fill: Char): Array<String> {
+    val res = s.split(k, fill)
+    return res
+}
+
+private fun String.split(delimeterSize: Int, fill: Char): Array<String> {
+    val res = mutableListOf<String>()
     var temp = ""
+    var count = delimeterSize
 
-    for (right in s.indices) {
-        temp += s[right]
-        if (right - left == k - 1) {
-            val hash = hash(temp, power, modulo)
-            if (hash.intValueExact() == hashValue.toBigInteger().intValueExact()) return temp
-            temp = temp.substring(1, temp.length)
-            left++
+    for (char in this) {
+        if (count != 0) {
+            temp += char
+            count--
+        } else {
+            res.add(temp)
+            temp = ""
+            temp += char
+            count = delimeterSize - 1
         }
     }
 
-    return ""
+    res.add(temp)
+    val arr = res.toTypedArray()
+    remainingFill(arr, fill, delimeterSize)
+
+    return arr
 }
 
-private fun hash(str: String, power: Int, modulo: Int): BigInteger {
-    var res = 0.toBigInteger()
-    var pow = 0
-    val power = power.toBigInteger()
-    for (element in str) {
-        val index = (element - 'a' + 1).toBigInteger()
-        val base = (power.pow(pow))
-        val calc = index * base
-        res += calc
-        pow++
+private fun remainingFill(strs: Array<String>, pattern: Char, k: Int) {
+    var last = strs[strs.size - 1]
+    var count = 0
+
+    if (last.length == k) return
+    else {
+        count = last.length
+        while (count != k) {
+            last += pattern
+            count++
+        }
+        strs[strs.size - 1] = last
     }
+}
 
-    return res % modulo.toBigInteger()
+/**
+ * 3136. Valid Word
+ */
+
+fun isValid(word: String): Boolean {
+    if (word.length < 3) return false
+
+    var vowels = 0
+    var consonants = 0
+
+    for (char in word) {
+        if (isNotDigit(char) && isNotLetter(char)) return false
+        if (isLetter(char)) {
+            if (isVowel(char)) vowels++
+            else consonants++
+        }
+    }
+
+    return !(vowels == 0 || consonants == 0)
+}
+
+private fun isNotDigit(char: Char) = when {
+    char in '0'..'9' -> false
+    else -> true
+}
+
+private fun isNotLetter(char: Char) = when {
+    char in 'a'..'z' || char in 'A'..'Z' -> false
+    else -> true
 }
 
+private fun isVowel(char: Char) = when {
+    char in "aeiou" || char in "AEIOU" -> true
+    else -> false
+}
+
+

contest/src/main/java/com/github/contest/strings/StringsProdVariant.kt

@@ -65,4 +65,16 @@ fun smallestStringProdVariant(s: String): String {
  * Prod Variant
  */
 
-fun lengthOfLastWordProdVariant(s: String): Int = s.trim().split(" ").lastOrNull()?.length ?: 0
+fun lengthOfLastWordProdVariant(s: String): Int = s.trim().split(" ").lastOrNull()?.length ?: 0
+
+/**
+ * 2138. Divide a String Into Groups of Size k
+ * Prod Variant
+ */
+
+fun divideStringProdVariant(s: String, k: Int, fill: Char): Array<String> = when {
+    s.length % k == 0 -> s.chunked(k).toTypedArray()
+    else -> s.chunked(k).toMutableList().apply {
+        this[this.lastIndex] = this.last().padEnd(k, fill)
+    }.toTypedArray()
+}

contest/src/main/java/com/github/contest/twoPointer/TwoPointerLeetCode.kt

@@ -48,4 +48,22 @@ fun trap(height: IntArray): Int {
     }
 
     return water
+}
+
+/**
+ * 2200. Find All K-Distant Indices in an Array
+ */
+
+fun findKDistantIndices(nums: IntArray, key: Int, k: Int): List<Int> {
+    val result = mutableSetOf<Int>()
+    for (j in nums.indices) {
+        if (nums[j] == key) {
+            val start = maxOf(0, j - k)
+            val end = minOf(nums.size - 1, j + k)
+            for (i in start..end) {
+                result.add(i)
+            }
+        }
+    }
+    return result.sorted()
 }