Fixed idea warnings

javadev · javadev · commit e469390ab112 · 2025-07-08T18:59:08.000+03:00
diff --git a/src/main/java/g0001_0100/s0068_text_justification/Solution.java b/src/main/java/g0001_0100/s0068_text_justification/Solution.java
@@ -44,9 +44,13 @@ public List<String> fullJustify(String[] words, int maxWidth) {
                             sb.append(' ');
                         }
                         // appending the rest of the required spaces
-                        for (int k = 0; k < (maxWidth - lineTotal) / (numWordsOnLine - 1); k++) {
-                            sb.append(' ');
-                        }
+                        sb.append(
+                                " "
+                                        .repeat(
+                                                Math.max(
+                                                        0,
+                                                        (maxWidth - lineTotal)
+                                                                / (numWordsOnLine - 1))));
                     }
                     // appending the last word of the line
                     sb.append(words[startWord + numWordsOnLine - 1]);
diff --git a/src/main/java/g0201_0300/s0297_serialize_and_deserialize_binary_tree/Codec.java b/src/main/java/g0201_0300/s0297_serialize_and_deserialize_binary_tree/Codec.java
@@ -36,11 +36,7 @@ public void serialize(TreeNode root, StringBuilder sb) {
             return;
         }
         String s = Integer.toHexString(root.val + BASE_OFFSET);
-        StringBuilder sb2 = new StringBuilder();
-        for (int i = 0; i < 3 - s.length(); i++) {
-            sb2.append('0');
-        }
-        sb2.append(s);
+        String sb2 = "0".repeat(Math.max(0, 3 - s.length())) + s;
         sb.append(sb2);
         serialize(root.left, sb);
         serialize(root.right, sb);
diff --git a/src/main/java/g0401_0500/s0451_sort_characters_by_frequency/Solution.java b/src/main/java/g0401_0500/s0451_sort_characters_by_frequency/Solution.java
@@ -27,9 +27,7 @@ public String frequencySort(String s) {
         for (Map.Entry<Integer, List<Character>> freq : reverseMap.entrySet()) {
             List<Character> list = reverseMap.get(freq.getKey());
             for (char c : list) {
-                for (int i = 0; i < freq.getKey(); i++) {
-                    sb.append(c);
-                }
+                sb.append(String.valueOf(c).repeat(Math.max(0, freq.getKey())));
             }
         }
         return sb.toString();
diff --git a/src/main/java/g0401_0500/s0494_target_sum/Solution.java b/src/main/java/g0401_0500/s0494_target_sum/Solution.java
@@ -7,8 +7,8 @@ public class Solution {
     public int findTargetSumWays(int[] nums, int target) {
         int totalSum = 0;
         int n = nums.length;
-        for (int i = 0; i < n; i++) {
-            totalSum += nums[i];
+        for (int num : nums) {
+            totalSum += num;
         }
         int sum = totalSum - target;
         if (sum < 0 || sum % 2 == 1) {
diff --git a/src/main/java/g0701_0800/s0753_cracking_the_safe/Solution.java b/src/main/java/g0701_0800/s0753_cracking_the_safe/Solution.java
@@ -12,9 +12,7 @@ public String crackSafe(int n, int k) {
         visited[0] = true;
         int visitedCnt = 1;
         StringBuilder crackStr = new StringBuilder();
-        for (int i = 0; i < n; i++) {
-            crackStr.append('0');
-        }
+        crackStr.append("0".repeat(Math.max(0, n)));
         dfsAddPwd(n, k, crackStr, 0, visited, visitedCnt, targetCnt);
         return foundStr;
     }
diff --git a/src/main/java/g0901_1000/s0972_equal_rational_numbers/Solution.java b/src/main/java/g0901_1000/s0972_equal_rational_numbers/Solution.java
@@ -29,10 +29,6 @@ public boolean isRationalEqual(String s, String t) {
     }
 
     private String repeat(String a) {
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < 100; i++) {
-            sb.append(a);
-        }
-        return sb.toString();
+        return String.valueOf(a).repeat(100);
     }
 }
diff --git a/src/main/java/g1101_1200/s1138_alphabet_board_path/Solution.java b/src/main/java/g1101_1200/s1138_alphabet_board_path/Solution.java
@@ -35,9 +35,7 @@ public String alphabetBoardPath(String target) {
 
     public StringBuilder helper(String dir, int time) {
         StringBuilder path = new StringBuilder();
-        for (int i = 0; i < time; i++) {
-            path.append(dir);
-        }
+        path.append(String.valueOf(dir).repeat(Math.max(0, time)));
         return path;
     }
 }
diff --git a/src/main/java/g1501_1600/s1592_rearrange_spaces_between_words/Solution.java b/src/main/java/g1501_1600/s1592_rearrange_spaces_between_words/Solution.java
@@ -12,25 +12,17 @@ public String reorderSpaces(String text) {
         }
         String[] words = text.trim().split("\\s+");
         if (words.length == 1) {
-            StringBuilder sb = new StringBuilder(words[0]);
-            for (int i = 0; i < spaceCount; i++) {
-                sb.append(" ");
-            }
-            return sb.toString();
+            return words[0] + " ".repeat(Math.max(0, spaceCount));
         }
         int trailingSpaces = spaceCount % (words.length - 1);
         int newSpaces = spaceCount / (words.length - 1);
         StringBuilder sb = new StringBuilder();
         for (int j = 0; j < words.length; j++) {
             sb.append(words[j]);
             if (j < words.length - 1) {
-                for (int i = 0; i < newSpaces; i++) {
-                    sb.append(" ");
-                }
+                sb.append(" ".repeat(Math.max(0, newSpaces)));
             } else {
-                for (int i = 0; i < trailingSpaces; i++) {
-                    sb.append(" ");
-                }
+                sb.append(" ".repeat(Math.max(0, trailingSpaces)));
             }
         }
         return sb.toString();
diff --git a/src/main/java/g1601_1700/s1643_kth_smallest_instructions/Solution.java b/src/main/java/g1601_1700/s1643_kth_smallest_instructions/Solution.java
@@ -19,14 +19,10 @@ public String kthSmallestPath(int[] destination, int k) {
                 k -= range;
             }
             if (v == 0) {
-                for (int i = 1; i <= n; i++) {
-                    sb.append('H');
-                }
+                sb.append("H".repeat(Math.max(0, n)));
                 break;
             } else if (v == n) {
-                for (int i = 1; i <= v; i++) {
-                    sb.append('V');
-                }
+                sb.append("V".repeat(Math.max(0, v)));
                 break;
             }
         }
diff --git a/src/main/java/g1701_1800/s1764_form_array_by_concatenating_subarrays_of_another_array/Solution.java b/src/main/java/g1701_1800/s1764_form_array_by_concatenating_subarrays_of_another_array/Solution.java
@@ -7,17 +7,17 @@
 public class Solution {
     public boolean canChoose(int[][] groups, int[] nums) {
         int prev = 0;
-        for (int i = 0; i < groups.length; i++) {
-            int[] temp = new int[groups[i].length];
-            if (prev + groups[i].length > nums.length) {
+        for (int[] group : groups) {
+            int[] temp = new int[group.length];
+            if (prev + group.length > nums.length) {
                 return false;
             }
             int index = 0;
             int j;
-            for (j = prev; j < prev + groups[i].length; j++) {
+            for (j = prev; j < prev + group.length; j++) {
                 temp[index++] = nums[j];
             }
-            if (Arrays.equals(temp, groups[i])) {
+            if (Arrays.equals(temp, group)) {
                 prev = j;
                 continue;
             }
@@ -28,7 +28,7 @@ public boolean canChoose(int[][] groups, int[] nums) {
                     temp[l] = temp[l + 1];
                 }
                 temp[l] = nums[k];
-                if (Arrays.equals(temp, groups[i])) {
+                if (Arrays.equals(temp, group)) {
                     prev = k + 1;
                     break;
                 }
diff --git a/src/main/java/g2001_2100/s2096_step_by_step_directions_from_a_binary_tree_node_to_another/Solution.java b/src/main/java/g2001_2100/s2096_step_by_step_directions_from_a_binary_tree_node_to_another/Solution.java
@@ -15,7 +15,7 @@ private boolean find(TreeNode n, int val, StringBuilder sb) {
         } else if (n.right != null && find(n.right, val, sb)) {
             sb.append("R");
         }
-        return sb.length() > 0;
+        return !sb.isEmpty();
     }
 
     public String getDirections(TreeNode root, int startValue, int destValue) {
@@ -28,11 +28,6 @@ public String getDirections(TreeNode root, int startValue, int destValue) {
         while (i < maxI && s.charAt(s.length() - i - 1) == d.charAt(d.length() - i - 1)) {
             ++i;
         }
-        StringBuilder result = new StringBuilder();
-        for (int j = 0; j < s.length() - i; j++) {
-            result.append("U");
-        }
-        result.append(d.reverse().substring(i));
-        return result.toString();
+        return "U".repeat(Math.max(0, s.length() - i)) + d.reverse().substring(i);
     }
 }
diff --git a/src/main/java/g2301_2400/s2318_number_of_distinct_roll_sequences/Solution.java b/src/main/java/g2301_2400/s2318_number_of_distinct_roll_sequences/Solution.java
@@ -3,9 +3,8 @@
 // #Hard #Dynamic_Programming #Memoization #2022_06_26_Time_254_ms_(91.67%)_Space_51.6_MB_(58.33%)
 
 public class Solution {
-    private int[][][] memo = new int[10001][7][7];
-    private int mod = 1000000007;
-    private int[][] m = {
+    private static final int MOD = 1000000007;
+    private static final int[][] M = {
         {1, 2, 3, 4, 5, 6},
         {2, 3, 4, 5, 6},
         {1, 3, 5},
@@ -14,6 +13,7 @@ public class Solution {
         {1, 2, 3, 4, 6},
         {1, 5}
     };
+    private final int[][][] memo = new int[10001][7][7];
 
     public int distinctSequences(int n) {
         return dp(n, 0, 0);
@@ -27,9 +27,9 @@ private int dp(int n, int prev, int pprev) {
             return memo[n][prev][pprev];
         }
         int ans = 0;
-        for (int x : m[prev]) {
+        for (int x : M[prev]) {
             if (x != pprev) {
-                ans = (ans + dp(n - 1, x, prev)) % mod;
+                ans = (ans + dp(n - 1, x, prev)) % MOD;
             }
         }
         memo[n][prev][pprev] = ans;
diff --git a/src/main/java/g2301_2400/s2365_task_scheduler_ii/Solution.java b/src/main/java/g2301_2400/s2365_task_scheduler_ii/Solution.java
@@ -9,15 +9,15 @@ public long taskSchedulerII(int[] tasks, int space) {
         long days = 0;
         space++;
         HashMap<Integer, Long> lastOccurence = new HashMap<>();
-        for (int i = 0; i < tasks.length; i++) {
-            if (lastOccurence.containsKey(tasks[i])) {
-                long lastTimeOccurred = lastOccurence.get(tasks[i]);
+        for (int task : tasks) {
+            if (lastOccurence.containsKey(task)) {
+                long lastTimeOccurred = lastOccurence.get(task);
                 long daysDifference = days - lastTimeOccurred;
                 if (daysDifference < space) {
                     days += (space - daysDifference);
                 }
             }
-            lastOccurence.put(tasks[i], days);
+            lastOccurence.put(task, days);
             days++;
         }
         return days;
diff --git a/src/main/java/g2401_2500/s2441_largest_positive_integer_that_exists_with_its_negative/Solution.java b/src/main/java/g2401_2500/s2441_largest_positive_integer_that_exists_with_its_negative/Solution.java
@@ -8,9 +8,9 @@ public class Solution {
     public int findMaxK(int[] nums) {
         int[] arr = new int[nums.length];
         int j = 0;
-        for (int i = 0; i < nums.length; i++) {
-            if (nums[i] < 0) {
-                arr[j++] = nums[i];
+        for (int k : nums) {
+            if (k < 0) {
+                arr[j++] = k;
             }
         }
         Arrays.sort(arr);
diff --git a/src/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/Solution.java b/src/main/java/g2401_2500/s2500_delete_greatest_value_in_each_row/Solution.java
@@ -7,14 +7,14 @@
 public class Solution {
     public int deleteGreatestValue(int[][] grid) {
         int sum = 0;
-        for (int i = 0; i < grid.length; i++) {
-            Arrays.sort(grid[i]);
+        for (int[] value : grid) {
+            Arrays.sort(value);
         }
         for (int j = 0; j < grid[0].length; j++) {
             int max = Integer.MIN_VALUE;
-            for (int i = 0; i < grid.length; i++) {
-                if (grid[i][j] > max) {
-                    max = grid[i][j];
+            for (int[] ints : grid) {
+                if (ints[j] > max) {
+                    max = ints[j];
                 }
             }
             sum += max;
diff --git a/src/main/java/g2501_2600/s2598_smallest_missing_non_negative_integer_after_operations/Solution.java b/src/main/java/g2501_2600/s2598_smallest_missing_non_negative_integer_after_operations/Solution.java
@@ -9,8 +9,8 @@ public int findSmallestInteger(int[] nums, int value) {
             return n;
         }
         int[] a = new int[value];
-        for (int i = 0; i < n; i++) {
-            int k = nums[i] % value;
+        for (int num : nums) {
+            int k = num % value;
             if (k < 0) {
                 k = (value + k) % value;
             }
diff --git a/src/main/java/g2601_2700/s2661_first_completely_painted_row_or_column/Solution.java b/src/main/java/g2601_2700/s2661_first_completely_painted_row_or_column/Solution.java
@@ -9,18 +9,18 @@ public int firstCompleteIndex(int[] arr, int[][] mat) {
             numMapIndex[arr[i]] = i;
         }
         int ans = Integer.MAX_VALUE;
-        for (int i = 0; i < mat.length; i++) {
+        for (int[] value : mat) {
             int rowMin = Integer.MIN_VALUE;
-            for (int i1 = 0; i1 < mat[i].length; i1++) {
-                int index = numMapIndex[mat[i][i1]];
+            for (int i : value) {
+                int index = numMapIndex[i];
                 rowMin = Math.max(rowMin, index);
             }
             ans = Math.min(ans, rowMin);
         }
         for (int i = 0; i < mat[0].length; i++) {
             int colMin = Integer.MIN_VALUE;
-            for (int i1 = 0; i1 < mat.length; i1++) {
-                int index = numMapIndex[mat[i1][i]];
+            for (int[] ints : mat) {
+                int index = numMapIndex[ints[i]];
                 colMin = Math.max(colMin, index);
             }
             ans = Math.min(ans, colMin);
diff --git a/src/main/java/g2701_2800/s2799_count_complete_subarrays_in_an_array/Solution.java b/src/main/java/g2701_2800/s2799_count_complete_subarrays_in_an_array/Solution.java
@@ -18,16 +18,16 @@ public int countCompleteSubarrays(int[] nums) {
             map[nums[i]]++;
         }
         int ans = 0;
-        for (int i = 0; i < n; ++i) {
+        for (int num : nums) {
             ans += n - last;
-            map[nums[i]]--;
-            if (map[nums[i]] == 0) {
+            map[num]--;
+            if (map[num] == 0) {
                 int possLast = 0;
-                for (int j = last + 1; j < n && map[nums[i]] == 0; ++j) {
+                for (int j = last + 1; j < n && map[num] == 0; ++j) {
                     map[nums[j]]++;
                     possLast = j;
                 }
-                if (map[nums[i]] > 0) {
+                if (map[num] > 0) {
                     last = possLast;
                 } else {
                     break;
diff --git a/src/main/java/g2801_2900/s2899_last_visited_integers/Solution.java b/src/main/java/g2801_2900/s2899_last_visited_integers/Solution.java
@@ -10,10 +10,10 @@ public List<Integer> lastVisitedIntegers(List<String> words) {
         List<String> prevEle = new ArrayList<>();
         List<Integer> res = new ArrayList<>();
         int count = 0;
-        for (int i = 0; i < words.size(); i++) {
-            if (!words.get(i).equals("prev")) {
+        for (String word : words) {
+            if (!word.equals("prev")) {
                 count = 0;
-                prevEle.add(words.get(i));
+                prevEle.add(word);
                 continue;
             }
             if (count >= prevEle.size()) {
diff --git a/src/main/java/g3101_3200/s3122_minimum_number_of_operations_to_satisfy_conditions/Solution.java b/src/main/java/g3101_3200/s3122_minimum_number_of_operations_to_satisfy_conditions/Solution.java
@@ -9,9 +9,9 @@ public int minimumOperations(int[][] grid) {
         int m = grid[0].length;
         int[][] dp = new int[m][10];
         int[][] cnt = new int[m][10];
-        for (int i = 0; i < n; ++i) {
+        for (int[] ints : grid) {
             for (int j = 0; j < m; j++) {
-                cnt[j][grid[i][j]]++;
+                cnt[j][ints[j]]++;
             }
         }
         int first = Integer.MAX_VALUE;
diff --git a/src/main/java/g3101_3200/s3138_minimum_length_of_anagram_concatenation/Solution.java b/src/main/java/g3101_3200/s3138_minimum_length_of_anagram_concatenation/Solution.java
@@ -20,8 +20,7 @@ public int minAnagramLength(String s) {
         }
         List<Integer> factors = getAllFactorsVer2(n);
         Collections.sort(factors);
-        for (int j = 0; j < factors.size(); j++) {
-            int factor = factors.get(j);
+        for (int factor : factors) {
             if (factor == 1) {
                 if (sq[0] * n == sq[n - 1]) {
                     return 1;
diff --git a/src/main/java/g3101_3200/s3164_find_the_number_of_good_pairs_ii/Solution.java b/src/main/java/g3101_3200/s3164_find_the_number_of_good_pairs_ii/Solution.java
@@ -11,20 +11,19 @@ public long numberOfPairs(int[] nums1, int[] nums2, int k) {
         for (int val : nums2) {
             hm.put(val * k, hm.getOrDefault(val * k, 0) + 1);
         }
-        for (int indx = 0; indx < nums1.length; indx++) {
-            if (nums1[indx] % k != 0) {
+        for (int i : nums1) {
+            if (i % k != 0) {
                 continue;
             }
-            for (int factor = 1; factor * factor <= nums1[indx]; factor++) {
-                if (nums1[indx] % factor != 0) {
+            for (int factor = 1; factor * factor <= i; factor++) {
+                if (i % factor != 0) {
                     continue;
                 }
-                int factor1 = factor;
-                int factor2 = nums1[indx] / factor;
-                if (hm.containsKey(factor1)) {
-                    ans += hm.get(factor1);
+                int factor2 = i / factor;
+                if (hm.containsKey(factor)) {
+                    ans += hm.get(factor);
                 }
-                if (factor1 != factor2 && hm.containsKey(factor2)) {
+                if (factor != factor2 && hm.containsKey(factor2)) {
                     ans += hm.get(factor2);
                 }
             }
diff --git a/src/main/java/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/Solution.java b/src/main/java/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/Solution.java
diff --git a/src/main/java/g3101_3200/s3190_find_minimum_operations_to_make_all_elements_divisible_by_three/Solution.java b/src/main/java/g3101_3200/s3190_find_minimum_operations_to_make_all_elements_divisible_by_three/Solution.java
diff --git a/src/main/java/g3301_3400/s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i/Solution.java b/src/main/java/g3301_3400/s3305_count_of_substrings_containing_every_vowel_and_k_consonants_i/Solution.java
diff --git a/src/main/java/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.java b/src/main/java/g3301_3400/s3394_check_if_grid_can_be_cut_into_sections/Solution.java
diff --git a/src/main/java/g3401_3500/s3433_count_mentions_per_user/Solution.java b/src/main/java/g3401_3500/s3433_count_mentions_per_user/Solution.java
diff --git a/src/main/java/g3401_3500/s3477_fruits_into_baskets_ii/Solution.java b/src/main/java/g3401_3500/s3477_fruits_into_baskets_ii/Solution.java
diff --git a/src/main/java/g3501_3600/s3558_number_of_ways_to_assign_edge_weights_i/Solution.java b/src/main/java/g3501_3600/s3558_number_of_ways_to_assign_edge_weights_i/Solution.java
diff --git a/src/main/java/g3501_3600/s3575_maximum_good_subtree_score/Solution.java b/src/main/java/g3501_3600/s3575_maximum_good_subtree_score/Solution.java

Original file line number	Diff line number	Diff line change
`@@ -27,9 +27,7 @@ public String frequencySort(String s) {`
`27`	`27`	`for (Map.Entry<Integer, List<Character>> freq : reverseMap.entrySet()) {`
`28`	`28`	`List<Character> list = reverseMap.get(freq.getKey());`
`29`	`29`	`for (char c : list) {`
`30`		`- for (int i = 0; i < freq.getKey(); i++) {`
`31`		`- sb.append(c);`
`32`		`- }`
	`30`	`+ sb.append(String.valueOf(c).repeat(Math.max(0, freq.getKey())));`
`33`	`31`	`}`
`34`	`32`	`}`
`35`	`33`	`return sb.toString();`
Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,6 @@ public boolean isRationalEqual(String s, String t) {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`private String repeat(String a) {`
`32`		`- StringBuilder sb = new StringBuilder();`
`33`		`- for (int i = 0; i < 100; i++) {`
`34`		`- sb.append(a);`
`35`		`- }`
`36`		`- return sb.toString();`
	`32`	`+ return String.valueOf(a).repeat(100);`
`37`	`33`	`}`
`38`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,9 +35,7 @@ public String alphabetBoardPath(String target) {`
`35`	`35`
`36`	`36`	`public StringBuilder helper(String dir, int time) {`
`37`	`37`	`StringBuilder path = new StringBuilder();`
`38`		`- for (int i = 0; i < time; i++) {`
`39`		`- path.append(dir);`
`40`		`- }`
	`38`	`+ path.append(String.valueOf(dir).repeat(Math.max(0, time)));`
`41`	`39`	`return path;`
`42`	`40`	`}`
`43`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,14 +19,10 @@ public String kthSmallestPath(int[] destination, int k) {`
`19`	`19`	`k -= range;`
`20`	`20`	`}`
`21`	`21`	`if (v == 0) {`
`22`		`- for (int i = 1; i <= n; i++) {`
`23`		`- sb.append('H');`
`24`		`- }`
	`22`	`+ sb.append("H".repeat(Math.max(0, n)));`
`25`	`23`	`break;`
`26`	`24`	`} else if (v == n) {`
`27`		`- for (int i = 1; i <= v; i++) {`
`28`		`- sb.append('V');`
`29`		`- }`
	`25`	`+ sb.append("V".repeat(Math.max(0, v)));`
`30`	`26`	`break;`
`31`	`27`	`}`
`32`	`28`	`}`