Prepare for publication

Author: spannm

.gitignore

@@ -14,3 +14,4 @@
 .~lock*
 *.kate-swp
 **/Migrate*.java
+**/RenameMethodParms.java

src/main/java/io/github/spannm/leetcode/LeetcodeProblem.java

@@ -2,35 +2,9 @@
 
 public abstract class LeetcodeProblem {
 
-    private final boolean doOutput;
-
-    protected LeetcodeProblem() {
-        this(true);
-    }
-
-    protected LeetcodeProblem(boolean _doOutput) {
-        doOutput = _doOutput;
-    }
-
-    public final boolean doOutput() {
-        return doOutput;
-    }
-
-    public final void printf(String _format, Object... _args) {
-        if (doOutput) {
-            System.out.printf(_format, _args);
-        }
-    }
-
-    public final void println(Object _arg) {
-        if (doOutput) {
-            System.out.println(_arg);
-        }
-    }
-
     @Override
     public String toString() {
-        return getClass().getSimpleName() + "[]";
+        return String.format("%s[]", getClass().getSimpleName());
     }
 
     public static String asString(Object _o) {

src/main/java/io/github/spannm/leetcode/LeetcodeSqlProblem.java

@@ -5,7 +5,6 @@ public abstract class LeetcodeSqlProblem extends LeetcodeProblem {
     private final String sql;
 
     protected LeetcodeSqlProblem(String _sql) {
-        super(true);
         sql = _sql;
     }
 

src/main/java/io/github/spannm/leetcode/dep/Sudoku.java

@@ -37,12 +37,7 @@ public boolean solve(Board _board) {
 
                 List<Field> fields = _board.boxes.stream().flatMap(b -> b.getFields().stream()).toList();
 
-                // inspect field by field
-                for (Field currFld : fields) {
-                    // if (currFld.getRowNo() == 'A' && currFld.getColNo() == 1) {
-                    // doOutput(" DEBUG ");
-                    // }
-                    // doOutput(" %s%n", currFld);
+                for (Field currFld : fields) { // inspect field by field
 
                     // check all remaining possible values whether one is only possible in this field
                     for (Area area : currFld.getAreas()) {

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0001.java

@@ -2,31 +2,23 @@
 
 import io.github.spannm.leetcode.LeetcodeProblem;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * <a href="https://leetcode.com/problems/two-sum/">1. Two Sum</a>.
  */
 class Problem0001 extends LeetcodeProblem {
 
     int[] twoSum(int[] _nums, int _target) {
-        if (doOutput()) {
-            printf("Input: %s, target: %d%n", java.util.Arrays.toString(_nums), _target);
-        }
-        return impl1(_nums, _target);
-    }
-
-    int[] impl1(int[] _nums, int _target) {
-        final java.util.List<IdxAndNum> idxAndNums = new java.util.ArrayList<>();
+        List<IdxAndNum> idxAndNums = new ArrayList<>();
         for (int i = 0; i < _nums.length; i++) {
             idxAndNums.add(new IdxAndNum(i, _nums[i]));
         }
         idxAndNums.sort(java.util.Comparator.comparing(IdxAndNum::getNum).thenComparing(IdxAndNum::getIdx));
 
         final int len = idxAndNums.size();
 
-        if (doOutput()) {
-            printf("Values (%s): %s%n", len, idxAndNums);
-        }
-
         int[] result = null;
 
         for (int i1 = 0; i1 < len - 1; i1++) {
@@ -40,19 +32,14 @@ int[] impl1(int[] _nums, int _target) {
 
         }
 
-        System.err.printf("No result found! %n%n");
         return null;
     }
 
     /**
      * Calculates the sum of two values.<br>
      * If equal to {@code target}, returns their indices in an int array.
      */
-    int[] calcSum(IdxAndNum _in1, IdxAndNum _in2, int _target) {
-        if (doOutput()) {
-            printf("  Test %s + %s = %s %n%n", _in1, _in2, _target);
-        }
-
+    static int[] calcSum(IdxAndNum _in1, IdxAndNum _in2, int _target) {
         if (_in1.getNum() + _in2.getNum() == _target) {
             return new int[] {_in1.getIdx(), _in2.getIdx()};
         }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0004.java

@@ -13,20 +13,18 @@
 class Problem0004 extends LeetcodeProblem {
 
     double findMedianSortedArrays(int[] _nums1, int[] _nums2) {
-        final LinkedList<Integer> l1 = Arrays.stream(_nums1).boxed().collect(Collectors.toCollection(LinkedList::new));
-        final LinkedList<Integer> l2 = Arrays.stream(_nums2).boxed().collect(Collectors.toCollection(LinkedList::new));
+        LinkedList<Integer> l1 = Arrays.stream(_nums1).boxed().collect(Collectors.toCollection(LinkedList::new));
+        LinkedList<Integer> l2 = Arrays.stream(_nums2).boxed().collect(Collectors.toCollection(LinkedList::new));
 
         // merge sorted arrays into one
         final LinkedList<Integer> merged = new LinkedList<>();
-        // Solange noch nicht beide Listen hinzugefügt worden
         while (!l1.isEmpty() && !l2.isEmpty()) {
             if (l1.getFirst() <= l2.getFirst()) {
                 merged.addLast(l1.removeFirst());
             } else {
                 merged.addLast(l2.removeFirst());
             }
         }
-        // Füge Rest hinzu, falls etwas übrig ist.
         merged.addAll(l1);
         merged.addAll(l2);
 
@@ -46,15 +44,9 @@ List<Integer> merge(LinkedList<Integer> _l1, LinkedList<Integer> _l2) {
                 merged.addLast(_l2.removeFirst());
             }
         }
-        // Füge Rest hinzu, falls etwas übrig ist.
         merged.addAll(_l1);
         merged.addAll(_l2);
         return merged;
     }
 
-    public void printFindMedianSortedArrays(int[] _nums1, int[] _nums2) {
-        double result = findMedianSortedArrays(_nums1, _nums2);
-        printf("%s and %s => %s%n", asString(_nums1), asString(_nums2), result);
-    }
-
 }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0006.java

@@ -23,7 +23,6 @@ String convert(String _s, int _numRows) {
 
         for (int i = 0; i < arr.length; i++) {
             sbs.get(z).append(arr[i]);
-            printf("i=%s, z=%s, v=%s %s %n", i, z, arr[i], up ? "up" : "down");
             if (up) {
                 z++;
             } else {
@@ -34,10 +33,6 @@ String convert(String _s, int _numRows) {
             }
         }
 
-        if (doOutput()) {
-            sbs.forEach(this::println);
-        }
-
         return sbs.stream().map(StringBuilder::toString).collect(Collectors.joining(""));
     }
 

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0008.java

@@ -5,7 +5,6 @@
 class Problem0008 extends LeetcodeProblem {
 
     int myAtoi(String _s) {
-        printf("Input: %s %n", _s);
         if (_s == null || _s.isEmpty()) {
             return 0;
         }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0017.java

@@ -68,7 +68,6 @@ public List<String> letterCombinations2(String _digits) {
         Set<String> combinations = new LinkedHashSet<>();
 
         generatePermutations(lol, combinations, 0, "");
-        printf("Combinations: %s %n", combinations);
 
         return new ArrayList<>(combinations);
     }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0019.java

@@ -9,7 +9,6 @@
 class Problem0019 extends LeetcodeProblem {
 
     ListNode removeNthFromEnd(ListNode _head, int _n) {
-        printf("Input: %s, n=%d%n", _head, _n);
         ListNode node = _head;
 
         int count = 1;
@@ -25,7 +24,6 @@ ListNode removeNthFromEnd(ListNode _head, int _n) {
         }
 
         int position = count - _n + 1; // position to remove
-        printf("Position of node to remove: %d (%d from end)%n", position, _n);
         if (position == 1) {
             _head = _head.next;
             return _head;

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0035.java

@@ -12,7 +12,6 @@ int searchInsert(int[] _nums, int _target) {
     }
 
     int searchInsert1(int[] _nums, int _target, int _fromIndex, int _toIndex) {
-        printf("%s, target %d, from %d to %d %n", java.util.Arrays.toString(_nums), _target, _fromIndex, _toIndex);
         if (_target < _nums[_fromIndex]) {
             return _fromIndex;
         } else if (_target > _nums[_toIndex]) {

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0037.java

@@ -16,13 +16,6 @@ void solveSudoku(char[][] _board) {
         Sudoku.Board b = new Sudoku.Board(getClass().getSimpleName(), _board);
         solver.solve(b);
         b.updateBoardMatrix(_board);
-
-        printf("Board one-liner: %s%n", b.toString("", ""));
-
-        for (Sudoku.Field f : b.getEmptyFields()) {
-            printf("  Solved: %s%n", f);
-        }
-
     }
 
 }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0057.java

@@ -12,7 +12,6 @@
 class Problem0057 extends LeetcodeProblem {
 
     int[][] insert(int[][] _intervals, int[] _newInterval) {
-        printf("intervals: %s, new: %s%n", asString(_intervals), asString(_newInterval));
 
         int arrLen = _intervals == null ? 0 : _intervals.length;
         if (arrLen == 0) {
@@ -39,7 +38,6 @@ int[][] insert(int[][] _intervals, int[] _newInterval) {
         int[] mergeInterval = null;
         for (int i = 0; i < arrLen; i++) {
             int[] currInterval = _intervals[i];
-            printf("Current: %s%n", asString(currInterval));
 
             if (_newInterval[0] >= currInterval[0] && _newInterval[1] <= currInterval[1]) { // within
                 return _intervals;
@@ -57,14 +55,12 @@ int[][] insert(int[][] _intervals, int[] _newInterval) {
                 }
             } else if (mergeInterval != null) { // currently merging
                 if (mergeInterval[1] < currInterval[0]) {
-                    printf("Merge done, end interval: %s%n", mergeInterval[1]);
                     intervalList.add(mergeInterval);
                     intervalList.addAll(List.of(_intervals).subList(i, arrLen));
                     break;
                 } else if (i == arrLen - 1) { // last
                     mergeInterval[1] = Math.max(mergeInterval[1], currInterval[1]);
                     intervalList.add(mergeInterval);
-                    printf("Merge done, end interval: %s%n", mergeInterval[1]);
                     break;
                 } else {
                     mergeInterval[1] = Math.max(mergeInterval[1], currInterval[1]);
@@ -73,17 +69,14 @@ int[][] insert(int[][] _intervals, int[] _newInterval) {
             } else {
                 mergeInterval = new int[] {Math.min(currInterval[0], _newInterval[0]), Math.max(currInterval[1], _newInterval[1])
                 };
-                printf("Merging, begin interval: %s%n", mergeInterval[0]);
                 if (i == arrLen - 1) { // last
                     intervalList.add(mergeInterval);
-                    printf("Merge done, end interval: %s%n", mergeInterval[1]);
                     break;
                 }
             }
 
         }
         _intervals = intervalList.toArray(new int[0][]);
-        printf("Returning %s%n", asString(_intervals));
         return _intervals;
     }
 

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0062.java

@@ -15,7 +15,6 @@ int uniquePaths(final int _rows, final int _cols) {
 
         for (int r = 1; r < _rows; r++) {
             for (int c = 1; c < _cols; c++) {
-                // printf("%d/%d%n", r, c);
                 dp[r][c] = dp[r - 1][c] + dp[r][c - 1];
             }
         }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0077.java

@@ -16,7 +16,6 @@ class Problem0077 extends LeetcodeProblem {
      * @return all possible combinations
      */
     public List<List<Integer>> combine(int _n, int _k) {
-        // printf("n=%d, k=%d%n", n, k);
         if (_k > _n || _k < 0) {
             return List.of();
         } else if (_k == 0) {
@@ -26,13 +25,11 @@ public List<List<Integer>> combine(int _n, int _k) {
         }
 
         List<List<Integer>> res = combine(_n - 1, _k - 1);
-        // printf("res 1=%s%n", res);
         // if at this point res is empty, it can only be that k-1 == 0,
         // n-1 < k-1 is not possible since n>=k (if n<k, the function would have already returned at an early point)
         for (List<Integer> list : res) {
             list.add(_n);
         }
-        // printf("res 2=%s%n", res);
         res.addAll(combine(_n - 1, _k));
         return res;
     }

src/main/java/io/github/spannm/leetcode/lc0/lc0000/Problem0087.java

@@ -140,15 +140,4 @@ static String scramble(ThreadLocalRandom _rand, String _str) {
         }
     }
 
-    public static void main(String[] _args) {
-        String str = "great";
-        int attempts = 10_000;
-        Set<String> results = new HashSet<>();
-        // IntStream.range(0, attempts).forEach(i -> System.out.printf("Scramble %s -> %s %n", str, scramble(str)));
-        ThreadLocalRandom rand = ThreadLocalRandom.current();
-        IntStream.range(0, attempts).forEach(i -> results.add(scramble(rand, str)));
-        System.out.printf("%d results:%n%s%n", results.size(), String.join("\n", results));
-        // results.stream().forEach(System.out::println);
-    }
-
 }

src/main/java/io/github/spannm/leetcode/lc0/lc0100/Problem0131.java

@@ -4,20 +4,14 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * <a href="https://leetcode.com/problems/palindrome-partitioning/">131. Palindrome Partitioning</a>.
  */
 class Problem0131 extends LeetcodeProblem {
 
     List<List<String>> partition(String _str) {
-        List<List<String>> result = dfs(0, new ArrayList<>(), new ArrayList<>(), _str);
-        printf("\"%s; %s,\"%n", _str, result.stream()
-            .map(List::stream)
-            .map(s -> '[' + s.collect(Collectors.joining(",")) + ']')
-            .collect(Collectors.joining(", ")));
-        return result;
+        return dfs(0, new ArrayList<>(), new ArrayList<>(), _str);
     }
 
     static List<List<String>> dfs(int _start, List<List<String>> _result, List<String> _currentList, String _str) {

src/main/java/io/github/spannm/leetcode/lc0/lc0100/Problem0136.java

@@ -26,17 +26,15 @@ int singleNumber2(int[] _nums) {
         return _nums[len - 1];
     }
 
-    public int singleNumber(final int[] _nums) {
-        // printf("Input: %s %n", Arrays.toString(_nums));
-        final int len = _nums.length;
+    int singleNumber(int[] _nums) {
+        int len = _nums.length;
         if (len == 1) {
             return _nums[0];
         }
 
         int n = _nums[0];
         for (int i = 1; i < len; i++) {
             n = n ^ _nums[i]; // bitwise exclusive OR
-            // printf("%d -> %d %n", _nums[i], n);
         }
         return n;
     }

src/main/java/io/github/spannm/leetcode/lc0/lc0100/Problem0137.java

@@ -16,7 +16,6 @@ int singleNumber2(final int[] _nums) {
         }
 
         Arrays.sort(_nums);
-        printf("Input: %s %n", Arrays.toString(_nums));
 
         for (int i = 1; i < len; i += 3) {
             if (_nums[i] - _nums[i - 1] != 0) {

src/main/java/io/github/spannm/leetcode/lc0/lc0100/Problem0142.java

@@ -9,7 +9,6 @@
 class Problem0142 extends LeetcodeProblem {
 
     ListNode detectCycle(ListNode _head) {
-        printf("Head: %s%n", _head);
         ListNode fast = _head;
         ListNode slow = _head;