Added tests for tasks 335-3132

src/test/kotlin/g0301_0400/s0335_self_crossing/SolutionTest.kt

@@ -37,6 +37,61 @@ internal class SolutionTest {
 
     @Test
     fun isSelfCrossing7() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(3, 3, 3, 2, 1, 1)), equalTo(false))
+    }
+
+    @Test
+    fun isSelfCrossing8() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(2, 3, 4, 5, 6, 7)), equalTo(false))
+    }
+
+    @Test
+    fun isSelfCrossing9() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(2, 2, 3, 2, 2)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing10() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(1, 1, 2, 1, 2, 1)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing11() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(10, 20, 30, 40, 50)), equalTo(false))
+    }
+
+    @Test
+    fun isSelfCrossing12() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(3, 3, 4, 2, 2)), equalTo(false))
+    }
+
+    @Test
+    fun isSelfCrossing13() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(2, 1, 2, 1)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing14() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(1, 2, 3, 4, 5, 6, 7, 8)), equalTo(false))
+    }
+
+    @Test
+    fun isSelfCrossing15() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(2, 2, 2, 2, 2, 2)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing16() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(1, 1, 2, 1, 1)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing17() {
+        assertThat(Solution().isSelfCrossing(intArrayOf(1, 1, 2, 2, 1, 1)), equalTo(true))
+    }
+
+    @Test
+    fun isSelfCrossing18() {
         assertThat(Solution().isSelfCrossing(intArrayOf(1, 1, 2, 2, 1, 1)), equalTo(true))
     }
 }

src/test/kotlin/g0601_0700/s0641_design_circular_deque/MyCircularDequeTest.kt

@@ -18,4 +18,75 @@ internal class MyCircularDequeTest {
         assertThat(myCircularDeque.insertFront(4), equalTo(true))
         assertThat(myCircularDeque.getFront(), equalTo(4))
     }
+
+    @Test
+    fun myCircularDequeTest2() {
+        val deque = MyCircularDeque(2)
+        assertThat(deque.insertFront(10), equalTo(true))
+        assertThat(deque.insertFront(20), equalTo(true))
+        assertThat(deque.insertFront(30), equalTo(false))
+        assertThat(deque.getFront(), equalTo(20))
+        assertThat(deque.deleteFront(), equalTo(true))
+        assertThat(deque.getFront(), equalTo(10))
+    }
+
+    @Test
+    fun myCircularDequeTest3() {
+        val deque = MyCircularDeque(1)
+        assertThat(deque.deleteFront(), equalTo(false))
+        assertThat(deque.deleteLast(), equalTo(false))
+        assertThat(deque.getFront(), equalTo(-1))
+        assertThat(deque.getRear(), equalTo(-1))
+        assertThat(deque.isEmpty(), equalTo(true))
+        assertThat(deque.isFull(), equalTo(false))
+    }
+
+    @Test
+    fun myCircularDequeTest4() {
+        val deque = MyCircularDeque(2)
+        assertThat(deque.insertLast(5), equalTo(true))
+        assertThat(deque.insertFront(6), equalTo(true))
+        assertThat(deque.isFull(), equalTo(true))
+        assertThat(deque.insertFront(7), equalTo(false))
+        assertThat(deque.getFront(), equalTo(6))
+        assertThat(deque.getRear(), equalTo(5))
+    }
+
+    @Test
+    fun myCircularDequeTest5() {
+        val deque = MyCircularDeque(3)
+        assertThat(deque.insertFront(10), equalTo(true))
+        assertThat(deque.deleteFront(), equalTo(true))
+        assertThat(deque.insertLast(20), equalTo(true))
+        assertThat(deque.deleteLast(), equalTo(true))
+        assertThat(deque.isEmpty(), equalTo(true))
+    }
+
+    @Test
+    fun myCircularDequeTest6() {
+        val deque = MyCircularDeque(1)
+        assertThat(deque.insertFront(100), equalTo(true))
+        assertThat(deque.isFull(), equalTo(true))
+        assertThat(deque.getFront(), equalTo(100))
+        assertThat(deque.getRear(), equalTo(100))
+        assertThat(deque.deleteFront(), equalTo(true))
+        assertThat(deque.isEmpty(), equalTo(true))
+    }
+
+    @Test
+    fun myCircularDequeTest7() {
+        val deque = MyCircularDeque(5)
+        deque.insertFront(1)
+        deque.insertLast(2)
+        deque.insertFront(3)
+        deque.insertLast(4)
+        deque.insertFront(5)
+        assertThat(deque.isFull(), equalTo(true))
+        deque.deleteFront()
+        deque.deleteLast()
+        assertThat(deque.insertFront(6), equalTo(true))
+        assertThat(deque.insertLast(7), equalTo(true))
+        assertThat(deque.getFront(), equalTo(6))
+        assertThat(deque.getRear(), equalTo(7))
+    }
 }

src/test/kotlin/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/SolutionTest.kt

@@ -14,4 +14,44 @@ internal class SolutionTest {
     fun canBeEqual2() {
         assertThat(Solution().canBeEqual("abcd", "cdab"), equalTo(true))
     }
+
+    @Test
+    fun canBeEqual3() {
+        assertThat(Solution().canBeEqual("abcd", "abcd"), equalTo(true))
+    }
+
+    @Test
+    fun canBeEqual4() {
+        assertThat(Solution().canBeEqual("abcd", "cbad"), equalTo(true))
+    }
+
+    @Test
+    fun canBeEqual5() {
+        assertThat(Solution().canBeEqual("abcd", "adcb"), equalTo(true))
+    }
+
+    @Test
+    fun canBeEqual6() {
+        assertThat(Solution().canBeEqual("abcd", "abdc"), equalTo(false))
+    }
+
+    @Test
+    fun canBeEqual7() {
+        assertThat(Solution().canBeEqual("abcd", "wxyz"), equalTo(false))
+    }
+
+    @Test
+    fun canBeEqual8() {
+        assertThat(Solution().canBeEqual("aabb", "bbaa"), equalTo(true))
+    }
+
+    @Test
+    fun canBeEqual9() {
+        assertThat(Solution().canBeEqual("abcd", "cdab"), equalTo(true))
+    }
+
+    @Test
+    fun canBeEqual10() {
+        assertThat(Solution().canBeEqual("abba", "baab"), equalTo(true))
+    }
 }

src/test/kotlin/g3001_3100/s3024_type_of_triangle/SolutionTest.kt

@@ -14,4 +14,70 @@ internal class SolutionTest {
     fun triangleType2() {
         assertThat(Solution().triangleType(intArrayOf(3, 4, 5)), equalTo("scalene"))
     }
+
+    @Test
+    fun triangleType3() {
+        assertThat(Solution().triangleType(intArrayOf(5, 5, 3)), equalTo("isosceles"))
+    }
+
+    @Test
+    fun triangleType4() {
+        assertThat(Solution().triangleType(intArrayOf(1, 2, 3)), equalTo("none"))
+    }
+
+    @Test
+    fun triangleType5() {
+        assertThat(Solution().triangleType(intArrayOf(100, 100, 100)), equalTo("equilateral"))
+    }
+
+    @Test
+    fun triangleType6() {
+        assertThat(Solution().triangleType(intArrayOf(7, 10, 7)), equalTo("isosceles"))
+    }
+
+    @Test
+    fun triangleType7() {
+        assertThat(Solution().triangleType(intArrayOf(0, 4, 4)), equalTo("none"))
+    }
+
+    @Test
+    fun triangleType8() {
+        assertThat(Solution().triangleType(intArrayOf(-3, 4, 5)), equalTo("none"))
+    }
+
+    @Test
+    fun triangleType9() {
+        // 2 + 3 = 5 → equals, not greater → invalid
+        assertThat(Solution().triangleType(intArrayOf(2, 3, 5)), equalTo("none"))
+    }
+
+    @Test
+    fun triangleType10() {
+        assertThat(Solution().triangleType(intArrayOf(5, 3, 4)), equalTo("scalene"))
+    }
+
+    @Test
+    fun triangleType11() {
+        assertThat(Solution().triangleType(intArrayOf(4, 6, 6)), equalTo("isosceles"))
+    }
+
+    @Test
+    fun triangleType12() {
+        assertThat(Solution().triangleType(intArrayOf(0, 0, 0)), equalTo("none"))
+    }
+
+    @Test
+    fun triangleType13() {
+        assertThat(Solution().triangleType(intArrayOf(5, 5, 6)), equalTo("isosceles"))
+    }
+
+    @Test
+    fun triangleType14() {
+        assertThat(Solution().triangleType(intArrayOf(10, 11, 12)), equalTo("scalene"))
+    }
+
+    @Test
+    fun triangleType15() {
+        assertThat(Solution().triangleType(intArrayOf(1, 10, 12)), equalTo("none"))
+    }
 }

src/test/kotlin/g3101_3200/s3132_find_the_integer_added_to_array_ii/SolutionTest.kt

@@ -29,4 +29,47 @@ internal class SolutionTest {
             equalTo(-2),
         )
     }
+
+    @Test
+    fun minimumAddedInteger4() {
+        assertThat(
+            Solution().minimumAddedInteger(intArrayOf(2, 5, 7, 8), intArrayOf(9, 10)),
+            equalTo(2),
+        )
+    }
+
+    @Test
+    fun minimumAddedInteger5() {
+        assertThat(
+            Solution().minimumAddedInteger(intArrayOf(2, 2, 2, 4, 4), intArrayOf(6, 6, 8)),
+            equalTo(4),
+        )
+    }
+
+    @Test
+    fun minimumAddedInteger6() {
+        assertThat(
+            Solution().minimumAddedInteger(intArrayOf(5, 5, 5, 5), intArrayOf(5, 5)),
+            equalTo(0),
+        )
+    }
+
+    @Test
+    fun minimumAddedInteger7() {
+        assertThat(
+            Solution().minimumAddedInteger(
+                intArrayOf(1_000_000, 2_000_000, 3_000_000, 4_000_000),
+                intArrayOf(3_000_002, 4_000_002),
+            ),
+            equalTo(2),
+        )
+    }
+
+    @Test
+    fun minimumAddedInteger8() {
+        assertThat(
+            Solution().minimumAddedInteger(intArrayOf(10, 20, 30, 40), intArrayOf(35, 45)),
+            equalTo(5),
+        )
+    }
 }