Merge pull request #155

Ashwagandha-coder · web-flow · commit 9e96ffbe857f · 2025-02-20T23:15:31.000+05:00
add new problems 20.02
diff --git a/contest/src/main/java/com/github/contest/Execute.kt b/contest/src/main/java/com/github/contest/Execute.kt
@@ -1,6 +1,8 @@
 package com.github.contest
 
-import com.github.contest.heap.customStructure.MaxHeap
+
+import com.github.contest.backtracking.findDifferentBinaryString
+import java.util.TreeMap
 
 
 /**
@@ -9,15 +11,19 @@ import com.github.contest.heap.customStructure.MaxHeap
 
 fun main() {
 
-    val maxheap = MaxHeap<Int>()
+    findDifferentBinaryString(arrayOf("00", "01"))
 
-    for (i in 1..39) maxheap.offer(i)
+}
 
-    while (maxheap.isNotEmpty()) {
-        println(maxheap.poll())
-    }
 
+fun workWithTreeMap() {
+    val treeMapOne = TreeMap<String, Int>()
+    treeMapOne["apple"] = 1
+    treeMapOne["banana"] = 2
+    treeMapOne["cherry"] = 3
 
+    println("TreeMap with natural ordering:")
+    treeMapOne.forEach { (key, value) -> println("$key: $value") }
 }
 
 
diff --git a/contest/src/main/java/com/github/contest/array/ArrayProdVariant.kt b/contest/src/main/java/com/github/contest/array/ArrayProdVariant.kt
@@ -15,4 +15,12 @@ fun getCommonProdVariant(nums1: IntArray, nums2: IntArray): Int {
         }
         .filterNotNull()
         .firstOrNull() ?: -1
-}
+}
+
+/**
+ * 3151. Special Array I
+ * Prod Variant
+ */
+
+fun isArraySpecialProdVariant(nums: IntArray): Boolean =
+    nums.isEmpty() || nums.toList().windowed(2).all { (a, b) -> a % 2 != b % 2 }
diff --git a/contest/src/main/java/com/github/contest/backtracking/BacktrackingLeetcode.kt b/contest/src/main/java/com/github/contest/backtracking/BacktrackingLeetcode.kt
@@ -141,4 +141,32 @@ private fun generateHappyString(
             subset.deleteCharAt(subset.length - 1)
         }
     }
+}
+
+/**
+ * 1980. Find Unique Binary String
+ */
+
+
+fun findDifferentBinaryString(nums: Array<String>): String {
+    val set = mutableSetOf<String>()
+    for (num in nums) set.add(num)
+    return generateBinaryString(set, 0, nums[0].length, StringBuilder())
+}
+
+private fun generateBinaryString(set: Set<String>, index: Int, n: Int, str: StringBuilder): String {
+    if (index == n) {
+        return if (!set.contains(str.toString())) str.toString() else ""
+    }
+    repeat(2) {
+        str.append(it.toString())
+        val ans = generateBinaryString(set, index + 1, n, str)
+        if (ans.isNotEmpty()) return ans
+        str.deleteLast()
+    }
+    return ""
+}
+
+private fun StringBuilder.deleteLast() {
+    if (isNotEmpty()) this.deleteCharAt(this.length - 1)
 }
diff --git a/contest/src/main/java/com/github/contest/hashTable/customStructure/CustomConcurrentHashMap.kt b/contest/src/main/java/com/github/contest/hashTable/customStructure/CustomConcurrentHashMap.kt
@@ -3,60 +3,207 @@ 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 HashEntry<K, V>(val key: K, var value: V, var next: HashEntry<K, V>?)
+
     private class Segment<K, V> {
-        val entries = mutableListOf<Entry<K, V>>()
         val lock = ReentrantLock()
+        var table: Array<HashEntry<K, V>?> = arrayOfNulls(16)
+        var count = 0
 
         fun get(key: K): V? = lock.withLock {
-            entries.find { it.key == key }?.value
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            while (entry != null) {
+                if (entry.key == key) {
+                    return entry.value
+                }
+                entry = entry.next
+            }
+            return null
         }
 
         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
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            while (entry != null) {
+                if (entry.key == key) {
+                    val oldValue = entry.value
+                    entry.value = value
+                    return oldValue
+                }
+                entry = entry.next
+            }
+            val newEntry = HashEntry(key, value, table[index])
+            table[index] = newEntry
+            count++
+            if (count >= table.size * 0.75) {
+                rehash()
             }
+            return null
         }
 
         fun remove(key: K): V? = lock.withLock {
-            entries.find { it.key == key }?.let {
-                entries.remove(it)
-                it.value
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            var prev: HashEntry<K, V>? = null
+            while (entry != null) {
+                if (entry.key == key) {
+                    if (prev == null) {
+                        table[index] = entry.next
+                    } else {
+                        prev.next = entry.next
+                    }
+                    count--
+                    return entry.value
+                }
+                prev = entry
+                entry = entry.next
             }
+            return null
         }
 
-        fun size(): Int = lock.withLock { entries.size }
+        private fun rehash() {
+            val oldTable = table
+            val newTableSize = table.size * 2
+            table = arrayOfNulls(newTableSize)
+            count = 0
+            for (entry in oldTable) {
+                var current = entry
+                while (current != null) {
+                    put(current.key, current.value)
+                    current = current.next
+                }
+            }
+        }
+    }
 
-        fun clear() = lock.withLock { entries.clear() }
+    private val segments: Array<Segment<K, V>> = Array(segmentCount) { Segment() }
+
+    private fun getSegment(key: K): Segment<K, V> {
+        val hash = key.hashCode()
+        val index = (hash ushr 16) % segmentCount
+        return segments[index]
     }
 
-    private data class Entry<K, V>(val key: K, var value: V)
+    fun get(key: K): V? = getSegment(key).get(key)
 
-    private val segments: Array<Segment<K, V>> = Array(segmentCount) { Segment() }
+    fun put(key: K, value: V): V? = getSegment(key).put(key, value)
+
+    fun remove(key: K): V? = getSegment(key).remove(key)
+}
+
+
+class CustomConcurrentHashMap<K, V>(private val capacitySegments: Int = 16) {
+
+    private data class HashEntry<K, V>(val key: K, var value: V, var next: HashEntry<K, V>?)
+
+
+    private class Segment<K, V> {
+
+        private val lock = ReentrantLock()
+        private var table: Array<HashEntry<K, V>?> = arrayOfNulls(16)
+        private var count = 0
+
+        fun put(key: K, value: V): V? = lock.withLock {
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            while (entry != null) {
+                if (entry.key == key) {
+                    val oldValue = entry.value
+                    entry.value = value
+                    return oldValue
+                }
+                entry = entry.next
+            }
+            entry = table[index]
+            val newEntry = HashEntry(key, value, table[index])
+            table[index] = newEntry
+            count++
+            if (count >= table.size * 0.75) rehash()
+            return null
+        }
+
+
+        fun get(key: K): V? {
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            while (entry != null) {
+                if (entry.key == key) return entry.value
+                entry = entry.next
+            }
+
+            return null
+        }
+
+        fun remove(key: K): V? = lock.withLock {
+            val hash = key.hashCode()
+            val index = hash % table.size
+            var entry = table[index]
+            var prev: HashEntry<K, V>? = null
+            while (entry != null) {
+                if (entry.key == key) {
+                    if (prev == null) {
+                        table[index] = entry.next
+                    } else prev.next = entry.next
+                    count--
+                    return entry.value
+                }
+                prev = entry
+                entry = entry.next
+            }
+
+            return null
+        }
 
-    private fun getSegmentIndex(key: K): Int = key.hashCode().let { Math.abs(it % segmentCount) }
 
-    fun get(key: K): V? = segments[getSegmentIndex(key)].get(key)
+        private fun rehash() {
+            val oldTable = table
+            val newSize = table.size * 2
+            table = arrayOfNulls(newSize)
+            count = 0
+            for (entry in oldTable) {
+                var current = entry
+                while (current != null) {
+                    put(current.key, current.value)
+                    current = current.next
+                }
+            }
+        }
 
-    fun put(key: K, value: V): V? = segments[getSegmentIndex(key)].put(key, value)
+    }
 
-    fun remove(key: K): V? = segments[getSegmentIndex(key)].remove(key)
+    private val segments = Array<Segment<K, V>>(capacitySegments) { Segment() }
 
-    fun size(): Int = segments.sumOf { it.size() }
+    fun put(key: K, value: V) = getSegment(key).let { it.put(key, value) }
 
-    fun clear() {
-        segments.forEach { it.clear() }
+    fun get(key: K): V? = getSegment(key).let { it.get(key) }
+
+    private fun getSegment(key: K): Segment<K, V> {
+        val hash = key.hashCode()
+        val index = (hash ushr 16) % capacitySegments
+        return segments[index]
     }
-}
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/contest/src/main/java/com/github/contest/heap/HeapAlterantiveSolution.kt b/contest/src/main/java/com/github/contest/heap/HeapAlterantiveSolution.kt
@@ -56,4 +56,34 @@ fun deleteGreatestValueAltSolution(grid: Array<IntArray>): Int {
     }
 
     return sum
+}
+
+/**
+ * 1424. Diagonal Traverse II
+ * Alternative Solution
+ */
+
+
+fun findDiagonalOrderAlternativeSolution(nums: List<List<Int>>): IntArray {
+    if (nums.hasSingle()) nums[0].toIntArray()
+    val map = mutableMapOf<Int, MutableList<Int>>()
+    for (i in nums.indices) {
+        for (j in 0 until nums[i].size) {
+            map.getOrPut(i + j) { mutableListOf() }.let { it.add(nums[i][j]) }
+        }
+    }
+    var diagonal = 0
+    val result = mutableListOf<Int>()
+    while (map.contains(diagonal)) {
+        val values = map.getOrDefault(diagonal, mutableListOf())
+        for (i in values.size - 1 downTo 0) result.add(values[i])
+        diagonal++
+    }
+
+    return result.toIntArray()
+}
+
+private fun <T> List<T>.hasSingle(): Boolean = when {
+    this.size == 1 -> true
+    else -> false
 }
diff --git a/contest/src/main/java/com/github/contest/heap/HeapLeetcode.kt b/contest/src/main/java/com/github/contest/heap/HeapLeetcode.kt
diff --git a/contest/src/main/java/com/github/contest/heap/HeapProdVariant.kt b/contest/src/main/java/com/github/contest/heap/HeapProdVariant.kt
