Merge pull request #153

add new problems 17.02

Author: Ashwagandha-coder

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

@@ -1,13 +1,33 @@
 package com.github.contest
 
+import com.github.contest.heap.numberGame
+
 
 /**
  * Stand
  */
 
 fun main() {
 
+    numberGame(intArrayOf(5, 4, 2, 3))
+
+
+}
+
 
+fun IntArray.printArray() {
+    var s = when (this.size) {
+        0 -> "[]"
+        1 -> "[${this[0]}]"
+        2 -> "[${this[0]}, ${this[1]}]"
+        else -> {
+            var temp = "[${this[0]}, "
+            for (i in 1 until this.size - 1) temp += "${this[i]}, "
+            temp += "${this[this.size - 1]}]"
+            temp
+        }
+    }
+    println(s)
 }
 
 

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

@@ -0,0 +1,61 @@
+package com.github.contest.backtracking
+
+/**
+ * 1718. Construct the Lexicographically Largest Valid Sequence
+ * Alternative Solution -
+ */
+
+data class State(
+    val index: Int,
+    val num: Int,
+    val arr: IntArray,
+    val used: BooleanArray
+)
+
+fun constructDistancedSequenceIterativeSolution(n: Int): IntArray {
+    val result = IntArray(2 * n - 1) { 0 }
+    val used = BooleanArray(n + 1) { false }
+    val stack = ArrayDeque<State>()
+
+    stack.addLast(State(0, n, result, used))
+
+    while (stack.isNotEmpty()) {
+        val currentState = stack.removeLast()
+        val (index, num, arr, used) = currentState
+
+        if (index == arr.size) {
+            return arr
+        }
+
+        if (arr[index] != 0) {
+            stack.addLast(State(index + 1, n, arr, used))
+            continue
+        }
+
+        for (currentNum in n downTo 1) {
+            if (!used[currentNum] && isValid(currentNum, index, arr)) {
+                val arrCopy = arr.copyOf()
+                val usedCopy = used.copyOf()
+
+                usedCopy[currentNum] = true
+                arrCopy[index] = currentNum
+                if (currentNum != 1) {
+                    arrCopy[index + currentNum + 1] = currentNum
+                }
+
+                stack.addLast(State(index + 1, n, arrCopy, usedCopy))
+            }
+        }
+    }
+
+    return intArrayOf()
+}
+
+
+private fun isValid(num: Int, pos: Int, arr: IntArray): Boolean {
+    if (arr[pos] != 0) return false
+    if (num == 1) return true
+    if (pos + num + 1 >= arr.size) return false
+    if (arr[pos + num + 1] != 0) return false
+    return true
+}

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

@@ -84,3 +84,27 @@ fun constructDistancedSequence(n: Int): IntArray {
     backtrack(0)
     return result
 }
+
+/**
+ * 1079. Letter Tile Possibilities
+ */
+
+fun numTilePossibilities(tiles: String): Int {
+    val count = IntArray(26)
+    for (c in tiles) {
+        count[c - 'A']++
+    }
+    return dfs(count)
+}
+
+private fun dfs(count: IntArray): Int {
+    var sum = 0
+    for (i in 0 until 26) {
+        if (count[i] == 0) continue
+        sum++
+        count[i]--
+        sum += dfs(count)
+        count[i]++
+    }
+    return sum
+}

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

@@ -198,3 +198,46 @@ private fun PriorityQueue<Int>.sum(): Int {
     while (this.isNotEmpty()) sum += this.poll()
     return sum
 }
+
+/**
+ * 2974. Minimum Number Game
+ */
+
+fun numberGame(nums: IntArray): IntArray {
+    val heap = PriorityQueue<Int> { a, b -> a - b }
+    for (num in nums) heap.offer(num)
+    var i = 0
+    while (heap.isNotEmpty()) {
+        val a = heap.poll()
+        val b = heap.poll()
+        nums[i] = b
+        nums[i + 1] = a
+        i += 2
+    }
+
+    return nums
+}
+
+/**
+ * 2335. Minimum Amount of Time to Fill Cups
+ */
+
+fun fillCups(amount: IntArray): Int {
+    val heap = PriorityQueue<Int> { a, b -> b - a }
+    var counter = 0
+    for (water in amount) if (water != 0) heap.offer(water)
+    while (heap.isNotEmpty()) {
+        if (heap.size >= 2) {
+            val one = heap.poll()
+            val two = heap.poll()
+            if (one - 1 != 0) heap.offer(one - 1)
+            if (two - 1 != 0) heap.offer(two - 1)
+        } else {
+            val single = heap.poll()
+            if (single - 1 != 0) heap.offer(single - 1)
+        }
+        counter++
+    }
+
+    return counter
+}

contest/src/main/java/com/github/contest/sorting/SortingLeetcode.kt

@@ -0,0 +1,39 @@
+package com.github.contest.sorting
+
+import kotlin.random.Random
+
+/**
+ * The BogoSort
+ */
+
+class BogoSort {
+    fun bogoSort(list: MutableList<Int>) {
+        while (!isSorted(list)) {
+            shuffle(list)
+        }
+    }
+
+    private fun isSorted(list: List<Int>): Boolean {
+        for (i in 0 until list.size - 1) {
+            if (list[i] > list[i + 1]) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun shuffle(list: MutableList<Int>) {
+        for (i in list.indices) {
+            val j = Random.nextInt(list.size)
+            list.swap(i, j)
+        }
+    }
+
+    private fun MutableList<Int>.swap(from: Int, to: Int) {
+        val temp = this[from]
+        this[from] = this[to]
+        this[to] = temp
+    }
+}
+
+