Added tests for tasks 84-2425

Author: ThanhNIT

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

@@ -19,4 +19,44 @@ internal class SolutionTest {
     fun largestRectangleArea3() {
         assertThat(Solution().largestRectangleArea(intArrayOf()), equalTo(0))
     }
+
+    @Test
+    fun largestRectangleArea4() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(5)), equalTo(5))
+    }
+
+    @Test
+    fun largestRectangleArea5() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(3, 6)), equalTo(6))
+    }
+
+    @Test
+    fun largestRectangleArea6() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(2, 2, 2, 2)), equalTo(8))
+    }
+
+    @Test
+    fun largestRectangleArea7() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(1, 2, 3, 4, 5)), equalTo(9))
+    }
+
+    @Test
+    fun largestRectangleArea8() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(5, 4, 3, 2, 1)), equalTo(9))
+    }
+
+    @Test
+    fun largestRectangleArea9() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(2, 1, 5, 6, 2, 3)), equalTo(10))
+    }
+
+    @Test
+    fun largestRectangleArea10() {
+        assertThat(Solution().largestRectangleArea(intArrayOf(1, 1, 1, 1)), equalTo(4))
+    }
+
+    @Test
+    fun largestRectangleArea11() {
+        assertThat(Solution().largestRectangleArea(intArrayOf()), equalTo(0))
+    }
 }

src/test/kotlin/g0201_0300/s0295_find_median_from_data_stream/MedianFinderTest.kt

@@ -28,4 +28,50 @@ internal class MedianFinderTest {
         medianFinder.addNum(-1)
         assertThat(medianFinder.findMedian(), equalTo(1.0))
     }
+
+    @Test
+    fun medianFinder3() {
+        val medianFinder = MedianFinder()
+        medianFinder.addNum(42)
+        assertThat(medianFinder.findMedian(), equalTo(42.0))
+    }
+
+    @Test
+    fun medianFinder4() {
+        val medianFinder = MedianFinder()
+        medianFinder.addNum(5)
+        medianFinder.addNum(5)
+        medianFinder.addNum(5)
+        medianFinder.addNum(5)
+        assertThat(medianFinder.findMedian(), equalTo(5.0))
+    }
+
+    @Test
+    fun medianFinder5() {
+        val medianFinder = MedianFinder()
+        medianFinder.addNum(-5)
+        medianFinder.addNum(-10)
+        medianFinder.addNum(-3)
+        assertThat(medianFinder.findMedian(), equalTo(-5.0))
+    }
+
+    @Test
+    fun medianFinder6() {
+        val medianFinder = MedianFinder()
+        medianFinder.addNum(1000)
+        medianFinder.addNum(1)
+        medianFinder.addNum(500)
+        medianFinder.addNum(0)
+        assertThat(medianFinder.findMedian(), equalTo(250.5))
+    }
+
+    @Test
+    fun medianFinder7() {
+        val medianFinder = MedianFinder()
+        medianFinder.addNum(1)
+        medianFinder.addNum(2)
+        medianFinder.addNum(3)
+        medianFinder.addNum(4)
+        assertThat(medianFinder.findMedian(), equalTo(2.5))
+    }
 }

src/test/kotlin/g0801_0900/s0858_mirror_reflection/SolutionTest.kt

@@ -14,4 +14,39 @@ internal class SolutionTest {
     fun mirrorReflection2() {
         assertThat(Solution().mirrorReflection(3, 1), equalTo(1))
     }
+
+    @Test
+    fun mirrorReflection3() {
+        assertThat(Solution().mirrorReflection(4, 2), equalTo(2))
+    }
+
+    @Test
+    fun mirrorReflection4() {
+        assertThat(Solution().mirrorReflection(6, 3), equalTo(2))
+    }
+
+    @Test
+    fun mirrorReflection5() {
+        assertThat(Solution().mirrorReflection(5, 2), equalTo(0))
+    }
+
+    @Test
+    fun mirrorReflection6() {
+        assertThat(Solution().mirrorReflection(7, 3), equalTo(1))
+    }
+
+    @Test
+    fun mirrorReflection7() {
+        assertThat(Solution().mirrorReflection(1000, 250), equalTo(2))
+    }
+
+    @Test
+    fun mirrorReflection8() {
+        assertThat(Solution().mirrorReflection(4, 4), equalTo(1))
+    }
+
+    @Test
+    fun mirrorReflection9() {
+        assertThat(Solution().mirrorReflection(1, 1), equalTo(1))
+    }
 }

src/test/kotlin/g1901_2000/s1901_find_a_peak_element_ii/SolutionTest.kt

@@ -2,6 +2,7 @@ package g1901_2000.s1901_find_a_peak_element_ii
 
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
 
 internal class SolutionTest {
@@ -20,4 +21,69 @@ internal class SolutionTest {
             equalTo(intArrayOf(1, 1)),
         )
     }
+
+    @Test
+    fun findPeakGrid3() {
+        assertThat(
+            Solution().findPeakGrid(arrayOf(intArrayOf(1, 3, 2, 4))),
+            equalTo(intArrayOf(0, 1)),
+        )
+    }
+
+    @Test
+    fun findPeakGrid4() {
+        assertThat(
+            Solution().findPeakGrid(
+                arrayOf(
+                    intArrayOf(1),
+                    intArrayOf(3),
+                    intArrayOf(2),
+                    intArrayOf(4),
+                ),
+            ),
+            equalTo(intArrayOf(3, 0)),
+        )
+    }
+
+    @Test
+    fun findPeakGrid5() {
+        assertThat(
+            Solution().findPeakGrid(
+                arrayOf(
+                    intArrayOf(2, 2),
+                    intArrayOf(2, 2),
+                ),
+            ),
+            equalTo(intArrayOf(0, 1)),
+        )
+    }
+
+    @Test
+    fun findPeakGrid6() {
+        val mat = arrayOf(
+            intArrayOf(1, 2, 3, 6),
+            intArrayOf(5, 6, 7, 8),
+            intArrayOf(4, 3, 2, 1),
+        )
+
+        val peak = Solution().findPeakGrid(mat)
+
+        Assertions.assertTrue(peak[0] >= 0 && peak[1] >= 0)
+
+        val value = mat[peak[0]][peak[1]]
+        val up = if (peak[0] > 0) mat[peak[0] - 1][peak[1]] else -1
+        val down = if (peak[0] < mat.size - 1) mat[peak[0] + 1][peak[1]] else -1
+        val left = if (peak[1] > 0) mat[peak[0]][peak[1] - 1] else -1
+        val right = if (peak[1] < mat[0].size - 1) mat[peak[0]][peak[1] + 1] else -1
+
+        Assertions.assertTrue(value > up && value > down && value > left && value > right)
+    }
+
+    @Test
+    fun findPeakGrid7() {
+        assertThat(
+            Solution().findPeakGrid(arrayOf(intArrayOf(5))),
+            equalTo(intArrayOf(0, 0)),
+        )
+    }
 }

src/test/kotlin/g2401_2500/s2425_bitwise_xor_of_all_pairings/SolutionTest.kt

@@ -17,4 +17,34 @@ internal class SolutionTest {
     fun xorAllNums2() {
         assertThat(Solution().xorAllNums(intArrayOf(1, 2), intArrayOf(3, 4)), equalTo(0))
     }
+
+    @Test
+    fun xorAllNums3() {
+        assertThat(Solution().xorAllNums(intArrayOf(7), intArrayOf(1, 2, 3)), equalTo(7))
+    }
+
+    @Test
+    fun xorAllNums4() {
+        assertThat(Solution().xorAllNums(intArrayOf(1, 2, 3), intArrayOf(5)), equalTo(5))
+    }
+
+    @Test
+    fun xorAllNums5() {
+        assertThat(Solution().xorAllNums(intArrayOf(8), intArrayOf(6)), equalTo(14))
+    }
+
+    @Test
+    fun xorAllNums6() {
+        assertThat(Solution().xorAllNums(intArrayOf(), intArrayOf(1, 2, 3)), equalTo(0))
+    }
+
+    @Test
+    fun xorAllNums7() {
+        assertThat(Solution().xorAllNums(intArrayOf(4, 5, 6), intArrayOf()), equalTo(0))
+    }
+
+    @Test
+    fun xorAllNums8() {
+        assertThat(Solution().xorAllNums(intArrayOf(), intArrayOf()), equalTo(0))
+    }
 }