Merge pull request #150

add new problems 14.02

Author: Ashwagandha-coder

.idea/other.xml

@@ -1,6 +1,8 @@
 package com.github.contest
 
-import com.github.contest.heap.halveArray
+import com.github.contest.dp.countVowels
+import com.github.contest.graph.findJudge
+import com.github.contest.heap.customStructure.MinHeap
 
 
 /**
@@ -9,7 +11,45 @@ import com.github.contest.heap.halveArray
 
 fun main() {
 
-    halveArray(intArrayOf(7, 7, 7, 31, 2)).also { println(it) }
+    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/Execute.kt

@@ -0,0 +1,32 @@
+package com.github.contest.design
+
+/**
+ * 1352. Product of the Last K Numbers
+ */
+
+class ProductOfNumbers() {
+
+    private val numbers = mutableListOf<Int>()
+
+    fun add(num: Int) {
+        numbers.add(num)
+    }
+
+    fun getProduct(k: Int): Int {
+        return when {
+            k == 1 -> numbers.last()
+            else -> calculateProduct(k)
+        }
+    }
+
+    private fun calculateProduct(k: Int): Int {
+        var res = 1
+        var k = k
+        while (k != 0) {
+            res *= numbers[numbers.size - k]
+            k--
+        }
+        return res
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package com.github.contest.design
+
+/**
+ * 1352. Product of the Last K Numbers
+ * Prod Variant
+ */
+
+class ProductOfNumbersProdVariant() {
+
+    private val products = mutableListOf<Int>()
+
+    fun add(num: Int) {
+        if (num == 0) {
+            products.clear()
+        } else {
+            if (products.isEmpty()) {
+                products.add(num)
+            } else {
+                products.add(products.last() * num)
+            }
+        }
+    }
+
+    fun getProduct(k: Int): Int {
+        if (k > products.size) {
+            return 0
+        }
+        if (k == products.size) {
+            return products.last()
+        }
+        return products.last() / products[products.size - k - 1]
+    }
+}

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

@@ -321,4 +321,43 @@ fun countVowels(word: String): Long {
     }
 
     return totalVowels
+}
+
+/**
+ *
+ */
+
+fun maxTwoEvents(events: Array<IntArray>): Int {
+    val n = events.size
+    events.sortBy { it[0] } // Sort by start time
+    val dp = IntArray(n)
+    var maxVal = 0
+    for (i in n - 1 downTo 0) {
+        maxVal = maxOf(maxVal, events[i][2])
+        dp[i] = maxVal
+    }
+    var res = 0
+    for (i in 0 until n) {
+        val start = events[i][0]
+        val end = events[i][1]
+        val value = events[i][2]
+        val nextIndex = findNextNonOverlapping(events, end)
+        val nextValue = if (nextIndex == n) 0 else dp[nextIndex]
+        res = maxOf(res, value + nextValue)
+    }
+    return res
+}
+
+private fun findNextNonOverlapping(events: Array<IntArray>, end: Int): Int {
+    var left = 0
+    var right = events.size
+    while (left < right) {
+        val mid = left + (right - left) / 2
+        if (events[mid][0] <= end) {
+            left = mid + 1
+        } else {
+            right = mid
+        }
+    }
+    return left
 }

contest/src/main/java/com/github/contest/dp/DpLeetcode.kt

@@ -1,2 +1,19 @@
 package com.github.contest.graph
 
+/**
+ * 997. Find the Town Judge
+ */
+
+fun findJudge(n: Int, trust: Array<IntArray>): Int {
+    if (trust.isEmpty() && n == 1) return 1
+    val inEdges = IntArray(n + 1)
+    for (person in trust) {
+        inEdges[person[0]]--
+        inEdges[person[1]]++
+    }
+
+    for (person in inEdges.indices) {
+        if (inEdges[person] == n - 1) return person
+    }
+    return -1
+}

contest/src/main/java/com/github/contest/graph/GraphLeetcode.kt

@@ -0,0 +1,31 @@
+package com.github.contest.heap
+
+import java.util.PriorityQueue
+
+/**
+ * 3066. Minimum Operations to Exceed Threshold Value II
+ * Alternative Solution
+ */
+
+
+fun minOperationsAlternativeSolution(nums: IntArray, k: Int): Int {
+    var operations = 0
+    val pq = PriorityQueue<Long>()
+    pq.addNums(nums)
+
+    while (pq.size > 1 && pq.peek() < k) {
+        val x = pq.poll()
+        val y = pq.poll()
+        val new = minOf(x, y) * 2 + maxOf(x, y)
+        pq.offer(new)
+        operations++
+    }
+
+    return operations
+}
+
+private fun PriorityQueue<Long>.addNums(nums: IntArray) {
+    val list = mutableListOf<Long>()
+    nums.forEach { list.add(it.toLong()) }
+    this.addAll(list)
+}

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

@@ -0,0 +1,24 @@
+package com.github.contest.heap
+
+import java.util.PriorityQueue
+
+/**
+ * 3066. Minimum Operations to Exceed Threshold Value II
+ * Prod Variant
+ */
+
+fun minOperationProdVariant(nums: IntArray, k: Int): Int {
+    var operation = 0
+    val pq = PriorityQueue<Long>().apply { nums.forEach { offer(it.toLong()) } }
+
+    while (pq.size > 1 && pq.peek() < k) {
+        val (x, y) = listOf(pq.poll(), pq.poll()).sorted()
+        pq.offer(x * 2 + y)
+        operation++
+    }
+
+    return operation
+}
+
+
+

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

@@ -0,0 +1,70 @@
+package com.github.contest.heap.customStructure
+
+class MinHeap<T : Comparable<T>> {
+
+    private val heap: MutableList<T> = mutableListOf()
+
+    val size: Int
+        get() = heap.size
+
+    fun isEmpty(): Boolean = heap.isEmpty()
+
+    fun peek(): T? = heap.firstOrNull()
+
+    fun offer(element: T) {
+        heap.add(element)
+        heapifyUp(heap.size - 1)
+    }
+
+    fun poll(): T? {
+        if (isEmpty()) throw NoSuchElementException("No Elements")
+        swap(0, heap.size - 1)
+        val element = heap.removeLast()
+        heapifyDown(0)
+        return element
+    }
+
+
+    private fun heapifyUp(index: Int) {
+        var currentIndex = index
+        var parentIndex = getParentIndex(currentIndex)
+        while (currentIndex > 0 && heap[currentIndex] < heap[parentIndex]) {
+            swap(currentIndex, parentIndex)
+            currentIndex = parentIndex
+            parentIndex = getParentIndex(currentIndex)
+        }
+    }
+
+    private fun heapifyDown(index: Int) {
+        var currentIndex = index
+        while (hasLeftChild(currentIndex)) {
+            var smallerChildIndex = getLeftChildIndex(currentIndex)
+            if (hasRightChild(currentIndex) && heap[getRightChildIndex(currentIndex)] < heap[smallerChildIndex]) {
+                smallerChildIndex = getRightChildIndex(currentIndex)
+            }
+            if (heap[currentIndex] < heap[smallerChildIndex]) {
+                break
+            } else {
+                swap(currentIndex, smallerChildIndex)
+            }
+            currentIndex = smallerChildIndex
+        }
+    }
+
+
+    private fun getParentIndex(index: Int): Int = (index - 1) / 2
+    private fun getLeftChildIndex(index: Int): Int = 2 * index + 1
+    private fun getRightChildIndex(index: Int): Int = 2 * index + 2
+    private fun hasLeftChild(index: Int): Boolean = getLeftChildIndex(index) < heap.size
+    private fun hasRightChild(index: Int): Boolean = getRightChildIndex(index) < heap.size
+
+    private fun swap(index1: Int, index2: Int) {
+        val temp = heap[index1]
+        heap[index1] = heap[index2]
+        heap[index2] = temp
+    }
+}
+
+
+
+