Fixed idea warnings

src/main/java/g0001_0100/s0068_text_justification/Solution.java

@@ -44,9 +44,8 @@ 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(' ');
-                        }
+                        int max = Math.max(0, (maxWidth - lineTotal) / (numWordsOnLine - 1));
+                        sb.append(" ".repeat(max));
                     }
                     // appending the last word of the line
                     sb.append(words[startWord + numWordsOnLine - 1]);

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);

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();

src/main/java/g0401_0500/s0494_target_sum/Solution.java

@@ -6,9 +6,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) {

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;
     }

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);
     }
 }

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;
     }
 }

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();

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;
             }
         }

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;
                 }

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);
     }
 }

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;

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;

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);

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;

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;
             }

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);

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;

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()) {

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;

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;

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);
                 }
             }

src/main/java/g3101_3200/s3165_maximum_sum_of_subsequence_with_non_adjacent_elements/Solution.java

@@ -13,8 +13,8 @@ public class Solution {
     public int maximumSumSubsequence(int[] nums, int[][] queries) {
         long[][] tree = build(nums);
         long result = 0;
-        for (int i = 0; i < queries.length; ++i) {
-            result += set(tree, queries[i][0], queries[i][1]);
+        for (int[] query : queries) {
+            result += set(tree, query[0], query[1]);
             result %= MOD;
         }
         return (int) result;