Fixed Idea warnings

javadev · web-flow · commit c593af3d98ea · 2025-03-26T15:46:37.000+02:00
diff --git a/src/main/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.kt b/src/main/kotlin/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.kt
@@ -4,7 +4,7 @@ package g0001_0100.s0034_find_first_and_last_position_of_element_in_sorted_array
 // #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_5 #Top_Interview_150_Binary_Search
 // #Big_O_Time_O(log_n)_Space_O(1) #2023_07_05_Time_174_ms_(100.00%)_Space_37.8_MB_(71.70%)
 
-class Solution constructor() {
+class Solution {
     fun searchRange(nums: IntArray, target: Int): IntArray {
         val ans = IntArray(2)
         ans[0] = helper(nums, target, false)
diff --git a/src/main/kotlin/g0001_0100/s0068_text_justification/Solution.kt b/src/main/kotlin/g0001_0100/s0068_text_justification/Solution.kt
@@ -55,7 +55,7 @@ class Solution {
                 startWord = i + 1
                 // resetting these to 0 for processing next line
                 lineTotal = 0
-                numWordsOnLine = lineTotal
+                numWordsOnLine = 0
                 // need a new StringBuilder for the next line
                 sb = StringBuilder(maxWidth)
             }
diff --git a/src/main/kotlin/g0201_0300/s0289_game_of_life/Solution.kt b/src/main/kotlin/g0201_0300/s0289_game_of_life/Solution.kt
@@ -47,7 +47,7 @@ class Solution {
     }
 
     private fun compute(board: Array<IntArray>, r: Int, c: Int): Int {
-        var ret: Int = 0
+        var ret = 0
         for (arr in dim) {
             val row = arr[0] + r
             val col = arr[1] + c
diff --git a/src/main/kotlin/g0201_0300/s0292_nim_game/Solution.kt b/src/main/kotlin/g0201_0300/s0292_nim_game/Solution.kt
@@ -4,9 +4,6 @@ package g0201_0300.s0292_nim_game
 
 class Solution {
     fun canWinNim(n: Int): Boolean {
-        if (n % 4 == 0) {
-            return false
-        }
-        return true
+        return n % 4 != 0
     }
 }
diff --git a/src/main/kotlin/g0301_0400/s0304_range_sum_query_2d_immutable/NumMatrix.kt b/src/main/kotlin/g0301_0400/s0304_range_sum_query_2d_immutable/NumMatrix.kt
@@ -5,14 +5,14 @@ package g0301_0400.s0304_range_sum_query_2d_immutable
 // #2022_11_07_Time_1373_ms_(85.71%)_Space_129.1_MB_(75.00%)
 
 class NumMatrix(matrix: Array<IntArray>) {
-    private val M = matrix.size
-    private val N = if (M > 0) matrix[0].size else 0
+    private val m = matrix.size
+    private val n = if (m > 0) matrix[0].size else 0
 
-    var array = Array<IntArray> (M + 1) { IntArray(N + 1) }
+    var array = Array<IntArray> (m + 1) { IntArray(n + 1) }
 
     init {
-        for (i in 1..M) {
-            for (j in 1..N) {
+        for (i in 1..m) {
+            for (j in 1..n) {
                 array[i][j] = matrix[i - 1][j - 1] + array[i][j - 1] + array[i - 1][j] - array[i - 1][j - 1]
             }
         }
diff --git a/src/main/kotlin/g0301_0400/s0310_minimum_height_trees/Solution.kt b/src/main/kotlin/g0301_0400/s0310_minimum_height_trees/Solution.kt
@@ -18,7 +18,7 @@ class Solution {
         while (queue.isNotEmpty()) {
             val size = queue.size
             val newLeaves = mutableListOf<Int>()
-            for (_sz in 0 until size) {
+            for (sz in 0 until size) {
                 val cur = queue.removeFirst()
                 newLeaves.add(cur)
                 for (next in graph[cur]) {
diff --git a/src/main/kotlin/g0301_0400/s0312_burst_balloons/Solution.kt b/src/main/kotlin/g0301_0400/s0312_burst_balloons/Solution.kt
@@ -18,7 +18,7 @@ class Solution {
             while (ei < nums.size) {
                 val l = if (si - 1 == -1) 1 else nums[si - 1]
                 val r = if (ei + 1 == nums.size) 1 else nums[ei + 1]
-                var maxAns = -1e7.toInt()
+                var maxAns = (-1e7).toInt()
                 for (cut in si..ei) {
                     val leftAns = if (si == cut) 0 else dp[si][cut - 1]
                     val rightAns = if (ei == cut) 0 else dp[cut + 1][ei]
diff --git a/src/main/kotlin/g0401_0500/s0409_longest_palindrome/Solution.kt b/src/main/kotlin/g0401_0500/s0409_longest_palindrome/Solution.kt
@@ -11,7 +11,7 @@ class Solution {
         for (c in s.toCharArray()) {
             set.flip(c.code - 'A'.code)
         }
-        return if (set.isEmpty()) {
+        return if (set.isEmpty) {
             s.length
         } else {
             s.length - set.cardinality() + 1
diff --git a/src/main/kotlin/g0701_0800/s0770_basic_calculator_iv/Solution.kt b/src/main/kotlin/g0701_0800/s0770_basic_calculator_iv/Solution.kt
@@ -97,7 +97,7 @@ class Solution {
     }
 
     private fun make(cur: String): Node {
-        val ans: Node = Node()
+        val ans = Node()
         val tmp: MutableList<String> = ArrayList()
         if (Character.isDigit(cur[0])) {
             ans.update(tmp, Integer.valueOf(cur))
diff --git a/src/main/kotlin/g0801_0900/s0811_subdomain_visit_count/Solution.kt b/src/main/kotlin/g0801_0900/s0811_subdomain_visit_count/Solution.kt
@@ -8,7 +8,7 @@ class Solution {
         val fmap: MutableMap<String, Int> = HashMap()
         for (s in d) {
             var rep = 0
-            var i: Int = 0
+            var i = 0
             while (i < s.length) {
                 val c = s[i]
                 rep = if (c in '0'..'9') {
diff --git a/src/main/kotlin/g1701_1800/s1739_building_boxes/Solution.kt b/src/main/kotlin/g1701_1800/s1739_building_boxes/Solution.kt
@@ -40,7 +40,7 @@ class Solution {
     }
 
     private fun product(vararg vals: Long): Long {
-        var product: Long = 1L
+        var product = 1L
         for (`val`: Long in vals) {
             product *= `val`
         }
diff --git a/src/main/kotlin/g1701_1800/s1748_sum_of_unique_elements/Solution.kt b/src/main/kotlin/g1701_1800/s1748_sum_of_unique_elements/Solution.kt
@@ -5,7 +5,7 @@ package g1701_1800.s1748_sum_of_unique_elements
 class Solution {
     fun sumOfUnique(nums: IntArray): Int {
         val map: MutableMap<Int, Int> = HashMap()
-        var sum: Int = 0
+        var sum = 0
         for (num: Int in nums) {
             map.put(num, map.getOrDefault(num, 0) + 1)
         }
diff --git a/src/main/kotlin/g1701_1800/s1749_maximum_absolute_sum_of_any_subarray/Solution.kt b/src/main/kotlin/g1701_1800/s1749_maximum_absolute_sum_of_any_subarray/Solution.kt
@@ -4,9 +4,9 @@ package g1701_1800.s1749_maximum_absolute_sum_of_any_subarray
 
 class Solution {
     fun maxAbsoluteSum(nums: IntArray): Int {
-        var min: Int = 0
-        var max: Int = 0
-        var s: Int = 0
+        var min = 0
+        var max = 0
+        var s = 0
         for (num: Int in nums) {
             s += num
             min = Math.min(min, s)
diff --git a/src/main/kotlin/g2201_2300/s2281_sum_of_total_strength_of_wizards/Solution.kt b/src/main/kotlin/g2201_2300/s2281_sum_of_total_strength_of_wizards/Solution.kt
@@ -45,7 +45,7 @@ class Solution {
                             ) *
                             nums[cur]
                         ) %
-                        mod
+                        MOD
                     )
             }
             dq.add(i)
@@ -59,7 +59,7 @@ class Solution {
                         getSum(nums, forward, prefix, backward, suffix, prev, cur, n) *
                         nums[cur]
                     ) %
-                    mod
+                    MOD
                 )
         }
         return res.toInt()
@@ -75,34 +75,34 @@ class Solution {
         cur: Int,
         next: Int,
     ): Long {
-        val sum = (cur - prev) * nums[cur].toLong() % mod * (next - cur) % mod
+        val sum = (cur - prev) * nums[cur].toLong() % MOD * (next - cur) % MOD
         val preSum = getPresum(backward, suffix, prev + 1, cur - 1, next - cur)
         val postSum = getPostsum(forward, prefix, cur + 1, next - 1, cur - prev)
-        return (sum + preSum + postSum) % mod
+        return (sum + preSum + postSum) % MOD
     }
 
     private fun getPresum(backward: LongArray, suffix: LongArray, from: Int, to: Int, m: Int): Long {
         val n = backward.size
         val cnt = to - from + 1L
         return (
-            (suffix[from] - suffix[to + 1] - cnt * (if (to + 1 == n) 0 else backward[to + 1]) % mod) %
-                mod
+            (suffix[from] - suffix[to + 1] - cnt * (if (to + 1 == n) 0 else backward[to + 1]) % MOD) %
+                MOD
                 * m %
-                mod
+                MOD
             )
     }
 
     private fun getPostsum(forward: LongArray, prefix: LongArray, from: Int, to: Int, m: Int): Long {
         val cnt = to - from + 1L
         return (
-            (prefix[to + 1] - prefix[from] - cnt * (if (0 == from) 0 else forward[from - 1]) % mod) %
-                mod
+            (prefix[to + 1] - prefix[from] - cnt * (if (0 == from) 0 else forward[from - 1]) % MOD) %
+                MOD
                 * m %
-                mod
+                MOD
             )
     }
 
     companion object {
-        private const val mod = 1e9.toInt() + 7
+        private const val MOD = 1e9.toInt() + 7
     }
 }
diff --git a/src/main/kotlin/g2501_2600/s2553_separate_the_digits_in_an_array/Solution.kt b/src/main/kotlin/g2501_2600/s2553_separate_the_digits_in_an_array/Solution.kt
@@ -14,8 +14,8 @@ class Solution {
         }
         val num = IntArray(arr.size)
         var i = arr.size - 1
-        for (I in arr) {
-            num[i--] = I
+        for (j in arr) {
+            num[i--] = j
         }
         return num
     }
diff --git a/src/main/kotlin/g2501_2600/s2574_left_and_right_sum_differences/Solution.kt b/src/main/kotlin/g2501_2600/s2574_left_and_right_sum_differences/Solution.kt
@@ -5,7 +5,7 @@ package g2501_2600.s2574_left_and_right_sum_differences
 class Solution {
     fun leftRightDifference(nums: IntArray): IntArray {
         val n = nums.size
-        val ans: IntArray = IntArray(n)
+        val ans = IntArray(n)
         var rightSum = nums.sum()
         var leftSum = 0
 
diff --git a/src/main/kotlin/g2701_2800/s2729_check_if_the_number_is_fascinating/Solution.kt b/src/main/kotlin/g2701_2800/s2729_check_if_the_number_is_fascinating/Solution.kt
@@ -6,22 +6,18 @@ package g2701_2800.s2729_check_if_the_number_is_fascinating
 class Solution {
     fun isFascinating(n: Int): Boolean {
         val set = HashSet<Int>()
-        fun add(_cur: Int): Boolean {
-            var cur = _cur
-            while (cur > 0) {
-                val n = cur % 10
+        fun add(cur: Int): Boolean {
+            var localCur = cur
+            while (localCur > 0) {
+                val n = localCur % 10
                 if (n == 0 || set.contains(n)) {
                     return false
                 }
                 set.add(n)
-                cur /= 10
+                localCur /= 10
             }
             return true
         }
-
-        if (!add(n) || !add(2 * n) || !add(3 * n)) {
-            return false
-        }
-        return true
+        return !(!add(n) || !add(2 * n) || !add(3 * n))
     }
 }
diff --git a/src/test/kotlin/com_github_leetcode/NodeTest.kt b/src/test/kotlin/com_github_leetcode/NodeTest.kt
@@ -21,14 +21,14 @@ internal class NodeTest {
 
     @Test
     fun constructor3() {
-        val node: Node = Node(1, listOf(Node(2)))
+        val node = Node(1, listOf(Node(2)))
         assertThat(node.`val`, equalTo(1))
         assertThat(node.toString(), equalTo("[2]"))
     }
 
     @Test
     fun constructor4() {
-        val node: Node = Node(
+        val node = Node(
             1,
             listOf(
                 Node(2, listOf(Node(3))),
diff --git a/src/test/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSetTest.kt b/src/test/kotlin/g0301_0400/s0380_insert_delete_getrandom_o1/RandomizedSetTest.kt
@@ -8,9 +8,8 @@ internal class RandomizedSetTest {
     @Test
     fun randomizedSet() {
         val result: MutableList<String> = ArrayList()
-        var randomizedSet: RandomizedSet? = null
-        result.add(randomizedSet.toString() + "")
-        randomizedSet = RandomizedSet()
+        result.add("null")
+        var randomizedSet = RandomizedSet()
         result.add(randomizedSet.insert(1).toString() + "")
         result.add(randomizedSet.remove(2).toString() + "")
         result.add(randomizedSet.insert(2).toString() + "")

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ class Solution {`
`55`	`55`	`startWord = i + 1`
`56`	`56`	`// resetting these to 0 for processing next line`
`57`	`57`	`lineTotal = 0`
`58`		`- numWordsOnLine = lineTotal`
	`58`	`+ numWordsOnLine = 0`
`59`	`59`	`// need a new StringBuilder for the next line`
`60`	`60`	`sb = StringBuilder(maxWidth)`
`61`	`61`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ class Solution {`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`private fun compute(board: Array<IntArray>, r: Int, c: Int): Int {`
`50`		`- var ret: Int = 0`
	`50`	`+ var ret = 0`
`51`	`51`	`for (arr in dim) {`
`52`	`52`	`val row = arr[0] + r`
`53`	`53`	`val col = arr[1] + c`
Original file line number	Diff line number	Diff line change
`@@ -4,9 +4,6 @@ package g0201_0300.s0292_nim_game`
`4`	`4`
`5`	`5`	`class Solution {`
`6`	`6`	`fun canWinNim(n: Int): Boolean {`
`7`		`- if (n % 4 == 0) {`
`8`		`- return false`
`9`		`- }`
`10`		`- return true`
	`7`	`+ return n % 4 != 0`
`11`	`8`	`}`
`12`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ class Solution {`
`11`	`11`	`for (c in s.toCharArray()) {`
`12`	`12`	`set.flip(c.code - 'A'.code)`
`13`	`13`	`}`
`14`		`- return if (set.isEmpty()) {`
	`14`	`+ return if (set.isEmpty) {`
`15`	`15`	`s.length`
`16`	`16`	`} else {`
`17`	`17`	`s.length - set.cardinality() + 1`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ class Solution {`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`private fun make(cur: String): Node {`
`100`		`- val ans: Node = Node()`
	`100`	`+ val ans = Node()`
`101`	`101`	`val tmp: MutableList<String> = ArrayList()`
`102`	`102`	`if (Character.isDigit(cur[0])) {`
`103`	`103`	`ans.update(tmp, Integer.valueOf(cur))`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ class Solution {`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`private fun product(vararg vals: Long): Long {`
`43`		`- var product: Long = 1L`
	`43`	`+ var product = 1L`
`44`	`44`	for (`val`: Long in vals) {
`45`	`45`	product *= `val`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ package g1701_1800.s1748_sum_of_unique_elements`
`5`	`5`	`class Solution {`
`6`	`6`	`fun sumOfUnique(nums: IntArray): Int {`
`7`	`7`	`val map: MutableMap<Int, Int> = HashMap()`
`8`		`- var sum: Int = 0`
	`8`	`+ var sum = 0`
`9`	`9`	`for (num: Int in nums) {`
`10`	`10`	`map.put(num, map.getOrDefault(num, 0) + 1)`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ class Solution {`
`45`	`45`	`) *`
`46`	`46`	`nums[cur]`
`47`	`47`	`) %`
`48`		`- mod`
	`48`	`+ MOD`
`49`	`49`	`)`
`50`	`50`	`}`
`51`	`51`	`dq.add(i)`
`@@ -59,7 +59,7 @@ class Solution {`
`59`	`59`	`getSum(nums, forward, prefix, backward, suffix, prev, cur, n) *`
`60`	`60`	`nums[cur]`
`61`	`61`	`) %`
`62`		`- mod`
	`62`	`+ MOD`
`63`	`63`	`)`
`64`	`64`	`}`
`65`	`65`	`return res.toInt()`
`@@ -75,34 +75,34 @@ class Solution {`
`75`	`75`	`cur: Int,`
`76`	`76`	`next: Int,`
`77`	`77`	`): Long {`
`78`		`- val sum = (cur - prev) * nums[cur].toLong() % mod * (next - cur) % mod`
	`78`	`+ val sum = (cur - prev) * nums[cur].toLong() % MOD * (next - cur) % MOD`
`79`	`79`	`val preSum = getPresum(backward, suffix, prev + 1, cur - 1, next - cur)`
`80`	`80`	`val postSum = getPostsum(forward, prefix, cur + 1, next - 1, cur - prev)`
`81`		`- return (sum + preSum + postSum) % mod`
	`81`	`+ return (sum + preSum + postSum) % MOD`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`private fun getPresum(backward: LongArray, suffix: LongArray, from: Int, to: Int, m: Int): Long {`
`85`	`85`	`val n = backward.size`
`86`	`86`	`val cnt = to - from + 1L`
`87`	`87`	`return (`
`88`		`- (suffix[from] - suffix[to + 1] - cnt * (if (to + 1 == n) 0 else backward[to + 1]) % mod) %`
`89`		`- mod`
	`88`	`+ (suffix[from] - suffix[to + 1] - cnt * (if (to + 1 == n) 0 else backward[to + 1]) % MOD) %`
	`89`	`+ MOD`
`90`	`90`	`* m %`
`91`		`- mod`
	`91`	`+ MOD`
`92`	`92`	`)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`private fun getPostsum(forward: LongArray, prefix: LongArray, from: Int, to: Int, m: Int): Long {`
`96`	`96`	`val cnt = to - from + 1L`
`97`	`97`	`return (`
`98`		`- (prefix[to + 1] - prefix[from] - cnt * (if (0 == from) 0 else forward[from - 1]) % mod) %`
`99`		`- mod`
	`98`	`+ (prefix[to + 1] - prefix[from] - cnt * (if (0 == from) 0 else forward[from - 1]) % MOD) %`
	`99`	`+ MOD`
`100`	`100`	`* m %`
`101`		`- mod`
	`101`	`+ MOD`
`102`	`102`	`)`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`companion object {`
`106`		`- private const val mod = 1e9.toInt() + 7`
	`106`	`+ private const val MOD = 1e9.toInt() + 7`
`107`	`107`	`}`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,8 @@ class Solution {`
`14`	`14`	`}`
`15`	`15`	`val num = IntArray(arr.size)`
`16`	`16`	`var i = arr.size - 1`
`17`		`- for (I in arr) {`
`18`		`- num[i--] = I`
	`17`	`+ for (j in arr) {`
	`18`	`+ num[i--] = j`
`19`	`19`	`}`
`20`	`20`	`return num`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,22 +6,18 @@ package g2701_2800.s2729_check_if_the_number_is_fascinating`
`6`	`6`	`class Solution {`
`7`	`7`	`fun isFascinating(n: Int): Boolean {`
`8`	`8`	`val set = HashSet<Int>()`
`9`		`- fun add(_cur: Int): Boolean {`
`10`		`- var cur = _cur`
`11`		`- while (cur > 0) {`
`12`		`- val n = cur % 10`
	`9`	`+ fun add(cur: Int): Boolean {`
	`10`	`+ var localCur = cur`
	`11`	`+ while (localCur > 0) {`
	`12`	`+ val n = localCur % 10`
`13`	`13`	`if (n == 0 \|\| set.contains(n)) {`
`14`	`14`	`return false`
`15`	`15`	`}`
`16`	`16`	`set.add(n)`
`17`		`- cur /= 10`
	`17`	`+ localCur /= 10`
`18`	`18`	`}`
`19`	`19`	`return true`
`20`	`20`	`}`
`21`		`-`
`22`		`- if (!add(n) \|\| !add(2 * n) \|\| !add(3 * n)) {`
`23`		`- return false`
`24`		`- }`
`25`		`- return true`
	`21`	`+ return !(!add(n) \|\| !add(2 * n) \|\| !add(3 * n))`
`26`	`22`	`}`
`27`	`23`	`}`