Fixed style

javadev · javadev · commit 03a6cfead992 · 2025-05-11T18:45:41.000+03:00
diff --git a/src/main/kotlin/g3501_3600/s3544_subtree_inversion_sum/Solution.kt b/src/main/kotlin/g3501_3600/s3544_subtree_inversion_sum/Solution.kt
@@ -52,11 +52,11 @@ class Solution {
         res[0][0] = totalSum[cur]
         res[1][0] = min(
             min(maxCandWithoutInv, maxCandWithInv),
-            min(minCandWithoutInv, minCandWithInv)
+            min(minCandWithoutInv, minCandWithInv),
         )
         res[2][0] = max(
             max(maxCandWithoutInv, maxCandWithInv),
-            max(minCandWithoutInv, minCandWithInv)
+            max(minCandWithoutInv, minCandWithInv),
         )
         return res
     }
diff --git a/src/test/kotlin/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/SolutionTest.kt
@@ -7,19 +7,19 @@ import org.junit.jupiter.api.Test
 internal class SolutionTest {
     @Test
     fun minOperations() {
-        MatcherAssert.assertThat<Int?>(Solution().minOperations(intArrayOf(0, 2)), CoreMatchers.equalTo<Int?>(1))
+        MatcherAssert.assertThat<Int>(Solution().minOperations(intArrayOf(0, 2)), CoreMatchers.equalTo<Int>(1))
     }
 
     @Test
     fun minOperations2() {
-        MatcherAssert.assertThat<Int?>(Solution().minOperations(intArrayOf(3, 1, 2, 1)), CoreMatchers.equalTo<Int?>(3))
+        MatcherAssert.assertThat<Int>(Solution().minOperations(intArrayOf(3, 1, 2, 1)), CoreMatchers.equalTo<Int>(3))
     }
 
     @Test
     fun minOperations3() {
-        MatcherAssert.assertThat<Int?>(
+        MatcherAssert.assertThat<Int>(
             Solution().minOperations(intArrayOf(1, 2, 1, 2, 1, 2)),
-            CoreMatchers.equalTo<Int?>(4)
+            CoreMatchers.equalTo<Int>(4),
         )
     }
 }
diff --git a/src/test/kotlin/g3501_3600/s3543_maximum_weighted_k_edge_path/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3543_maximum_weighted_k_edge_path/SolutionTest.kt
@@ -9,31 +9,31 @@ internal class SolutionTest {
     fun maxWeight() {
         assertThat<Int>(
             Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 1), intArrayOf(1, 2, 2)), 2, 4),
-            equalTo<Int>(3)
+            equalTo<Int>(3),
         )
     }
 
     @Test
     fun maxWeight2() {
         assertThat<Int>(
             Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 2), intArrayOf(0, 2, 3)), 1, 3),
-            equalTo<Int>(2)
+            equalTo<Int>(2),
         )
     }
 
     @Test
     fun maxWeight3() {
         assertThat<Int>(
             Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 6), intArrayOf(1, 2, 8)), 1, 6),
-            equalTo<Int>(-1)
+            equalTo<Int>(-1),
         )
     }
 
     @Test
     fun maxWeight4() {
         assertThat<Int>(
             Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 6), intArrayOf(1, 2, 8)), 0, 6),
-            equalTo<Int>(0)
+            equalTo<Int>(0),
         )
     }
 }
diff --git a/src/test/kotlin/g3501_3600/s3544_subtree_inversion_sum/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3544_subtree_inversion_sum/SolutionTest.kt
@@ -16,12 +16,12 @@ internal class SolutionTest {
                         intArrayOf(1, 3),
                         intArrayOf(1, 4),
                         intArrayOf(2, 5),
-                        intArrayOf(2, 6)
+                        intArrayOf(2, 6),
                     ),
                     intArrayOf(4, -8, -6, 3, 7, -2, 5),
-                    2
+                    2,
                 ),
-            equalTo<Long>(27L)
+            equalTo<Long>(27L),
         )
     }
 
@@ -32,9 +32,9 @@ internal class SolutionTest {
                 .subtreeInversionSum(
                     arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4)),
                     intArrayOf(-1, 3, -2, 4, -5),
-                    2
+                    2,
                 ),
-            equalTo<Long>(9L)
+            equalTo<Long>(9L),
         )
     }
 
@@ -43,9 +43,11 @@ internal class SolutionTest {
         assertThat<Long>(
             Solution()
                 .subtreeInversionSum(
-                    arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2)), intArrayOf(0, -1, -2), 3
+                    arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2)),
+                    intArrayOf(0, -1, -2),
+                    3,
                 ),
-            equalTo<Long>(3L)
+            equalTo<Long>(3L),
         )
     }
 }
diff --git a/src/test/kotlin/g3501_3600/s3546_equal_sum_grid_partition_i/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3546_equal_sum_grid_partition_i/SolutionTest.kt
@@ -11,9 +11,10 @@ internal class SolutionTest {
             Solution().canPartitionGrid(
                 arrayOf<IntArray>(
                     intArrayOf(1, 4),
-                    intArrayOf(2, 3)
-                )
-            ), equalTo<Boolean>(true)
+                    intArrayOf(2, 3),
+                ),
+            ),
+            equalTo<Boolean>(true),
         )
     }
 
@@ -23,17 +24,18 @@ internal class SolutionTest {
             Solution().canPartitionGrid(
                 arrayOf<IntArray>(
                     intArrayOf(1, 3),
-                    intArrayOf(2, 4)
-                )
-            ), equalTo<Boolean>(false)
+                    intArrayOf(2, 4),
+                ),
+            ),
+            equalTo<Boolean>(false),
         )
     }
 
     @Test
     fun canPartitionGrid3() {
         assertThat<Boolean>(
             Solution().canPartitionGrid(arrayOf<IntArray>(intArrayOf(1))),
-            equalTo<Boolean>(false)
+            equalTo<Boolean>(false),
         )
     }
 }
diff --git a/src/test/kotlin/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph/SolutionTest.kt
@@ -17,10 +17,10 @@ internal class SolutionTest {
                         intArrayOf(2, 0),
                         intArrayOf(3, 4),
                         intArrayOf(4, 5),
-                        intArrayOf(5, 6)
-                    )
+                        intArrayOf(5, 6),
+                    ),
                 ),
-            equalTo<Long>(130L)
+            equalTo<Long>(130L),
         )
     }
 
@@ -36,10 +36,10 @@ internal class SolutionTest {
                         intArrayOf(2, 0),
                         intArrayOf(1, 3),
                         intArrayOf(2, 4),
-                        intArrayOf(1, 5)
-                    )
+                        intArrayOf(1, 5),
+                    ),
                 ),
-            equalTo<Long>(82L)
+            equalTo<Long>(82L),
         )
     }
 }
diff --git a/src/test/kotlin/g3501_3600/s3548_equal_sum_grid_partition_ii/SolutionTest.kt b/src/test/kotlin/g3501_3600/s3548_equal_sum_grid_partition_ii/SolutionTest.kt
@@ -11,9 +11,10 @@ internal class SolutionTest {
             Solution().canPartitionGrid(
                 arrayOf<IntArray>(
                     intArrayOf(1, 4),
-                    intArrayOf(2, 3)
-                )
-            ), equalTo<Boolean>(true)
+                    intArrayOf(2, 3),
+                ),
+            ),
+            equalTo<Boolean>(true),
         )
     }
 
@@ -23,33 +24,34 @@ internal class SolutionTest {
             Solution().canPartitionGrid(
                 arrayOf<IntArray>(
                     intArrayOf(1, 2),
-                    intArrayOf(3, 4)
-                )
-            ), equalTo<Boolean>(true)
+                    intArrayOf(3, 4),
+                ),
+            ),
+            equalTo<Boolean>(true),
         )
     }
 
     @Test
     fun canPartitionGrid3() {
         assertThat<Boolean>(
             Solution().canPartitionGrid(arrayOf<IntArray>(intArrayOf(1, 2, 4), intArrayOf(2, 3, 5))),
-            equalTo<Boolean>(false)
+            equalTo<Boolean>(false),
         )
     }
 
     @Test
     fun canPartitionGrid4() {
         assertThat<Boolean>(
             Solution().canPartitionGrid(arrayOf<IntArray>(intArrayOf(4, 1, 8), intArrayOf(3, 2, 6))),
-            equalTo<Boolean>(false)
+            equalTo<Boolean>(false),
         )
     }
 
     @Test
     fun canPartitionGrid5() {
         assertThat<Boolean>(
             Solution().canPartitionGrid(arrayOf<IntArray>(intArrayOf(1))),
-            equalTo<Boolean>(false)
+            equalTo<Boolean>(false),
         )
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,11 +52,11 @@ class Solution {`
`52`	`52`	`res[0][0] = totalSum[cur]`
`53`	`53`	`res[1][0] = min(`
`54`	`54`	`min(maxCandWithoutInv, maxCandWithInv),`
`55`		`- min(minCandWithoutInv, minCandWithInv)`
	`55`	`+ min(minCandWithoutInv, minCandWithInv),`
`56`	`56`	`)`
`57`	`57`	`res[2][0] = max(`
`58`	`58`	`max(maxCandWithoutInv, maxCandWithInv),`
`59`		`- max(minCandWithoutInv, minCandWithInv)`
	`59`	`+ max(minCandWithoutInv, minCandWithInv),`
`60`	`60`	`)`
`61`	`61`	`return res`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,19 +7,19 @@ import org.junit.jupiter.api.Test`
`7`	`7`	`internal class SolutionTest {`
`8`	`8`	`@Test`
`9`	`9`	`fun minOperations() {`
`10`		`- MatcherAssert.assertThat<Int?>(Solution().minOperations(intArrayOf(0, 2)), CoreMatchers.equalTo<Int?>(1))`
	`10`	`+ MatcherAssert.assertThat<Int>(Solution().minOperations(intArrayOf(0, 2)), CoreMatchers.equalTo<Int>(1))`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`@Test`
`14`	`14`	`fun minOperations2() {`
`15`		`- MatcherAssert.assertThat<Int?>(Solution().minOperations(intArrayOf(3, 1, 2, 1)), CoreMatchers.equalTo<Int?>(3))`
	`15`	`+ MatcherAssert.assertThat<Int>(Solution().minOperations(intArrayOf(3, 1, 2, 1)), CoreMatchers.equalTo<Int>(3))`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`@Test`
`19`	`19`	`fun minOperations3() {`
`20`		`- MatcherAssert.assertThat<Int?>(`
	`20`	`+ MatcherAssert.assertThat<Int>(`
`21`	`21`	`Solution().minOperations(intArrayOf(1, 2, 1, 2, 1, 2)),`
`22`		`- CoreMatchers.equalTo<Int?>(4)`
	`22`	`+ CoreMatchers.equalTo<Int>(4),`
`23`	`23`	`)`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,31 +9,31 @@ internal class SolutionTest {`
`9`	`9`	`fun maxWeight() {`
`10`	`10`	`assertThat<Int>(`
`11`	`11`	`Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 1), intArrayOf(1, 2, 2)), 2, 4),`
`12`		`- equalTo<Int>(3)`
	`12`	`+ equalTo<Int>(3),`
`13`	`13`	`)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`@Test`
`17`	`17`	`fun maxWeight2() {`
`18`	`18`	`assertThat<Int>(`
`19`	`19`	`Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 2), intArrayOf(0, 2, 3)), 1, 3),`
`20`		`- equalTo<Int>(2)`
	`20`	`+ equalTo<Int>(2),`
`21`	`21`	`)`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`@Test`
`25`	`25`	`fun maxWeight3() {`
`26`	`26`	`assertThat<Int>(`
`27`	`27`	`Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 6), intArrayOf(1, 2, 8)), 1, 6),`
`28`		`- equalTo<Int>(-1)`
	`28`	`+ equalTo<Int>(-1),`
`29`	`29`	`)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`@Test`
`33`	`33`	`fun maxWeight4() {`
`34`	`34`	`assertThat<Int>(`
`35`	`35`	`Solution().maxWeight(3, arrayOf<IntArray>(intArrayOf(0, 1, 6), intArrayOf(1, 2, 8)), 0, 6),`
`36`		`- equalTo<Int>(0)`
	`36`	`+ equalTo<Int>(0),`
`37`	`37`	`)`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,12 @@ internal class SolutionTest {`
`16`	`16`	`intArrayOf(1, 3),`
`17`	`17`	`intArrayOf(1, 4),`
`18`	`18`	`intArrayOf(2, 5),`
`19`		`- intArrayOf(2, 6)`
	`19`	`+ intArrayOf(2, 6),`
`20`	`20`	`),`
`21`	`21`	`intArrayOf(4, -8, -6, 3, 7, -2, 5),`
`22`		`- 2`
	`22`	`+ 2,`
`23`	`23`	`),`
`24`		`- equalTo<Long>(27L)`
	`24`	`+ equalTo<Long>(27L),`
`25`	`25`	`)`
`26`	`26`	`}`
`27`	`27`
`@@ -32,9 +32,9 @@ internal class SolutionTest {`
`32`	`32`	`.subtreeInversionSum(`
`33`	`33`	`arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4)),`
`34`	`34`	`intArrayOf(-1, 3, -2, 4, -5),`
`35`		`- 2`
	`35`	`+ 2,`
`36`	`36`	`),`
`37`		`- equalTo<Long>(9L)`
	`37`	`+ equalTo<Long>(9L),`
`38`	`38`	`)`
`39`	`39`	`}`
`40`	`40`
`@@ -43,9 +43,11 @@ internal class SolutionTest {`
`43`	`43`	`assertThat<Long>(`
`44`	`44`	`Solution()`
`45`	`45`	`.subtreeInversionSum(`
`46`		`- arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2)), intArrayOf(0, -1, -2), 3`
	`46`	`+ arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2)),`
	`47`	`+ intArrayOf(0, -1, -2),`
	`48`	`+ 3,`
`47`	`49`	`),`
`48`		`- equalTo<Long>(3L)`
	`50`	`+ equalTo<Long>(3L),`
`49`	`51`	`)`
`50`	`52`	`}`
`51`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,10 @@ internal class SolutionTest {`
`11`	`11`	`Solution().canPartitionGrid(`
`12`	`12`	`arrayOf<IntArray>(`
`13`	`13`	`intArrayOf(1, 4),`
`14`		`- intArrayOf(2, 3)`
`15`		`- )`
`16`		`- ), equalTo<Boolean>(true)`
	`14`	`+ intArrayOf(2, 3),`
	`15`	`+ ),`
	`16`	`+ ),`
	`17`	`+ equalTo<Boolean>(true),`
`17`	`18`	`)`
`18`	`19`	`}`
`19`	`20`
`@@ -23,17 +24,18 @@ internal class SolutionTest {`
`23`	`24`	`Solution().canPartitionGrid(`
`24`	`25`	`arrayOf<IntArray>(`
`25`	`26`	`intArrayOf(1, 3),`
`26`		`- intArrayOf(2, 4)`
`27`		`- )`
`28`		`- ), equalTo<Boolean>(false)`
	`27`	`+ intArrayOf(2, 4),`
	`28`	`+ ),`
	`29`	`+ ),`
	`30`	`+ equalTo<Boolean>(false),`
`29`	`31`	`)`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`@Test`
`33`	`35`	`fun canPartitionGrid3() {`
`34`	`36`	`assertThat<Boolean>(`
`35`	`37`	`Solution().canPartitionGrid(arrayOf<IntArray>(intArrayOf(1))),`
`36`		`- equalTo<Boolean>(false)`
	`38`	`+ equalTo<Boolean>(false),`
`37`	`39`	`)`
`38`	`40`	`}`
`39`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,10 @@ internal class SolutionTest {`
`17`	`17`	`intArrayOf(2, 0),`
`18`	`18`	`intArrayOf(3, 4),`
`19`	`19`	`intArrayOf(4, 5),`
`20`		`- intArrayOf(5, 6)`
`21`		`- )`
	`20`	`+ intArrayOf(5, 6),`
	`21`	`+ ),`
`22`	`22`	`),`
`23`		`- equalTo<Long>(130L)`
	`23`	`+ equalTo<Long>(130L),`
`24`	`24`	`)`
`25`	`25`	`}`
`26`	`26`
`@@ -36,10 +36,10 @@ internal class SolutionTest {`
`36`	`36`	`intArrayOf(2, 0),`
`37`	`37`	`intArrayOf(1, 3),`
`38`	`38`	`intArrayOf(2, 4),`
`39`		`- intArrayOf(1, 5)`
`40`		`- )`
	`39`	`+ intArrayOf(1, 5),`
	`40`	`+ ),`
`41`	`41`	`),`
`42`		`- equalTo<Long>(82L)`
	`42`	`+ equalTo<Long>(82L),`
`43`	`43`	`)`
`44`	`44`	`}`
`45`	`45`	`}`