Merge pull request #159

add new problems 28.02

Author: Ashwagandha-coder

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

@@ -1,7 +1,7 @@
 package com.github.contest
 
 
-import com.github.contest.heap.largestInteger
+import com.github.contest.array.sortArrayByParityIIAlternativeSolution
 import java.util.TreeMap
 
 
@@ -11,7 +11,7 @@ import java.util.TreeMap
 
 fun main() {
 
-    largestInteger(1234)
+    sortArrayByParityIIAlternativeSolution(intArrayOf(4, 2, 5, 7)).also { it.printArray() }
 
 }
 

contest/src/main/java/com/github/contest/array/AlternativeSolutionArray.kt

@@ -20,4 +20,23 @@ fun getCommonAlternativeSolution(nums1: IntArray, nums2: IntArray): Int {
     }
 
     return -1
+}
+
+/**
+ * 922. Sort Array By Parity II
+ * Alternative Solution
+ */
+
+fun sortArrayByParityIIAlternativeSolution(nums: IntArray): IntArray {
+    var evenIndex = 0
+    var oddIndex = 1
+    while (evenIndex < nums.size && oddIndex < nums.size) {
+        while (evenIndex < nums.size && nums[evenIndex] % 2 == 0) evenIndex += 2
+        while (oddIndex < nums.size && nums[oddIndex] % 2 != 0) oddIndex += 2
+        if (evenIndex < nums.size && oddIndex < nums.size) {
+            nums[evenIndex] = nums[oddIndex].also { nums[oddIndex] = nums[evenIndex] }
+        }
+    }
+
+    return nums
 }

contest/src/main/java/com/github/contest/array/ArrayLeetcode.kt

@@ -44,28 +44,22 @@ fun candy(ratings: IntArray): Int {
 }
 
 /**
- *
+ * 922. Sort Array By Parity II
  */
 
-fun firstMissingPositive(nums: IntArray): Int {
-    val n = nums.size
-
-    // In-place rearrangement
-    for (i in 0 until n) {
-        while (nums[i] in 1..n && nums[nums[i] - 1] != nums[i]) {
-            val temp = nums[i]
-            nums[i] = nums[temp - 1]
-            nums[temp - 1] = temp
-        }
+fun sortArrayByParityII(nums: IntArray): IntArray {
+    val even = mutableListOf<Int>()
+    val odd = mutableListOf<Int>()
+    for (num in nums) {
+        if (num % 2 == 0) even.add(num)
+        else odd.add(num)
     }
 
-    // Find the missing positive
-    for (i in 0 until n) {
-        if (nums[i] != i + 1) {
-            return i + 1
-        }
+    for (i in nums.indices) {
+        nums[i] = if (i % 2 == 0) even.removeLast() else odd.removeLast()
     }
 
-    // All positives from 1 to n are present
-    return n + 1
-}
+    return nums
+}
+
+

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

@@ -86,4 +86,40 @@ fun findDiagonalOrderAlternativeSolution(nums: List<List<Int>>): IntArray {
 private fun <T> List<T>.hasSingle(): Boolean = when {
     this.size == 1 -> true
     else -> false
+}
+
+/**
+ * 2231. Largest Number After Digit Swaps by Parity
+ * Alternative Solution
+ */
+
+
+fun largestIntegerAltSolution(num: Int): Int {
+    if (num <= 99) return num
+    val odd = PriorityQueue<Int>(reverseOrder())
+    val even = PriorityQueue<Int>(reverseOrder())
+    val str = num.toString()
+    val len = str.length
+
+    for (i in 0 until len) {
+        if (str[i].digitToInt() % 2 == 0) {
+            even.offer(str[i].digitToInt())
+        } else odd.offer(str[i].digitToInt())
+    }
+
+    var res = 0
+    for (i in 0 until len) {
+        if (str[i].digitToInt() % 2 == 0) {
+            val value = even.poll()
+            if (value != 0) res += value
+
+        } else {
+            val value = odd.poll()
+            if (value != 0) res += value
+
+        }
+        if (even.isNotEmpty() || odd.isNotEmpty()) res *= 10
+    }
+
+    return res
 }

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

@@ -96,6 +96,68 @@ fun maxSubsequenceProdVariantII(nums: IntArray, k: Int): IntArray =
         }
 
 
+/**
+ * 2231. Largest Number After Digit Swaps by Parity
+ * Prod Variant
+ */
+
+fun largestIntegerProdVariant(num: Int): Int = when {
+    num <= 99 -> num
+    else -> {
+        val odd = PriorityQueue<Int>(reverseOrder())
+        val even = PriorityQueue<Int>(reverseOrder())
+        val str = num.toString()
+        str.forEach {
+            when {
+                it.digitToInt() % 2 == 0 -> even.offer(it.digitToInt())
+                else -> odd.offer(it.digitToInt())
+            }
+        }
+        var res = 0
+        str.forEach {
+            when {
+                it.digitToInt() % 2 == 0 -> {
+                    val value = even.poll()
+                    if (value != 0) res += value
+                }
+
+                else -> {
+                    val value = odd.poll()
+                    if (value != 0) res += value
+                }
+            }
+            if (even.isNotEmpty() && odd.isNotEmpty()) res *= 10
+        }
+
+        res
+    }
+}
+
+fun largestIntegerProdVariantII(num: Int): Int {
+    val even = PriorityQueue<Int>(reverseOrder())
+    val odd = PriorityQueue<Int>(reverseOrder())
+
+
+    val parityMap = num.toString().map { it.digitToInt() }.map {
+        if (it % 2 == 0) {
+            even.offer(it)
+            true
+        } else {
+            odd.offer(it)
+            false
+        }
+    }
+
+    return buildString {
+        parityMap.forEach {
+            val number = when {
+                it -> even.poll()
+                else -> odd.poll()
+            }
+            append(number)
+        }
+    }.toInt()
+}