Fixed format

Author: javadev

src/main/kotlin/g3701_3800/s3714_longest_balanced_substring_ii/Solution.kt

@@ -38,14 +38,17 @@ class Solution {
             val excludedChar: Char = CHARS[(p + 2) % CHARS.size]
             maxLength = max(
                 maxLength,
-                findBalancedInSegments(s, firstChar, secondChar, excludedChar)
+                findBalancedInSegments(s, firstChar, secondChar, excludedChar),
             )
         }
         return maxLength
     }
 
     private fun findBalancedInSegments(
-        s: String, firstChar: Char, secondChar: Char, excludedChar: Char
+        s: String,
+        firstChar: Char,
+        secondChar: Char,
+        excludedChar: Char,
     ): Int {
         var maxLength = 0
         var index = 0
@@ -63,8 +66,8 @@ class Solution {
                 maxLength = max(
                     maxLength,
                     findBalancedInRange(
-                        s, segmentStart, segmentEnd, firstChar, secondChar
-                    )
+                        s, segmentStart, segmentEnd, firstChar, secondChar,
+                    ),
                 )
             }
         }

src/main/kotlin/g3701_3800/s3715_sum_of_perfect_square_ancestors/Solution.kt

@@ -23,7 +23,11 @@ class Solution {
     }
 
     private fun dfs(
-        node: Int, parent: Int, adj: MutableList<MutableList<Int>>, nums: IntArray, freq: MutableMap<Int, Int>
+        node: Int,
+        parent: Int,
+        adj: MutableList<MutableList<Int>>,
+        nums: IntArray,
+        freq: MutableMap<Int, Int>,
     ): Long {
         // kernel <= nums[node] <= 1e5 fits int
         val key = getKernel(nums[node]).toInt()

src/test/kotlin/g3701_3800/s3708_longest_fibonacci_subarray/SolutionTest.kt

@@ -9,23 +9,23 @@ internal class SolutionTest {
     fun longestSubarray() {
         assertThat<Int>(
             Solution().longestSubarray(intArrayOf(1, 1, 1, 1, 2, 3, 5, 1)),
-            equalTo<Int>(5)
+            equalTo<Int>(5),
         )
     }
 
     @Test
     fun longestSubarray2() {
         assertThat<Int>(
             Solution().longestSubarray(intArrayOf(5, 2, 7, 9, 16)),
-            equalTo<Int>(5)
+            equalTo<Int>(5),
         )
     }
 
     @Test
     fun longestSubarray3() {
         assertThat<Int>(
             Solution().longestSubarray(intArrayOf(1000000000, 1000000000, 1000000000)),
-            equalTo<Int>(2)
+            equalTo<Int>(2),
         )
     }
 }

src/test/kotlin/g3701_3800/s3710_maximum_partition_factor/SolutionTest.kt

@@ -13,18 +13,18 @@ internal class SolutionTest {
                     intArrayOf(0, 0),
                     intArrayOf(0, 2),
                     intArrayOf(2, 0),
-                    intArrayOf(2, 2)
-                )
+                    intArrayOf(2, 2),
+                ),
             ),
-            equalTo<Int>(4)
+            equalTo<Int>(4),
         )
     }
 
     @Test
     fun maxPartitionFactor2() {
         assertThat<Int>(
             Solution().maxPartitionFactor(arrayOf<IntArray>(intArrayOf(0, 0), intArrayOf(0, 1), intArrayOf(10, 0))),
-            equalTo<Int>(11)
+            equalTo<Int>(11),
         )
     }
 }

src/test/kotlin/g3701_3800/s3712_sum_of_elements_with_frequency_divisible_by_k/SolutionTest.kt

@@ -8,23 +8,24 @@ internal class SolutionTest {
     @Test
     fun sumDivisibleByK() {
         assertThat<Int>(
-            Solution().sumDivisibleByK(intArrayOf(1, 2, 2, 3, 3, 3, 3, 4), 2), equalTo<Int>(16)
+            Solution().sumDivisibleByK(intArrayOf(1, 2, 2, 3, 3, 3, 3, 4), 2),
+            equalTo<Int>(16),
         )
     }
 
     @Test
     fun sumDivisibleByK2() {
         assertThat<Int>(
             Solution().sumDivisibleByK(intArrayOf(1, 2, 3, 4, 5), 2),
-            equalTo<Int>(0)
+            equalTo<Int>(0),
         )
     }
 
     @Test
     fun sumDivisibleByK3() {
         assertThat<Int>(
             Solution().sumDivisibleByK(intArrayOf(4, 4, 4, 1, 2, 3), 3),
-            equalTo<Int>(12)
+            equalTo<Int>(12),
         )
     }
 }

src/test/kotlin/g3701_3800/s3715_sum_of_perfect_square_ancestors/SolutionTest.kt

@@ -9,15 +9,15 @@ internal class SolutionTest {
     fun sumOfAncestors() {
         assertThat<Long>(
             Solution().sumOfAncestors(3, arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(1, 2)), intArrayOf(2, 8, 2)),
-            equalTo<Long>(3L)
+            equalTo<Long>(3L),
         )
     }
 
     @Test
     fun sumOfAncestors2() {
         assertThat<Long>(
             Solution().sumOfAncestors(3, arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2)), intArrayOf(1, 2, 4)),
-            equalTo<Long>(1L)
+            equalTo<Long>(1L),
         )
     }
 
@@ -26,9 +26,11 @@ internal class SolutionTest {
         assertThat<Long>(
             Solution()
                 .sumOfAncestors(
-                    4, arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2), intArrayOf(1, 3)), intArrayOf(1, 2, 9, 4)
+                    4,
+                    arrayOf<IntArray>(intArrayOf(0, 1), intArrayOf(0, 2), intArrayOf(1, 3)),
+                    intArrayOf(1, 2, 9, 4),
                 ),
-            equalTo<Long>(2L)
+            equalTo<Long>(2L),
         )
     }
 }