Added tests for tasks 33-1036

src/main/kotlin/g0901_1000/s0972_equal_rational_numbers/Solution.kt

@@ -2,21 +2,41 @@ package g0901_1000.s0972_equal_rational_numbers
 
 // #Hard #String #Math #2023_05_06_Time_130_ms_(100.00%)_Space_35.4_MB_(50.00%)
 
-import kotlin.math.abs
-import kotlin.math.pow
-
 class Solution {
-    fun isRationalEqual(s: String, t: String): Boolean {
-        return abs(valueOf(s) - valueOf(t)) < 1e-9
+    private fun repeat(a: String): String {
+        return a.repeat(100)
     }
-    private val ratios = doubleArrayOf(1.0, 1.0 / 9, 1.0 / 99, 1.0 / 999, 1.0 / 9999)
-    private fun valueOf(s: String): Double {
-        if (!s.contains("(")) return java.lang.Double.valueOf(s)
-        val integerNonRepeating = java.lang.Double.valueOf(s.substring(0, s.indexOf('(')))
-        val nonRepeatingLength = s.indexOf('(') - s.indexOf('.') - 1
-        val repeating = s.substring(s.indexOf('(') + 1, s.indexOf(')')).toInt()
-        val repeatingLength = s.indexOf(')') - s.indexOf('(') - 1
-        return integerNonRepeating +
-            repeating * 0.1.pow(nonRepeatingLength.toDouble()) * ratios[repeatingLength]
+
+    fun isRationalEqual(s: String, t: String): Boolean {
+        val sLeftIndex = s.indexOf("(")
+        val tLeftIndex = t.indexOf("(")
+
+        if (sLeftIndex < 0 && tLeftIndex < 0) {
+            return s.toDouble() == t.toDouble()
+        }
+
+        var sModified = s
+        val sDouble: Double
+        if (sLeftIndex >= 0) {
+            val repeatingPart = s.substring(sLeftIndex + 1, s.length - 1)
+            sModified = s.substring(0, sLeftIndex) + repeat(repeatingPart)
+
+            sDouble = sModified.substring(0, minOf(sModified.length, 100)).toDouble()
+        } else {
+            sDouble = sModified.toDouble()
+        }
+
+        var tModified = t
+        val tDouble: Double
+        if (tLeftIndex >= 0) {
+            val repeatingPart = t.substring(tLeftIndex + 1, t.length - 1)
+            tModified = t.substring(0, tLeftIndex) + repeat(repeatingPart)
+
+            tDouble = tModified.substring(0, minOf(tModified.length, 100)).toDouble()
+        } else {
+            tDouble = tModified.toDouble()
+        }
+
+        return sDouble == tDouble
     }
 }

src/test/kotlin/g0001_0100/s0033_search_in_rotated_sorted_array/SolutionTest.kt

@@ -19,4 +19,64 @@ internal class SolutionTest {
     fun search3() {
         assertThat(Solution().search(intArrayOf(1), 0), equalTo(-1))
     }
+
+    @Test
+    fun search4() {
+        assertThat(Solution().search(intArrayOf(1, 2, 3, 4, 5, 6), 4), equalTo(3))
+    }
+
+    @Test
+    fun search5() {
+        assertThat(Solution().search(intArrayOf(1, 2, 3, 4, 5, 6), 10), equalTo(-1))
+    }
+
+    @Test
+    fun search6() {
+        assertThat(Solution().search(intArrayOf(6, 7, 0, 1, 2, 3, 4), 7), equalTo(1))
+    }
+
+    @Test
+    fun search7() {
+        assertThat(Solution().search(intArrayOf(6, 7, 0, 1, 2, 3, 4), 3), equalTo(5))
+    }
+
+    @Test
+    fun search8() {
+        assertThat(Solution().search(intArrayOf(5, 1), 1), equalTo(1))
+    }
+
+    @Test
+    fun search9() {
+        assertThat(Solution().search(intArrayOf(5, 1), 2), equalTo(-1))
+    }
+
+    @Test
+    fun search10() {
+        assertThat(Solution().search(intArrayOf(4, 5, 6, 7, 0, 1, 2), 4), equalTo(0))
+    }
+
+    @Test
+    fun search11() {
+        assertThat(Solution().search(intArrayOf(4, 5, 6, 7, 0, 1, 2), 2), equalTo(6))
+    }
+
+    @Test
+    fun search12() {
+        assertThat(Solution().search(intArrayOf(2, 3, 4, 5, 6, 0, 1), 0), equalTo(5))
+    }
+
+    @Test
+    fun search13() {
+        assertThat(Solution().search(intArrayOf(0, 1, 2, 3, 4, 5), 3), equalTo(3))
+    }
+
+    @Test
+    fun search14() {
+        assertThat(Solution().search(intArrayOf(5, 6, 7, 0, 1, 2, 3), 2), equalTo(5))
+    }
+
+    @Test
+    fun search15() {
+        assertThat(Solution().search(intArrayOf(5, 6, 7, 0, 1, 2, 3), 6), equalTo(1))
+    }
 }

src/test/kotlin/g0601_0700/s0622_design_circular_queue/MyCircularQueueTest.kt

@@ -18,4 +18,71 @@ internal class MyCircularQueueTest {
         assertThat(myCircularQueue.enQueue(4), equalTo(true))
         assertThat(myCircularQueue.Rear(), equalTo(4))
     }
+
+    @Test
+    fun myCircularQueue2() {
+        val q = MyCircularQueue(3)
+        assertThat(q.enQueue(1), equalTo(true))
+        assertThat(q.enQueue(2), equalTo(true))
+        assertThat(q.enQueue(3), equalTo(true))
+        assertThat(q.enQueue(4), equalTo(false))
+        assertThat(q.Rear(), equalTo(3))
+        assertThat(q.isFull(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.enQueue(4), equalTo(true))
+        assertThat(q.Rear(), equalTo(4))
+    }
+
+    @Test
+    fun myCircularQueue3() {
+        val q = MyCircularQueue(2)
+        assertThat(q.Front(), equalTo(-1))
+        assertThat(q.Rear(), equalTo(-1))
+        assertThat(q.deQueue(), equalTo(false))
+        assertThat(q.isEmpty(), equalTo(true))
+    }
+
+    @Test
+    fun myCircularQueue4() {
+        val q = MyCircularQueue(1)
+        assertThat(q.enQueue(10), equalTo(true))
+        assertThat(q.isFull(), equalTo(true))
+        assertThat(q.Front(), equalTo(10))
+        assertThat(q.Rear(), equalTo(10))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.isEmpty(), equalTo(true))
+        assertThat(q.Front(), equalTo(-1))
+        assertThat(q.Rear(), equalTo(-1))
+    }
+
+    @Test
+    fun myCircularQueue5() {
+        val q = MyCircularQueue(3)
+        assertThat(q.enQueue(1), equalTo(true))
+        assertThat(q.enQueue(2), equalTo(true))
+        assertThat(q.enQueue(3), equalTo(true))
+        assertThat(q.isFull(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.enQueue(4), equalTo(true))
+        assertThat(q.Front(), equalTo(2))
+        assertThat(q.Rear(), equalTo(4))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(false))
+    }
+
+    @Test
+    fun myCircularQueue6() {
+        val q = MyCircularQueue(2)
+        assertThat(q.enQueue(5), equalTo(true))
+        assertThat(q.enQueue(6), equalTo(true))
+        assertThat(q.isFull(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.deQueue(), equalTo(true))
+        assertThat(q.isEmpty(), equalTo(true))
+        assertThat(q.enQueue(7), equalTo(true))
+        assertThat(q.Front(), equalTo(7))
+        assertThat(q.Rear(), equalTo(7))
+    }
 }

src/test/kotlin/g0701_0800/s0782_transform_to_chessboard/SolutionTest.kt

@@ -92,4 +92,58 @@ internal class SolutionTest {
             equalTo(1),
         )
     }
+
+    @Test
+    fun movesToChessboard8() {
+        val grid = arrayOf(
+            intArrayOf(0, 0),
+            intArrayOf(0, 1),
+        )
+        assertThat(Solution().movesToChessboard(grid), equalTo(-1))
+    }
+
+    @Test
+    fun movesToChessboard9() {
+        val grid = arrayOf(
+            intArrayOf(1, 1),
+            intArrayOf(1, 1),
+        )
+        assertThat(Solution().movesToChessboard(grid), equalTo(-1))
+    }
+
+    @Test
+    fun movesToChessboard10() {
+        val grid = arrayOf(
+            intArrayOf(1, 0),
+            intArrayOf(1, 0),
+        )
+        assertThat(Solution().movesToChessboard(grid), equalTo(-1))
+    }
+
+    @Test
+    fun movesToChessboard11() {
+        val grid = arrayOf(
+            intArrayOf(1, 0, 1),
+            intArrayOf(0, 1, 0),
+            intArrayOf(1, 0, 1),
+        )
+        assertThat(Solution().movesToChessboard(grid), equalTo(0))
+    }
+
+    @Test
+    fun movesToChessboard12() {
+        val grid = arrayOf(
+            intArrayOf(1, 0, 0, 1),
+            intArrayOf(0, 1, 1, 0),
+            intArrayOf(1, 0, 0, 1),
+            intArrayOf(0, 1, 1, 0),
+        )
+        assertThat(Solution().movesToChessboard(grid), equalTo(1))
+    }
+
+    @Test
+    fun movesToChessboard13() {
+        val grid = arrayOf(intArrayOf(0))
+        assertThat(Solution().movesToChessboard(grid), equalTo(0))
+    }
 }

src/test/kotlin/g0901_1000/s0972_equal_rational_numbers/SolutionTest.kt

@@ -19,4 +19,49 @@ internal class SolutionTest {
     fun isRationalEqual3() {
         assertThat(Solution().isRationalEqual("0.9(9)", "1."), equalTo(true))
     }
+
+    @Test
+    fun isRationalEqual4() {
+        assertThat(Solution().isRationalEqual("3.14", "3.14"), equalTo(true))
+    }
+
+    @Test
+    fun isRationalEqual5() {
+        assertThat(Solution().isRationalEqual("3.14", "3.15"), equalTo(false))
+    }
+
+    @Test
+    fun isRationalEqual6() {
+        assertThat(Solution().isRationalEqual("0.(3)", "0.3333333333"), equalTo(false))
+    }
+
+    @Test
+    fun isRationalEqual7() {
+        assertThat(Solution().isRationalEqual("0.(12)", "0.(13)"), equalTo(false))
+    }
+
+    @Test
+    fun isRationalEqual8() {
+        assertThat(Solution().isRationalEqual("1.(0)", "1."), equalTo(true))
+    }
+
+    @Test
+    fun isRationalEqual9() {
+        assertThat(Solution().isRationalEqual("0.(987654321)", "0.(987654321)"), equalTo(true))
+    }
+
+    @Test
+    fun isRationalEqual10() {
+        assertThat(Solution().isRationalEqual("42", "42"), equalTo(true))
+    }
+
+    @Test
+    fun isRationalEqual11() {
+        assertThat(Solution().isRationalEqual("42", "42.0"), equalTo(true))
+    }
+
+    @Test
+    fun isRationalEqual12() {
+        assertThat(Solution().isRationalEqual("0.(1)", "0.(2)"), equalTo(false))
+    }
 }

src/test/kotlin/g1001_1100/s1036_escape_a_large_maze/SolutionTest.kt

@@ -22,4 +22,92 @@ internal class SolutionTest {
             equalTo(true),
         )
     }
+
+    @Test
+    fun isEscapePossible3() {
+        val blocked = arrayOf(intArrayOf(1, 1))
+        val source = intArrayOf(0, 0)
+        val target = intArrayOf(1, 1)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible4() {
+        val blocked = arrayOf(intArrayOf(10, 10))
+        val source = intArrayOf(0, 0)
+        val target = intArrayOf(0, 1)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible5() {
+        val blocked = arrayOf(
+            intArrayOf(0, 2),
+            intArrayOf(1, 2),
+            intArrayOf(2, 2),
+        )
+        val source = intArrayOf(0, 0)
+        val target = intArrayOf(3, 3)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible6() {
+        val blocked = arrayOf(
+            intArrayOf(0, 1),
+            intArrayOf(0, 2),
+            intArrayOf(1, 0),
+            intArrayOf(2, 0),
+        )
+        val source = intArrayOf(0, 0)
+        val target = intArrayOf(3, 3)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(false))
+    }
+
+    @Test
+    fun isEscapePossible7() {
+        val blocked = arrayOf(
+            intArrayOf(999998, 999999),
+            intArrayOf(999999, 999998),
+        )
+        val source = intArrayOf(999999, 999999)
+        val target = intArrayOf(0, 0)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(false))
+    }
+
+    @Test
+    fun isEscapePossible8() {
+        val blocked = arrayOf(
+            intArrayOf(5, 5),
+            intArrayOf(5, 6),
+            intArrayOf(6, 5),
+        )
+        val source = intArrayOf(5, 7)
+        val target = intArrayOf(6, 6)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible9() {
+        val blocked = arrayOf(intArrayOf(1, 2))
+        val source = intArrayOf(2, 2)
+        val target = intArrayOf(2, 2)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible10() {
+        val blocked = arrayOf<IntArray>()
+        val source = intArrayOf(0, 0)
+        val target = intArrayOf(0, 1)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
+
+    @Test
+    fun isEscapePossible11() {
+        val blocked = arrayOf(intArrayOf(2, 2))
+        val source = intArrayOf(2, 1)
+        val target = intArrayOf(2, 2)
+        assertThat(Solution().isEscapePossible(blocked, source, target), equalTo(true))
+    }
 }