Improved tests

javadev · javadev · commit 55dea6a0caf5 · 2024-11-24T17:10:37.000+02:00
diff --git a/src/main/kotlin/g3301_3400/s3362_zero_array_transformation_iii/Solution.kt b/src/main/kotlin/g3301_3400/s3362_zero_array_transformation_iii/Solution.kt
@@ -17,7 +17,7 @@ class Solution {
                 idx++
             }
             cur += diffs[i]
-            while (cur < nums[i] && !last.isEmpty() && last.peek()!! >= i) {
+            while (cur < nums[i] && last.isNotEmpty() && last.peek()!! >= i) {
                 cur++
                 diffs[last.poll()!! + 1]--
             }
diff --git a/src/main/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.kt b/src/main/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.kt
@@ -9,9 +9,9 @@ class Solution {
     fun maximizeSumOfWeights(edges: Array<IntArray>, k: Int): Long {
         val map = HashMap<Int?, ArrayList<IntArray>?>()
         for (edge in edges) {
-            map.computeIfAbsent(edge[0]) { t: Int? -> ArrayList<IntArray>() }!!
+            map.computeIfAbsent(edge[0]) { _: Int? -> ArrayList<IntArray>() }!!
                 .add(intArrayOf(edge[1], edge[2]))
-            map.computeIfAbsent(edge[1]) { t: Int? -> ArrayList<IntArray>() }!!
+            map.computeIfAbsent(edge[1]) { _: Int? -> ArrayList<IntArray>() }!!
                 .add(intArrayOf(edge[0], edge[2]))
         }
         return maximizeSumOfWeights(0, -1, k, map)[0]
@@ -25,7 +25,7 @@ class Solution {
     ): LongArray {
         var sum: Long = 0
         val queue = PriorityQueue<Long>()
-        for (i in map.get(v)!!) {
+        for (i in map[v]!!) {
             if (i[0] != from) {
                 val next = maximizeSumOfWeights(i[0], v, k, map)
                 next[1] += i[1].toLong()
diff --git a/src/test/kotlin/g3301_3400/s3360_stone_removal_game/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3360_stone_removal_game/SolutionTest.kt
@@ -1,23 +1,22 @@
-package g3301_3400.s3360_stone_removal_game;
+package g3301_3400.s3360_stone_removal_game
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void canAliceWin() {
-        assertThat(new Solution().canAliceWin(12), equalTo(true));
+    fun canAliceWin() {
+        assertThat<Boolean>(Solution().canAliceWin(12), equalTo<Boolean>(true))
     }
 
     @Test
-    void canAliceWin2() {
-        assertThat(new Solution().canAliceWin(1), equalTo(false));
+    fun canAliceWin2() {
+        assertThat<Boolean>(Solution().canAliceWin(1), equalTo<Boolean>(false))
     }
 
     @Test
-    void canAliceWin3() {
-        assertThat(new Solution().canAliceWin(19), equalTo(false));
+    fun canAliceWin3() {
+        assertThat<Boolean>(Solution().canAliceWin(19), equalTo<Boolean>(false))
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3361_shift_distance_between_two_strings/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3361_shift_distance_between_two_strings/SolutionTest.kt
@@ -1,44 +1,47 @@
-package g3301_3400.s3361_shift_distance_between_two_strings;
+package g3301_3400.s3361_shift_distance_between_two_strings
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void shiftDistance() {
-        assertThat(
-                new Solution()
-                        .shiftDistance(
-                                "abab",
-                                "baba",
-                                new int[] {
-                                    100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                    0, 0, 0, 0, 0
-                                },
-                                new int[] {
-                                    1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                    0, 0, 0, 0, 0
-                                }),
-                equalTo(2L));
+    fun shiftDistance() {
+        assertThat<Long>(
+            Solution()
+                .shiftDistance(
+                    "abab",
+                    "baba",
+                    intArrayOf(
+                        100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0,
+                    ),
+                    intArrayOf(
+                        1, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        0, 0, 0, 0, 0,
+                    ),
+                ),
+            equalTo<Long>(2L),
+        )
     }
 
     @Test
-    void shiftDistance2() {
-        assertThat(
-                new Solution()
-                        .shiftDistance(
-                                "leet",
-                                "code",
-                                new int[] {
-                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                    1, 1, 1, 1, 1
-                                },
-                                new int[] {
-                                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                    1, 1, 1, 1, 1
-                                }),
-                equalTo(31L));
+    fun shiftDistance2() {
+        assertThat<Long>(
+            Solution()
+                .shiftDistance(
+                    "leet",
+                    "code",
+                    intArrayOf(
+                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                        1, 1, 1, 1, 1,
+                    ),
+                    intArrayOf(
+                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+                        1, 1, 1, 1, 1,
+                    ),
+                ),
+            equalTo<Long>(31L),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3362_zero_array_transformation_iii/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3362_zero_array_transformation_iii/SolutionTest.kt
@@ -1,33 +1,39 @@
-package g3301_3400.s3362_zero_array_transformation_iii;
+package g3301_3400.s3362_zero_array_transformation_iii
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void maxRemoval() {
-        assertThat(
-                new Solution()
-                        .maxRemoval(new int[] {2, 0, 2}, new int[][] {{0, 2}, {0, 2}, {1, 1}}),
-                equalTo(1));
+    fun maxRemoval() {
+        assertThat<Int>(
+            Solution()
+                .maxRemoval(
+                    intArrayOf(2, 0, 2),
+                    arrayOf<IntArray>(intArrayOf(0, 2), intArrayOf(0, 2), intArrayOf(1, 1)),
+                ),
+            equalTo<Int>(1),
+        )
     }
 
     @Test
-    void maxRemoval2() {
-        assertThat(
-                new Solution()
-                        .maxRemoval(
-                                new int[] {1, 1, 1, 1},
-                                new int[][] {{1, 3}, {0, 2}, {1, 3}, {1, 2}}),
-                equalTo(2));
+    fun maxRemoval2() {
+        assertThat<Int>(
+            Solution()
+                .maxRemoval(
+                    intArrayOf(1, 1, 1, 1),
+                    arrayOf<IntArray>(intArrayOf(1, 3), intArrayOf(0, 2), intArrayOf(1, 3), intArrayOf(1, 2)),
+                ),
+            equalTo<Int>(2),
+        )
     }
 
     @Test
-    void maxRemoval3() {
-        assertThat(
-                new Solution().maxRemoval(new int[] {1, 2, 3, 4}, new int[][] {{0, 3}}),
-                equalTo(-1));
+    fun maxRemoval3() {
+        assertThat<Int>(
+            Solution().maxRemoval(intArrayOf(1, 2, 3, 4), arrayOf<IntArray>(intArrayOf(0, 3))),
+            equalTo<Int>(-1),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/SolutionTest.kt
@@ -1,24 +1,36 @@
-package g3301_3400.s3363_find_the_maximum_number_of_fruits_collected;
+package g3301_3400.s3363_find_the_maximum_number_of_fruits_collected
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void maxCollectedFruits() {
-        assertThat(
-                new Solution()
-                        .maxCollectedFruits(
-                                new int[][] {
-                                    {1, 2, 3, 4}, {5, 6, 8, 7}, {9, 10, 11, 12}, {13, 14, 15, 16}
-                                }),
-                equalTo(100));
+    fun maxCollectedFruits() {
+        assertThat<Int>(
+            Solution()
+                .maxCollectedFruits(
+                    arrayOf<IntArray>(
+                        intArrayOf(1, 2, 3, 4),
+                        intArrayOf(5, 6, 8, 7),
+                        intArrayOf(9, 10, 11, 12),
+                        intArrayOf(13, 14, 15, 16),
+                    ),
+                ),
+            equalTo<Int>(100),
+        )
     }
 
     @Test
-    void maxCollectedFruits2() {
-        assertThat(new Solution().maxCollectedFruits(new int[][] {{1, 1}, {1, 1}}), equalTo(4));
+    fun maxCollectedFruits2() {
+        assertThat<Int>(
+            Solution().maxCollectedFruits(
+                arrayOf<IntArray>(
+                    intArrayOf(1, 1),
+                    intArrayOf(1, 1),
+                ),
+            ),
+            equalTo<Int>(4),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3364_minimum_positive_sum_subarray/SolutionTest.kt
@@ -1,24 +1,31 @@
-package g3301_3400.s3364_minimum_positive_sum_subarray;
+package g3301_3400.s3364_minimum_positive_sum_subarray
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import java.util.List;
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void minimumSumSubarray() {
-        assertThat(new Solution().minimumSumSubarray(List.of(3, -2, 1, 4), 2, 3), equalTo(1));
+    fun minimumSumSubarray() {
+        assertThat<Int>(
+            Solution().minimumSumSubarray(listOf<Int>(3, -2, 1, 4), 2, 3),
+            equalTo<Int>(1),
+        )
     }
 
     @Test
-    void minimumSumSubarray2() {
-        assertThat(new Solution().minimumSumSubarray(List.of(-2, 2, -3, 1), 2, 3), equalTo(-1));
+    fun minimumSumSubarray2() {
+        assertThat<Int>(
+            Solution().minimumSumSubarray(listOf<Int>(-2, 2, -3, 1), 2, 3),
+            equalTo<Int>(-1),
+        )
     }
 
     @Test
-    void minimumSumSubarray3() {
-        assertThat(new Solution().minimumSumSubarray(List.of(1, 2, 3, 4), 2, 4), equalTo(3));
+    fun minimumSumSubarray3() {
+        assertThat<Int>(
+            Solution().minimumSumSubarray(mutableListOf<Int>(1, 2, 3, 4), 2, 4),
+            equalTo<Int>(3),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/SolutionTest.kt
@@ -1,23 +1,34 @@
-package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string;
+package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void isPossibleToRearrange() {
-        assertThat(new Solution().isPossibleToRearrange("abcd", "cdab", 2), equalTo(true));
+    fun isPossibleToRearrange() {
+        assertThat<Boolean>(
+            Solution()
+                .isPossibleToRearrange("abcd", "cdab", 2),
+            equalTo<Boolean>(true),
+        )
     }
 
     @Test
-    void isPossibleToRearrange2() {
-        assertThat(new Solution().isPossibleToRearrange("aabbcc", "bbaacc", 3), equalTo(true));
+    fun isPossibleToRearrange2() {
+        assertThat<Boolean>(
+            Solution()
+                .isPossibleToRearrange("aabbcc", "bbaacc", 3),
+            equalTo<Boolean>(true),
+        )
     }
 
     @Test
-    void isPossibleToRearrange3() {
-        assertThat(new Solution().isPossibleToRearrange("aabbcc", "bbaacc", 2), equalTo(false));
+    fun isPossibleToRearrange3() {
+        assertThat<Boolean>(
+            Solution()
+                .isPossibleToRearrange("aabbcc", "bbaacc", 2),
+            equalTo<Boolean>(false),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3366_minimum_array_sum/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3366_minimum_array_sum/SolutionTest.kt
@@ -1,18 +1,23 @@
-package g3301_3400.s3366_minimum_array_sum;
+package g3301_3400.s3366_minimum_array_sum
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
 
-import org.junit.jupiter.api.Test;
-
-class SolutionTest {
+internal class SolutionTest {
     @Test
-    void minArraySum() {
-        assertThat(new Solution().minArraySum(new int[] {2, 8, 3, 19, 3}, 3, 1, 1), equalTo(23));
+    fun minArraySum() {
+        assertThat<Int>(
+            Solution().minArraySum(intArrayOf(2, 8, 3, 19, 3), 3, 1, 1),
+            equalTo<Int>(23),
+        )
     }
 
     @Test
-    void minArraySum2() {
-        assertThat(new Solution().minArraySum(new int[] {2, 4, 3}, 3, 2, 1), equalTo(3));
+    fun minArraySum2() {
+        assertThat<Int>(
+            Solution().minArraySum(intArrayOf(2, 4, 3), 3, 2, 1),
+            equalTo<Int>(3),
+        )
     }
 }
diff --git a/src/test/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/SolutionTest.kt b/src/test/kotlin/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/SolutionTest.kt

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ class Solution {`
`17`	`17`	`idx++`
`18`	`18`	`}`
`19`	`19`	`cur += diffs[i]`
`20`		`- while (cur < nums[i] && !last.isEmpty() && last.peek()!! >= i) {`
	`20`	`+ while (cur < nums[i] && last.isNotEmpty() && last.peek()!! >= i) {`
`21`	`21`	`cur++`
`22`	`22`	`diffs[last.poll()!! + 1]--`
`23`	`23`	`}`