saving executing files

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,67 +1,15 @@
 package com.github.contest
 
-import com.github.contest.backtracking.punishmentNumberProdVariant
-import com.github.contest.dp.countVowels
-import com.github.contest.graph.findJudge
-import com.github.contest.heap.customStructure.CustomMinHeap
-
 
 /**
  * Stand
  */
 
 fun main() {
 
-    punishmentNumberProdVariant(10).apply { println(this) }
-
-}
 
-private fun IntArray.printArray() {
-    var s = "["
-    this.forEach { s += "$it, " }
-    s += "]"
-    println(s)
 }
 
-fun findJudgeData() {
-    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 = CustomMinHeap<Int>()
-    heap.offer(3)
-    heap.offer(1)
-    heap.offer(2)
-    heap.offer(5)
-
-
-    println(heap.poll())
-
-}

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() }
+    }
+}