Merge pull request #151

add new problems 16.02

Author: Ashwagandha-coder

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

@@ -1,5 +1,7 @@
 package com.leetcode_kotlin
 
+import java.util.concurrent.ConcurrentHashMap
+
 
 /**
  * Executing
@@ -8,11 +10,10 @@ package com.leetcode_kotlin
 
 fun main() {
 
+    val concurrentHashMap = ConcurrentHashMap<Int, Int>()
+
+    concurrentHashMap.put(1, 5)
 
-    val arr = intArrayOf(1, 4, 6, 7, 3, 7, 7)
-    arr.drop(1).forEachIndexed { index, num ->
-        println("$index $num")
-    }
 
 }
 

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

@@ -1,55 +1,15 @@
 package com.github.contest
 
-import com.github.contest.dp.countVowels
-import com.github.contest.graph.findJudge
-import com.github.contest.heap.customStructure.MinHeap
-
 
 /**
  * Stand
  */
 
 fun main() {
 
-    findJudge(
-        5,
-        arrayOf(
-            intArrayOf(1, 3),
-            intArrayOf(2, 3),
-            intArrayOf(4, 3),
-            intArrayOf(4, 1),
-            intArrayOf(5, 3),
-            intArrayOf(5, 1),
-            intArrayOf(5, 4)
-        )
-    )
 
 }
 
-fun vowels() {
-
-    /**
-     * a a a
-     * aa
-     * aa
-     * aaa
-     * count - 10
-     */
-
-    countVowels("aaa")
-
-}
 
 
-fun heapWork() {
 
-    val heap = MinHeap<Int>()
-    heap.offer(3)
-    heap.offer(1)
-    heap.offer(2)
-    heap.offer(5)
-
-
-    println(heap.poll())
-
-}

contest/src/main/java/com/github/contest/backtracking/BacktrackingLeetcode.kt

@@ -1,2 +1,86 @@
 package com.github.contest.backtracking
 
+/**
+ * 2698. Find the Punishment Number of an Integer
+ */
+
+
+fun punishmentNumber(n: Int): Int {
+    var sum = 0
+    for (i in 1..n) {
+        if (isPunishmentNumber(i)) {
+            sum += i * i
+        }
+    }
+    return sum
+}
+
+
+private fun isPunishmentNumber(n: Int): Boolean {
+    val square = n * n
+    val squareStr = square.toString()
+    return canSplit(squareStr, 0, n, 0)
+}
+
+
+private fun canSplit(squareStr: String, index: Int, target: Int, currentSum: Int): Boolean {
+    if (index == squareStr.length) {
+        return currentSum == target
+    }
+
+    var currentNum = 0
+    for (i in index until squareStr.length) {
+        currentNum = currentNum * 10 + (squareStr[i] - '0')
+        if (canSplit(squareStr, i + 1, target, currentSum + currentNum)) {
+            return true
+        }
+    }
+    return false
+}
+
+/**
+ * 1718. Construct the Lexicographically Largest Valid Sequence
+ */
+
+
+fun constructDistancedSequence(n: Int): IntArray {
+    val result = IntArray(2 * n - 1)
+    val used = BooleanArray(n + 1)
+
+    fun backtrack(index: Int): Boolean {
+        if (index == result.size) {
+            return true
+        }
+        if (result[index] != 0) {
+            return backtrack(index + 1)
+        }
+
+        for (num in n downTo 1) {
+            if (!used[num]) {
+                if (num == 1) {
+                    result[index] = num
+                    used[num] = true
+                    if (backtrack(index + 1)) {
+                        return true
+                    }
+                    used[num] = false
+                    result[index] = 0
+                } else if (index + num < result.size && result[index + num] == 0) {
+                    result[index] = num
+                    result[index + num] = num
+                    used[num] = true
+                    if (backtrack(index + 1)) {
+                        return true
+                    }
+                    used[num] = false
+                    result[index] = 0
+                    result[index + num] = 0
+                }
+            }
+        }
+        return false
+    }
+
+    backtrack(0)
+    return result
+}

contest/src/main/java/com/github/contest/backtracking/BacktrackingProdVariant.kt

@@ -0,0 +1,25 @@
+package com.github.contest.backtracking
+
+/**
+ * 2698. Find the Punishment Number of an Integer
+ * Prod Variant
+ */
+
+
+fun punishmentNumberProdVariant(n: Int): Int {
+    return (1..n).filter { isPunishment(it) }.sumOf { it * it }
+}
+
+private fun isPunishment(num: Int): Boolean {
+    val squareStr = (num * num).toString()
+
+    fun backtrack(index: Int, currentSum: Int): Boolean = when {
+        index == squareStr.length -> currentSum == num
+        else -> (index until squareStr.length).any { i ->
+            val subNum = squareStr.substring(index, i + 1).toInt()
+            backtrack(i + 1, currentSum + subNum)
+        }
+    }
+
+    return backtrack(0, 0)
+}

contest/src/main/java/com/github/contest/hashTable/customStructure/CustomConcurrentHashMap.kt

@@ -0,0 +1,62 @@
+package com.github.contest.hashTable.customStructure
+
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+class CustomConcurrentHashMap<T> {
+
+
+}
+
+
+class MyConcurrentHashMap<K, V>(private val segmentCount: Int = 16) {
+
+    private class Segment<K, V> {
+        val entries = mutableListOf<Entry<K, V>>()
+        val lock = ReentrantLock()
+
+        fun get(key: K): V? = lock.withLock {
+            entries.find { it.key == key }?.value
+        }
+
+        fun put(key: K, value: V): V? = lock.withLock {
+            entries.find { it.key == key }?.let {
+                val oldValue = it.value
+                it.value = value
+                oldValue
+            } ?: run {
+                entries.add(Entry(key, value))
+                null
+            }
+        }
+
+        fun remove(key: K): V? = lock.withLock {
+            entries.find { it.key == key }?.let {
+                entries.remove(it)
+                it.value
+            }
+        }
+
+        fun size(): Int = lock.withLock { entries.size }
+
+        fun clear() = lock.withLock { entries.clear() }
+    }
+
+    private data class Entry<K, V>(val key: K, var value: V)
+
+    private val segments: Array<Segment<K, V>> = Array(segmentCount) { Segment() }
+
+    private fun getSegmentIndex(key: K): Int = key.hashCode().let { Math.abs(it % segmentCount) }
+
+    fun get(key: K): V? = segments[getSegmentIndex(key)].get(key)
+
+    fun put(key: K, value: V): V? = segments[getSegmentIndex(key)].put(key, value)
+
+    fun remove(key: K): V? = segments[getSegmentIndex(key)].remove(key)
+
+    fun size(): Int = segments.sumOf { it.size() }
+
+    fun clear() {
+        segments.forEach { it.clear() }
+    }
+}

contest/src/main/java/com/github/contest/heap/HeapAlterantiveSolution.kt

@@ -28,4 +28,32 @@ private fun PriorityQueue<Long>.addNums(nums: IntArray) {
     val list = mutableListOf<Long>()
     nums.forEach { list.add(it.toLong()) }
     this.addAll(list)
+}
+
+/**
+ * 2500. Delete Greatest Value in Each Row
+ * Alternative Solution
+ */
+
+
+fun deleteGreatestValueAltSolution(grid: Array<IntArray>): Int {
+    val pqRows = Array(grid.size) { PriorityQueue<Int>(reverseOrder()) }
+
+    for (i in 0 until grid.size) {
+        for (num in grid[i]) {
+            pqRows[i].offer(num)
+        }
+    }
+
+    var sum = 0
+
+    while (pqRows[0].isNotEmpty()) {
+        var maxVal = 0
+        for (pq in pqRows) {
+            maxVal = maxOf(maxVal, pq.poll())
+        }
+        sum += maxVal
+    }
+
+    return sum
 }