From 010b65841a6d5fe244cdd6a0c570924f3241b45d Mon Sep 17 00:00:00 2001 From: ThanhNIT Date: Sat, 29 Nov 2025 10:05:22 +0700 Subject: [PATCH] Added tests for tasks 335-3132 --- .../s0335_self_crossing/SolutionTest.kt | 55 ++++++++++++++ .../MyCircularDequeTest.kt | 71 +++++++++++++++++++ .../SolutionTest.kt | 40 +++++++++++ .../s3024_type_of_triangle/SolutionTest.kt | 66 +++++++++++++++++ .../SolutionTest.kt | 43 +++++++++++ 5 files changed, 275 insertions(+) diff --git a/src/test/kotlin/g0301_0400/s0335_self_crossing/SolutionTest.kt b/src/test/kotlin/g0301_0400/s0335_self_crossing/SolutionTest.kt index d4911b9fb..30017c0d5 100644 --- a/src/test/kotlin/g0301_0400/s0335_self_crossing/SolutionTest.kt +++ b/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)) } } diff --git a/src/test/kotlin/g0601_0700/s0641_design_circular_deque/MyCircularDequeTest.kt b/src/test/kotlin/g0601_0700/s0641_design_circular_deque/MyCircularDequeTest.kt index beae0138d..f63d90cc1 100644 --- a/src/test/kotlin/g0601_0700/s0641_design_circular_deque/MyCircularDequeTest.kt +++ b/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)) + } } diff --git a/src/test/kotlin/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/SolutionTest.kt b/src/test/kotlin/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/SolutionTest.kt index ae5e79fa7..40e8a436e 100644 --- a/src/test/kotlin/g2801_2900/s2839_check_if_strings_can_be_made_equal_with_operations_i/SolutionTest.kt +++ b/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)) + } } diff --git a/src/test/kotlin/g3001_3100/s3024_type_of_triangle/SolutionTest.kt b/src/test/kotlin/g3001_3100/s3024_type_of_triangle/SolutionTest.kt index 990dd59ac..abfad10d7 100644 --- a/src/test/kotlin/g3001_3100/s3024_type_of_triangle/SolutionTest.kt +++ b/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")) + } } diff --git a/src/test/kotlin/g3101_3200/s3132_find_the_integer_added_to_array_ii/SolutionTest.kt b/src/test/kotlin/g3101_3200/s3132_find_the_integer_added_to_array_ii/SolutionTest.kt index 9ad07f0dd..013f9d7ff 100644 --- a/src/test/kotlin/g3101_3200/s3132_find_the_integer_added_to_array_ii/SolutionTest.kt +++ b/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), + ) + } }