Fixed format

Author: javadev

src/main/kotlin/g3601_3700/s3680_generate_schedule/Solution.kt

@@ -5,9 +5,9 @@ package g3601_3700.s3680_generate_schedule
 class Solution {
     fun generateSchedule(n: Int): Array<IntArray> {
         if (n < 5) {
-            return Array<IntArray>(0) { IntArray(0)}
+            return Array<IntArray>(0) { IntArray(0) }
         }
-        val res = Array<IntArray>(n * (n - 1)) { IntArray(2)}
+        val res = Array<IntArray>(n * (n - 1)) { IntArray(2) }
         var idx = 0
         for (i in 2..<n - 1) {
             for (j in 0..<n) {

src/test/kotlin/g3601_3700/s3679_minimum_discards_to_balance_inventory/SolutionTest.kt

@@ -8,15 +8,16 @@ internal class SolutionTest {
     @Test
     fun minArrivalsToDiscard() {
         assertThat<Int>(
-            Solution().minArrivalsToDiscard(intArrayOf(1, 2, 1, 3, 1), 4, 2), equalTo<Int>(0)
+            Solution().minArrivalsToDiscard(intArrayOf(1, 2, 1, 3, 1), 4, 2),
+            equalTo<Int>(0),
         )
     }
 
     @Test
     fun minArrivalsToDiscard2() {
         assertThat<Int>(
             Solution().minArrivalsToDiscard(intArrayOf(1, 2, 3, 3, 3, 4), 3, 2),
-            equalTo<Int>(1)
+            equalTo<Int>(1),
         )
     }
 }

src/test/kotlin/g3601_3700/s3680_generate_schedule/SolutionTest.kt

@@ -35,9 +35,9 @@ internal class SolutionTest {
                     intArrayOf(3, 4),
                     intArrayOf(2, 1),
                     intArrayOf(4, 0),
-                    intArrayOf(3, 2)
-                )
-            )
+                    intArrayOf(3, 2),
+                ),
+            ),
         )
     }
 }

src/test/kotlin/g3601_3700/s3681_maximum_xor_of_subsequences/SolutionTest.kt

@@ -9,7 +9,7 @@ internal class SolutionTest {
     fun maxXorSubsequences() {
         assertThat<Int>(
             Solution().maxXorSubsequences(intArrayOf(1, 2, 3)),
-            equalTo<Int>(3)
+            equalTo<Int>(3),
         )
     }
 

src/test/kotlin/g3601_3700/s3683_earliest_time_to_finish_one_task/SolutionTest.kt

@@ -9,7 +9,7 @@ internal class SolutionTest {
     fun earliestTime() {
         assertThat<Int>(
             Solution().earliestTime(arrayOf<IntArray>(intArrayOf(1, 6), intArrayOf(2, 3))),
-            equalTo<Int>(5)
+            equalTo<Int>(5),
         )
     }
 
@@ -20,18 +20,18 @@ internal class SolutionTest {
                 arrayOf<IntArray>(
                     intArrayOf(100, 100),
                     intArrayOf(100, 100),
-                    intArrayOf(100, 100)
-                )
+                    intArrayOf(100, 100),
+                ),
             ),
-            equalTo<Int>(200)
+            equalTo<Int>(200),
         )
     }
 
     @Test
     fun earliestTime3() {
         assertThat<Int>(
             Solution().earliestTime(arrayOf<IntArray>(intArrayOf(1, 6))),
-            equalTo<Int>(7)
+            equalTo<Int>(7),
         )
     }
 }

src/test/kotlin/g3601_3700/s3684_maximize_sum_of_at_most_k_distinct_elements/SolutionTest.kt

@@ -9,23 +9,23 @@ internal class SolutionTest {
     fun maxKDistinct() {
         assertThat<IntArray>(
             Solution().maxKDistinct(intArrayOf(84, 93, 100, 77, 90), 3),
-            equalTo<IntArray>(intArrayOf(100, 93, 90))
+            equalTo<IntArray>(intArrayOf(100, 93, 90)),
         )
     }
 
     @Test
     fun maxKDistinct2() {
         assertThat<IntArray>(
             Solution().maxKDistinct(intArrayOf(84, 93, 100, 77, 93), 3),
-            equalTo<IntArray>(intArrayOf(100, 93, 84))
+            equalTo<IntArray>(intArrayOf(100, 93, 84)),
         )
     }
 
     @Test
     fun maxKDistinct3() {
         assertThat<IntArray>(
             Solution().maxKDistinct(intArrayOf(1, 1, 1, 2, 2, 2), 6),
-            equalTo<IntArray>(intArrayOf(2, 1))
+            equalTo<IntArray>(intArrayOf(2, 1)),
         )
     }
 }

src/test/kotlin/g3601_3700/s3685_subsequence_sum_after_capping_elements/SolutionTest.kt

@@ -9,15 +9,15 @@ internal class SolutionTest {
     fun subsequenceSumAfterCapping() {
         assertThat<BooleanArray>(
             Solution().subsequenceSumAfterCapping(intArrayOf(4, 3, 2, 4), 5),
-            equalTo<BooleanArray>(booleanArrayOf(false, false, true, true))
+            equalTo<BooleanArray>(booleanArrayOf(false, false, true, true)),
         )
     }
 
     @Test
     fun subsequenceSumAfterCapping2() {
         assertThat<BooleanArray>(
             Solution().subsequenceSumAfterCapping(intArrayOf(1, 2, 3, 4, 5), 3),
-            equalTo<BooleanArray>(booleanArrayOf(true, true, true, true, true))
+            equalTo<BooleanArray>(booleanArrayOf(true, true, true, true, true)),
         )
     }
 }

src/test/kotlin/g3601_3700/s3686_number_of_stable_subsequences/SolutionTest.kt

@@ -9,15 +9,15 @@ internal class SolutionTest {
     fun countStableSubsequences() {
         assertThat<Int>(
             Solution().countStableSubsequences(intArrayOf(1, 3, 5)),
-            equalTo<Int>(6)
+            equalTo<Int>(6),
         )
     }
 
     @Test
     fun countStableSubsequences2() {
         assertThat<Int>(
             Solution().countStableSubsequences(intArrayOf(2, 3, 4, 2)),
-            equalTo<Int>(14)
+            equalTo<Int>(14),
         )
     }
 }