Merge pull request #148

add new problem 7.02

Author: Ashwagandha-coder

.idea/other.xml

@@ -6,4 +6,12 @@ plugins {
 java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
+}
+
+
+dependencies {
+
+    implementation 'junit:junit:4.13.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.7.1'
+
 }

contest/build.gradle

@@ -8,4 +8,10 @@ fun MutableMap<Int, Int>.removeIfEmptyBucket(key: Int) {
 
 fun Any.printData(label: String) {
     println("$label $this")
+}
+
+
+inline fun abs(number: Int): Int = when {
+    number < 0 -> number * -1
+    else -> number
 }

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

@@ -1,13 +1,15 @@
 package com.github.contest
 
 
+import com.github.contest.dp.divisorGameDp
+
 
 /**
  * Stand
  */
 
 fun main() {
 
-
+    divisorGameDp(6)
 
 }

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

@@ -0,0 +1,12 @@
+package com.github.contest.array
+
+import org.junit.Test
+
+
+class CandyTest {
+
+    @Test
+    fun `first_test_for_candy`() {}
+
+
+}

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

@@ -1,5 +1,8 @@
 package com.github.contest.dp
 
+import com.github.contest.abs
+
+
 /**
  * 1137. N-th Tribonacci Number
  */
@@ -127,4 +130,83 @@ fun longestPalindromeSubseq(s: String): Int {
 private fun String.hasSingle(): Boolean = when {
     this.length == 1 -> true
     else -> false
+}
+
+/**
+ * 647. Palindromic Substrings
+ */
+
+
+fun countSubstrings(s: String): Int {
+    if (s.hasSingle()) return 1
+    val n = s.length
+    var counter = s.length
+    val dp = Array(n) { BooleanArray(n) }
+    for (i in 0 until n) dp[i][i] = true
+
+    for (len in 2..n) {
+        for (i in 0..n - len) {
+            val j = i + len - 1
+            when {
+                len == 2 -> {
+                    if (s[i] == s[j]) {
+                        counter++
+                        dp[i][j] = true
+                    }
+                }
+
+                else -> {
+                    if (s[i] == s[j] && dp[i + 1][j - 1]) {
+                        counter++
+                        dp[i][j] = true
+                    }
+                }
+            }
+        }
+    }
+
+    return counter
+}
+
+/**
+ * 2370. Longest Ideal Subsequence
+ */
+
+fun longestIdealString(s: String, k: Int): Int {
+    val dp = IntArray(26) { 0 }
+
+    for (c in s) {
+        val currIndex = c - 'a'
+        var maxLength = 0
+        for (prevIndex in 0..25) {
+            if (abs(currIndex - prevIndex) <= k) {
+                maxLength = maxOf(maxLength, dp[prevIndex])
+            }
+        }
+        dp[currIndex] = maxOf(dp[currIndex], maxLength + 1)
+    }
+
+    return dp.maxOrNull() ?: 0
+}
+
+/**
+ * 1025. Divisor Game
+ * Dp Approach
+ */
+
+fun divisorGameDp(n: Int): Boolean {
+    if (n <= 1) return false
+    val dp = BooleanArray(n + 1)
+    dp[1] = false // Base case: If n is 1, the current player loses
+
+    for (i in 2..n) {
+        for (x in 1 until i) {
+            if (i % x == 0 && !dp[i - x]) {
+                dp[i] = true
+                break // If we find a winning move, we can stop checking
+            }
+        }
+    }
+
+    return dp[n]
 }

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

@@ -1,5 +1,7 @@
 package com.github.contest.dp
 
+import com.github.contest.abs
+
 
 /**
  * 70. Climbing Stairs
@@ -52,36 +54,34 @@ private fun String.hasSingle(): Boolean = when {
 }
 
 /**
- * 647. Palindromic Substrings
+ * 2370. Longest Ideal Subsequence
+ * Prod Variant
  */
 
 
-fun countSubstrings(s: String): Int {
-    if (s.hasSingle()) return 1
-    val n = s.length
-    var counter = s.length
-    val dp = Array(n) { BooleanArray(n) }
-    for (i in 0 until n) dp[i][i] = true
+fun longestIdealStringProdVariant(s: String, k: Int): Int {
+    val dp = IntArray(26) { 0 }
 
-    for (len in 2..n) {
-        for (i in 0..n - len) {
-            val j = i + len - 1
-            when {
-                len == 2 -> {
-                    if (s[i] == s[j]) {
-                        counter++
-                        dp[i][j] = true
-                    }
-                }
-                else -> {
-                    if (s[i] == s[j] && dp[i + 1][j - 1]) {
-                        counter++
-                        dp[i][j] = true
-                    }
-                }
-            }
+    s.forEach {
+        val index = it - 'a'
+        var len = 0
+        (0..25).forEach { prev ->
+            if (abs(prev - index) <= k) len = maxOf(len, dp[prev])
         }
+        dp[index] = maxOf(dp[index], len + 1)
     }
 
-    return counter
+    return dp.max()
 }
+
+
+fun longestIdealStringProdVariantII(s: String, k: Int): Int =
+    s.fold(IntArray(26)) { dp, c ->
+        val currIndex = c - 'a'
+        dp.apply {
+            this[currIndex] = maxOf(this[currIndex], (0..25).maxOf { prevIndex ->
+                if (abs(currIndex - prevIndex) <= k) this[prevIndex] else 0
+            } + 1)
+        }
+    }.max()
+

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

@@ -116,4 +116,35 @@ fun tupleSameProduct(nums: IntArray): Int {
         if (count > 1) tuples += count * (count - 1) * 4
     }
     return tuples
+}
+
+/**
+ * 1796. Second Largest Digit in a String
+ */
+
+fun secondHighest(s: String): Int {
+    if (s.hasSingle()) return -1
+    val map = mutableMapOf<Int, Int>()
+    for (char in s) {
+        if (isDigit(char)) {
+            val value = char.digitToInt()
+            map[value] = map.getOrDefault(value, 0) + 1
+        }
+    }
+    var keyMax = 0
+    for (key in map.keys) {
+        keyMax = maxOf(keyMax, key)
+    }
+    if (map.contains(keyMax)) map.remove(keyMax)
+
+    return map.keys.maxOrNull() ?: -1
+}
+
+private fun String.hasSingle(): Boolean = when {
+    this.length == 1 -> true
+    else -> false
+}
+
+private fun isDigit(s: Char): Boolean {
+    return s in "0123456789"
 }

contest/src/main/java/com/github/contest/hashTable/HashTableLeetcode.kt

@@ -15,4 +15,5 @@ fun areAlmostEqualProdVariant(s1: String, s2: String): Boolean =
             .let { diff ->
                 diff.size == 2 && s1[diff[0]] == s2[diff[1]] && s1[diff[1]] == s2[diff[0]]
             }
-    }
+    }
+

contest/src/main/java/com/github/contest/hashTable/HashTableProdVariant.kt

@@ -0,0 +1,48 @@
+package com.github.contest.hashTable.test
+
+import com.github.contest.hashTable.areAlmostEqual
+import junit.framework.TestCase.assertEquals
+import org.junit.Test
+
+
+/**
+ * 1790. Check if One String Swap Can Make Strings Equal
+ * Test
+ */
+
+class CheckIfOneStringSwapCanMakeStringsEqualTest {
+
+
+    @Test
+    fun `first_case`() {
+        val s1 = "bank"
+        val s2 = "kanb"
+
+        val expected = true
+        val actual = areAlmostEqual(s1, s2)
+        assertEquals(expected, actual)
+    }
+
+
+    @Test
+    fun `one_element`() {
+        val s1 = "a"
+        val s2 = "b"
+
+        val actual = areAlmostEqual(s1, s2)
+        assertEquals(false, actual)
+    }
+
+
+    @Test
+    fun `two_equals_string`() {
+        val s1 = "anna"
+        val s2 = "anna"
+
+        val actual = areAlmostEqual(s1, s2)
+
+        assertEquals(true, actual)
+    }
+
+
+}