Fixed format

javadev · javadev · commit c86a441ea833 · 2025-03-02T08:24:59.000+02:00
diff --git a/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt b/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt
@@ -24,11 +24,11 @@ class Solution {
         var res: Int = max(nums[i], nums[i + 1]) + solve(nums, i + 2, last)
         res = min(
             res,
-            max(nums[i], nums[last]) + solve(nums, i + 2, i + 1)
+            max(nums[i], nums[last]) + solve(nums, i + 2, i + 1),
         )
         res = min(
             res,
-            max(nums[i + 1], nums[last]) + solve(nums, i + 2, i)
+            max(nums[i + 1], nums[last]) + solve(nums, i + 2, i),
         )
         dp[i][last] = res
         return res
diff --git a/src/test/kotlin/g3401_3500/s3467_transform_array_by_parity/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3467_transform_array_by_parity/SolutionTest.kt
@@ -9,15 +9,15 @@ internal class SolutionTest {
     fun transformArray() {
         assertThat<IntArray>(
             Solution().transformArray(intArrayOf(4, 3, 2, 1)),
-            equalTo<IntArray>(intArrayOf(0, 0, 1, 1))
+            equalTo<IntArray>(intArrayOf(0, 0, 1, 1)),
         )
     }
 
     @Test
     fun transformArray2() {
         assertThat<IntArray>(
             Solution().transformArray(intArrayOf(1, 5, 1, 4, 2)),
-            equalTo<IntArray>(intArrayOf(0, 0, 1, 1, 1))
+            equalTo<IntArray>(intArrayOf(0, 0, 1, 1, 1)),
         )
     }
 }
diff --git a/src/test/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/SolutionTest.kt
@@ -11,9 +11,9 @@ internal class SolutionTest {
             Solution()
                 .countArrays(
                     intArrayOf(1, 2, 3, 4),
-                    arrayOf<IntArray>(intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4), intArrayOf(4, 5))
+                    arrayOf<IntArray>(intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4), intArrayOf(4, 5)),
                 ),
-            equalTo<Int>(2)
+            equalTo<Int>(2),
         )
     }
 
@@ -23,9 +23,9 @@ internal class SolutionTest {
             Solution()
                 .countArrays(
                     intArrayOf(1, 2, 3, 4),
-                    arrayOf<IntArray>(intArrayOf(1, 10), intArrayOf(2, 9), intArrayOf(3, 8), intArrayOf(4, 7))
+                    arrayOf<IntArray>(intArrayOf(1, 10), intArrayOf(2, 9), intArrayOf(3, 8), intArrayOf(4, 7)),
                 ),
-            equalTo<Int>(4)
+            equalTo<Int>(4),
         )
     }
 
@@ -35,9 +35,9 @@ internal class SolutionTest {
             Solution()
                 .countArrays(
                     intArrayOf(1, 2, 1, 2),
-                    arrayOf<IntArray>(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 3), intArrayOf(2, 3))
+                    arrayOf<IntArray>(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 3), intArrayOf(2, 3)),
                 ),
-            equalTo<Int>(0)
+            equalTo<Int>(0),
         )
     }
 }
diff --git a/src/test/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/SolutionTest.kt
@@ -19,7 +19,7 @@ internal class SolutionTest {
     fun minCost3() {
         assertThat<Int>(
             Solution().minCost(intArrayOf(83, 47, 66, 24, 57, 85, 16)),
-            equalTo<Int>(224)
+            equalTo<Int>(224),
         )
     }
 }
diff --git a/src/test/kotlin/g3401_3500/s3470_permutations_iv/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3470_permutations_iv/SolutionTest.kt
@@ -9,15 +9,15 @@ internal class SolutionTest {
     fun permute() {
         MatcherAssert.assertThat<IntArray?>(
             Solution().permute(4, 6L),
-            CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 4, 1, 2))
+            CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 4, 1, 2)),
         )
     }
 
     @Test
     fun permute2() {
         MatcherAssert.assertThat<IntArray?>(
             Solution().permute(3, 2L),
-            CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 2, 1))
+            CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 2, 1)),
         )
     }
 
@@ -34,9 +34,9 @@ internal class SolutionTest {
                 intArrayOf(
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                     21, 22, 43, 40, 27, 36, 25, 34, 31, 32, 29, 28, 33, 24, 23, 26, 41, 42,
-                    35, 38, 37, 30, 39
-                )
-            )
+                    35, 38, 37, 30, 39,
+                ),
+            ),
         )
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@ class Solution {`
`24`	`24`	`var res: Int = max(nums[i], nums[i + 1]) + solve(nums, i + 2, last)`
`25`	`25`	`res = min(`
`26`	`26`	`res,`
`27`		`- max(nums[i], nums[last]) + solve(nums, i + 2, i + 1)`
	`27`	`+ max(nums[i], nums[last]) + solve(nums, i + 2, i + 1),`
`28`	`28`	`)`
`29`	`29`	`res = min(`
`30`	`30`	`res,`
`31`		`- max(nums[i + 1], nums[last]) + solve(nums, i + 2, i)`
	`31`	`+ max(nums[i + 1], nums[last]) + solve(nums, i + 2, i),`
`32`	`32`	`)`
`33`	`33`	`dp[i][last] = res`
`34`	`34`	`return res`
Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,15 @@ internal class SolutionTest {`
`9`	`9`	`fun transformArray() {`
`10`	`10`	`assertThat<IntArray>(`
`11`	`11`	`Solution().transformArray(intArrayOf(4, 3, 2, 1)),`
`12`		`- equalTo<IntArray>(intArrayOf(0, 0, 1, 1))`
	`12`	`+ equalTo<IntArray>(intArrayOf(0, 0, 1, 1)),`
`13`	`13`	`)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`@Test`
`17`	`17`	`fun transformArray2() {`
`18`	`18`	`assertThat<IntArray>(`
`19`	`19`	`Solution().transformArray(intArrayOf(1, 5, 1, 4, 2)),`
`20`		`- equalTo<IntArray>(intArrayOf(0, 0, 1, 1, 1))`
	`20`	`+ equalTo<IntArray>(intArrayOf(0, 0, 1, 1, 1)),`
`21`	`21`	`)`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,9 @@ internal class SolutionTest {`
`11`	`11`	`Solution()`
`12`	`12`	`.countArrays(`
`13`	`13`	`intArrayOf(1, 2, 3, 4),`
`14`		`- arrayOf<IntArray>(intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4), intArrayOf(4, 5))`
	`14`	`+ arrayOf<IntArray>(intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4), intArrayOf(4, 5)),`
`15`	`15`	`),`
`16`		`- equalTo<Int>(2)`
	`16`	`+ equalTo<Int>(2),`
`17`	`17`	`)`
`18`	`18`	`}`
`19`	`19`
`@@ -23,9 +23,9 @@ internal class SolutionTest {`
`23`	`23`	`Solution()`
`24`	`24`	`.countArrays(`
`25`	`25`	`intArrayOf(1, 2, 3, 4),`
`26`		`- arrayOf<IntArray>(intArrayOf(1, 10), intArrayOf(2, 9), intArrayOf(3, 8), intArrayOf(4, 7))`
	`26`	`+ arrayOf<IntArray>(intArrayOf(1, 10), intArrayOf(2, 9), intArrayOf(3, 8), intArrayOf(4, 7)),`
`27`	`27`	`),`
`28`		`- equalTo<Int>(4)`
	`28`	`+ equalTo<Int>(4),`
`29`	`29`	`)`
`30`	`30`	`}`
`31`	`31`
`@@ -35,9 +35,9 @@ internal class SolutionTest {`
`35`	`35`	`Solution()`
`36`	`36`	`.countArrays(`
`37`	`37`	`intArrayOf(1, 2, 1, 2),`
`38`		`- arrayOf<IntArray>(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 3), intArrayOf(2, 3))`
	`38`	`+ arrayOf<IntArray>(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 3), intArrayOf(2, 3)),`
`39`	`39`	`),`
`40`		`- equalTo<Int>(0)`
	`40`	`+ equalTo<Int>(0),`
`41`	`41`	`)`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ internal class SolutionTest {`
`19`	`19`	`fun minCost3() {`
`20`	`20`	`assertThat<Int>(`
`21`	`21`	`Solution().minCost(intArrayOf(83, 47, 66, 24, 57, 85, 16)),`
`22`		`- equalTo<Int>(224)`
	`22`	`+ equalTo<Int>(224),`
`23`	`23`	`)`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,15 +9,15 @@ internal class SolutionTest {`
`9`	`9`	`fun permute() {`
`10`	`10`	`MatcherAssert.assertThat<IntArray?>(`
`11`	`11`	`Solution().permute(4, 6L),`
`12`		`- CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 4, 1, 2))`
	`12`	`+ CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 4, 1, 2)),`
`13`	`13`	`)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`@Test`
`17`	`17`	`fun permute2() {`
`18`	`18`	`MatcherAssert.assertThat<IntArray?>(`
`19`	`19`	`Solution().permute(3, 2L),`
`20`		`- CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 2, 1))`
	`20`	`+ CoreMatchers.equalTo<IntArray?>(intArrayOf(3, 2, 1)),`
`21`	`21`	`)`
`22`	`22`	`}`
`23`	`23`
`@@ -34,9 +34,9 @@ internal class SolutionTest {`
`34`	`34`	`intArrayOf(`
`35`	`35`	`1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,`
`36`	`36`	`21, 22, 43, 40, 27, 36, 25, 34, 31, 32, 29, 28, 33, 24, 23, 26, 41, 42,`
`37`		`- 35, 38, 37, 30, 39`
`38`		`- )`
`39`		`- )`
	`37`	`+ 35, 38, 37, 30, 39,`
	`38`	`+ ),`
	`39`	`+ ),`
`40`	`40`	`)`
`41`	`41`	`}`
`42`	`42`	`}`