Updated spotless

Author: javadev

build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
     kotlin("jvm") version "2.0.21"
     jacoco
     id("org.sonarqube") version "5.1.0.4882"
-    id("com.diffplug.spotless") version "6.12.0"
+    id("com.diffplug.spotless") version "6.21.0"
     `maven-publish`
 }
 
@@ -52,9 +52,14 @@ spotless {
     kotlin {
         encoding("UTF-8")
         target("**/src/**/*.kt")
-        ktlint("0.43.0").userData(mapOf(
-                "max_line_length" to "120"
-                ))
+        ktlint("0.50.0").editorConfigOverride(
+            mapOf(
+                "max_line_length" to "120",
+                "indent_size" to "4",
+                "ktlint_standard_package-name" to "disabled",
+                "ktlint_standard_comment-wrapping" to "disabled"
+            )
+        )
         toggleOffOn()
         trimTrailingWhitespace()
         endWithNewline()

pom-central.xml

@@ -109,7 +109,7 @@
             <plugin>
                 <groupId>org.jetbrains.dokka</groupId>
                 <artifactId>dokka-maven-plugin</artifactId>
-                <version>1.9.20</version>
+                <version>2.0.0-Beta</version>
                 <executions>
                     <execution>
                         <phase>prepare-package</phase>

src/main/kotlin/com_github_leetcode/Employee.kt

@@ -6,5 +6,5 @@ class Employee(
     /** the importance value of this employee  */
     var importance: Int,
     /** the id of direct subordinates  */
-    var subordinates: List<Int> = listOf()
+    var subordinates: List<Int> = listOf(),
 )

src/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/Solution.kt

@@ -19,10 +19,14 @@ class Solution {
         var lpsCenter = 0
         var lpsRadius = 0
         for (i in newStr.indices) {
-            dp[i] = if (friendCenter + friendRadius > i) Math.min(
-                dp[friendCenter * 2 - i],
-                friendCenter + friendRadius - i
-            ) else 1
+            dp[i] = if (friendCenter + friendRadius > i) {
+                Math.min(
+                    dp[friendCenter * 2 - i],
+                    friendCenter + friendRadius - i,
+                )
+            } else {
+                1
+            }
             while (i + dp[i] < newStr.size && i - dp[i] >= 0 && newStr[i + dp[i]] == newStr[i - dp[i]]) {
                 dp[i]++
             }

src/main/kotlin/g0001_0100/s0010_regular_expression_matching/Solution.kt

@@ -31,7 +31,7 @@ class Solution {
                     i,
                     j - 2,
                     s,
-                    p
+                    p,
                 )
             }
         } else {

src/main/kotlin/g0001_0100/s0017_letter_combinations_of_a_phone_number/Solution.kt

@@ -19,7 +19,7 @@ class Solution {
         nums: String,
         letters: Array<String>,
         curr: StringBuilder,
-        ans: MutableList<String>
+        ans: MutableList<String>,
     ) {
         if (curr.length == nums.length) {
             ans.add(curr.toString())

src/main/kotlin/g0001_0100/s0023_merge_k_sorted_lists/Solution.kt

@@ -19,7 +19,9 @@ class Solution {
     fun mergeKLists(lists: Array<ListNode>): ListNode? {
         return if (lists.isEmpty()) {
             null
-        } else mergeKLists(lists, 0, lists.size)
+        } else {
+            mergeKLists(lists, 0, lists.size)
+        }
     }
 
     private fun mergeKLists(lists: Array<ListNode>, leftIndex: Int, rightIndex: Int): ListNode? {

src/main/kotlin/g0001_0100/s0030_substring_with_concatenation_of_all_words/Solution.kt

@@ -20,7 +20,6 @@ class Solution {
             // move a word's length each time
             var j = i
             while (j + window <= s.length) {
-
                 // get the subStr
                 val subStr = s.substring(j, j + window)
                 val map: MutableMap<String, Int> = HashMap()

src/main/kotlin/g0001_0100/s0040_combination_sum_ii/Solution.kt

@@ -19,7 +19,7 @@ class Solution {
         target: Int,
         start: Int,
         sums: MutableList<List<Int>>,
-        sum: LinkedList<Int>
+        sum: LinkedList<Int>,
     ) {
         if (target == 0) {
             // make a deep copy of the current combination
@@ -28,7 +28,6 @@ class Solution {
         }
         var i = start
         while (i < candidates.size && target >= candidates[i]) {
-
             // If candidate[i] equals candidate[i-1], then solutions for i is subset of
             // solution of i-1
             if (i == start || i > start && candidates[i] != candidates[i - 1]) {

src/main/kotlin/g0001_0100/s0046_permutations/Solution.kt

@@ -19,7 +19,7 @@ class Solution {
         nums: IntArray,
         finalResult: MutableList<List<Int>>,
         currResult: MutableList<Int>,
-        used: BooleanArray
+        used: BooleanArray,
     ) {
         if (currResult.size == nums.size) {
             finalResult.add(ArrayList(currResult))

src/main/kotlin/g0001_0100/s0048_rotate_image/Solution.kt

@@ -13,7 +13,7 @@ class Solution {
                     intArrayOf(i, j),
                     intArrayOf(j, n - 1 - i),
                     intArrayOf(n - 1 - i, n - 1 - j),
-                    intArrayOf(n - 1 - j, i)
+                    intArrayOf(n - 1 - j, i),
                 )
                 var t = matrix[pos[0][0]][pos[0][1]]
                 for (k in 1 until pos.size) {

src/main/kotlin/g0001_0100/s0049_group_anagrams/Solution.kt

@@ -12,7 +12,7 @@ class Solution {
             ch.sort()
             val temp = String(ch)
             hm.computeIfAbsent(
-                temp
+                temp,
             ) { _: String? -> ArrayList() }
             hm.getValue(temp).add(s)
         }

src/main/kotlin/g0001_0100/s0050_powx_n/Solution.kt

@@ -23,6 +23,8 @@ class Solution {
         }
         return if (n < 0) {
             1.0 / res
-        } else res
+        } else {
+            res
+        }
     }
 }

src/main/kotlin/g0001_0100/s0052_n_queens_ii/Solution.kt

@@ -17,7 +17,7 @@ class Solution {
         row: BooleanArray,
         col: BooleanArray,
         diagonal: BooleanArray,
-        antiDiagonal: BooleanArray
+        antiDiagonal: BooleanArray,
     ): Int {
         if (r == n) {
             return 1

src/main/kotlin/g0001_0100/s0079_word_search/Solution.kt

@@ -11,7 +11,7 @@ class Solution {
         word: String,
         index: Int,
         x: Int,
-        y: Int
+        y: Int,
     ): Boolean {
         if (index == word.length) {
             return true
@@ -40,7 +40,7 @@ class Solution {
     fun exist(board: Array<CharArray>, word: String): Boolean {
         val visited = Array(board.size) {
             BooleanArray(
-                board[0].size
+                board[0].size,
             )
         }
         for (i in board.indices) {

src/main/kotlin/g0001_0100/s0084_largest_rectangle_in_histogram/Solution.kt

@@ -38,7 +38,7 @@ class Solution {
             maxOfThreeNums(
                 largestArea(a, start, minInd),
                 a[minInd] * (limit - start),
-                largestArea(a, minInd + 1, limit)
+                largestArea(a, minInd + 1, limit),
             )
         }
     }

src/main/kotlin/g0001_0100/s0093_restore_ip_addresses/Solution.kt

@@ -17,7 +17,7 @@ class Solution {
                     '.' +
                     octets[2] +
                     '.' +
-                    octets[3]
+                    octets[3],
             )
         } else if (count < 4 && pos < 12) {
             var octet = 0

src/main/kotlin/g0001_0100/s0097_interleaving_string/Solution.kt

@@ -18,7 +18,7 @@ class Solution {
         i1: Int,
         i2: Int,
         i3: Int,
-        cache: Array<Array<Boolean?>>
+        cache: Array<Array<Boolean?>>,
     ): Boolean {
         if (cache[i1][i2] != null) {
             return cache[i1][i2]!!

src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt

@@ -30,6 +30,8 @@ class Solution {
         }
         return if (root.`val` <= left || root.`val` >= right) {
             false
-        } else solve(root.left, left, root.`val`.toLong()) && solve(root.right, root.`val`.toLong(), right)
+        } else {
+            solve(root.left, left, root.`val`.toLong()) && solve(root.right, root.`val`.toLong(), right)
+        }
     }
 }

src/main/kotlin/g0001_0100/s0100_same_tree/Solution.kt

@@ -20,7 +20,9 @@ class Solution {
         return if (n != null && m != null) {
             if (n.`val` != m.`val`) {
                 false
-            } else trav(n.left, m.left) && trav(n.right, m.right)
+            } else {
+                trav(n.left, m.left) && trav(n.right, m.right)
+            }
         } else {
             n == null && m == null
         }

src/main/kotlin/g0101_0200/s0101_symmetric_tree/Solution.kt

@@ -20,7 +20,9 @@ class Solution {
     fun isSymmetric(root: TreeNode?): Boolean {
         return if (root == null) {
             true
-        } else helper(root.left, root.right)
+        } else {
+            helper(root.left, root.right)
+        }
     }
 
     private fun helper(leftNode: TreeNode?, rightNode: TreeNode?): Boolean {
@@ -29,6 +31,8 @@ class Solution {
         }
         return if (leftNode.`val` != rightNode.`val`) {
             false
-        } else helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left)
+        } else {
+            helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left)
+        }
     }
 }

src/main/kotlin/g0101_0200/s0112_path_sum/Solution.kt

@@ -22,6 +22,8 @@ class Solution {
         }
         return if (targetSum == root.`val` && root.left == null && root.right == null) {
             true
-        } else hasPathSum(root.left, targetSum - root.`val`) || hasPathSum(root.right, targetSum - root.`val`)
+        } else {
+            hasPathSum(root.left, targetSum - root.`val`) || hasPathSum(root.right, targetSum - root.`val`)
+        }
     }
 }

src/main/kotlin/g0101_0200/s0113_path_sum_ii/Solution.kt

@@ -31,7 +31,7 @@ class Solution {
         al: ArrayList<Int>,
         sum: Int,
         targetSum: Int,
-        root: TreeNode?
+        root: TreeNode?,
     ) {
         var sum = sum
         if (root == null) {

src/main/kotlin/g0101_0200/s0120_triangle/Solution.kt

@@ -27,7 +27,7 @@ class Solution {
             triangle[row][col] +
                 Math.min(
                     dfs(triangle, dp, row + 1, col),
-                    dfs(triangle, dp, row + 1, col + 1)
+                    dfs(triangle, dp, row + 1, col + 1),
                 )
             )
         dp[row][col] = sum

src/main/kotlin/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/Solution.kt

@@ -5,7 +5,7 @@ package g0101_0200.s0123_best_time_to_buy_and_sell_stock_iii
 class Solution {
     fun maxProfit(prices: IntArray): Int {
         val n = prices.size
-        if (n <2) {
+        if (n < 2) {
             return 0
         }
         val a = IntArray(n) { 0 }

src/main/kotlin/g0101_0200/s0126_word_ladder_ii/Solution.kt

@@ -32,7 +32,7 @@ class Solution {
                 if (isLadder(word, next)) {
                     // construct the reverse graph from endWord
                     val reverseLadders = reverse.computeIfAbsent(
-                        next
+                        next,
                     ) { _: String? -> HashSet() }
                     reverseLadders.add(word)
                     if (endWord == next) {
@@ -71,7 +71,7 @@ class Solution {
         beginWord: String,
         graph: Map<String, MutableSet<String>>,
         ans: MutableList<List<String>>,
-        path: MutableSet<String>
+        path: MutableSet<String>,
     ) {
         val next = graph[endWord] ?: return
         for (word in next) {

src/main/kotlin/g0101_0200/s0128_longest_consecutive_sequence/Solution.kt

@@ -22,7 +22,7 @@ class Solution {
             if (num == lastNum) {
                 continue
             }
-            length ++
+            length++
             if (num - lastNum > 1) {
                 length = 1
             }

src/main/kotlin/g0101_0200/s0134_gas_station/Solution.kt

@@ -24,6 +24,8 @@ class Solution {
         }
         return if (sumGas < sumCost) {
             -1
-        } else result
+        } else {
+            result
+        }
     }
 }

src/main/kotlin/g0101_0200/s0140_word_break_ii/Solution.kt

@@ -18,7 +18,7 @@ class Solution {
         wordSet: Set<String>,
         index: Int,
         sb: StringBuilder,
-        result: MutableList<String>
+        result: MutableList<String>,
     ) {
         if (index == s.length) {
             if (sb[sb.length - 1] == ' ') {

src/main/kotlin/g0101_0200/s0150_evaluate_reverse_polish_notation/Solution.kt

@@ -8,7 +8,7 @@ class Solution {
         "/" to { a, b -> a / b },
         "*" to { a, b -> a * b },
         "+" to { a, b -> a + b },
-        "-" to { a, b -> a - b }
+        "-" to { a, b -> a - b },
     )
     fun evalRPN(tokens: Array<String>): Int {
         val stack = ArrayDeque<String>()

src/main/kotlin/g0101_0200/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.kt

@@ -7,7 +7,9 @@ class Solution {
     fun findMin(nums: IntArray): Int {
         return if (nums.isEmpty()) {
             0
-        } else find(0, nums.size - 1, nums)
+        } else {
+            find(0, nums.size - 1, nums)
+        }
     }
 
     private fun find(left: Int, right: Int, nums: IntArray): Int {

src/main/kotlin/g0101_0200/s0155_min_stack/MinStack.kt

@@ -9,8 +9,11 @@ class MinStack() {
     private val stack: ArrayDeque<Pair<Int, Int>> = ArrayDeque()
 
     fun push(x: Int) {
-        val min: Int = if (stack.isEmpty()) x
-        else getMin()
+        val min: Int = if (stack.isEmpty()) {
+            x
+        } else {
+            getMin()
+        }
         stack.addLast(x to minOf(min, x))
     }
 

src/main/kotlin/g0201_0300/s0201_bitwise_and_of_numbers_range/Solution.kt

@@ -41,7 +41,7 @@ class Solution {
             -0x10,
             -0x8,
             -0x4,
-            -0x2
+            -0x2,
         )
     }
 }

src/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt

@@ -34,7 +34,7 @@ class Solution {
     private fun buildGraph(
         numCourses: Int,
         prerequisites: Array<IntArray>,
-        indegrees: IntArray
+        indegrees: IntArray,
     ): List<List<Int>> {
         val graph = List(numCourses) { mutableListOf<Int>() }
         for ((cur, prev) in prerequisites) {