chore: commit pending changes before monorepo submodule conversion

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

cediackermann/challenges/happyNumber/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "happyNumber",
+    main_class = "cediackermann.challenges.happyNumber.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/happyNumber/Main.java

@@ -0,0 +1,8 @@
+package cediackermann.challenges.happyNumber;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        System.out.println(sol.isHappy(2));
+    }
+}

cediackermann/challenges/happyNumber/Solution.java

@@ -0,0 +1,27 @@
+package cediackermann.challenges.happyNumber;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public boolean isHappy(int n) {
+        Set<Integer> seen = new HashSet<>();
+        
+        while (n != 1 && !seen.contains(n)) {
+            seen.add(n);
+            n = getNextGen(n);
+        }
+        
+        return n == 1;
+    }
+
+    private int getNextGen(int n) {
+        int nextGen = 0;
+        while (n > 0) {
+            int digit = n % 10;
+            nextGen += digit * digit;
+            n /= 10;
+        }
+        return nextGen;
+    }
+}

cediackermann/challenges/houseRobber/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "houseRobber",
+    main_class = "cediackermann.challenges.houseRobber.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/houseRobber/Main.java

@@ -0,0 +1,11 @@
+package cediackermann.challenges.houseRobber;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        System.out.println(        
+            sol.rob(new int[]{2,7,9,3,1})
+        );        
+    }
+    
+}

cediackermann/challenges/houseRobber/Solution.java

@@ -0,0 +1,17 @@
+package cediackermann.challenges.houseRobber;
+
+class Solution {
+    public int rob(int[] nums) {
+        int n = nums.length;
+        if (n == 1) {
+            return nums[0];
+        }
+        int[] loot = new int[n];
+        loot[0] = nums[0];
+        loot[1] = Math.max(nums[0], nums[1]);
+        for (int i = 2; i < n; i++) {
+            loot[i] = Math.max(loot[i - 1], nums[i] + loot[i - 2]);
+        }
+        return loot[n - 1];
+    }
+}

cediackermann/challenges/romanToInt/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "romanToInt",
+    main_class = "cediackermann.challenges.romanToInt.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/romanToInt/Main.java

@@ -0,0 +1,11 @@
+package cediackermann.challenges.romanToInt;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        System.out.println(        
+            sol.romanToInt("MCMXCIV")
+        );        
+    }
+    
+}

cediackermann/challenges/romanToInt/Solution.java

@@ -0,0 +1,37 @@
+package cediackermann.challenges.romanToInt;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    private final Map<String, Integer> romanLetters = new HashMap<>();
+
+    public Solution() {
+        romanLetters.put("I", 1);
+        romanLetters.put("V", 5);
+        romanLetters.put("X", 10);
+        romanLetters.put("L", 50);
+        romanLetters.put("C", 100);
+        romanLetters.put("D", 500);
+        romanLetters.put("M", 1000);
+    }
+
+    public int romanToInt(String s) {
+        int solution = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i + 1 <= s.length() - 1) {
+                if (this.romanLetters.get(Character.toString(s.charAt(i))) < this.romanLetters
+                        .get(Character.toString(s.charAt(i + 1)))) {
+                    solution += this.romanLetters.get(Character.toString(s.charAt(i + 1)))
+                            - this.romanLetters.get(Character.toString(s.charAt(i)));
+                    i++;
+                } else {
+                    solution += this.romanLetters.get(Character.toString(s.charAt(i)));
+                }
+            } else {
+                solution += this.romanLetters.get(Character.toString(s.charAt(i)));
+            }
+        }
+        return solution;
+    }
+}

cediackermann/challenges/romanToInt2/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "romanToInt2",
+    main_class = "cediackermann.challenges.romanToInt2.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/romanToInt2/Main.java

@@ -0,0 +1,10 @@
+package cediackermann.challenges.romanToInt2;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        System.out.println(
+                sol.romanToInt("MCMXCIV"));
+    }
+
+}

cediackermann/challenges/romanToInt2/Solution.java

@@ -0,0 +1,31 @@
+package cediackermann.challenges.romanToInt2;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    private final Map<Character, Integer> romanLetters = new HashMap<>();
+
+    public Solution() {
+        romanLetters.put('I', 1);
+        romanLetters.put('V', 5);
+        romanLetters.put('X', 10);
+        romanLetters.put('L', 50);
+        romanLetters.put('C', 100);
+        romanLetters.put('D', 500);
+        romanLetters.put('M', 1000);
+    }
+
+    public int romanToInt(String s) {
+        int solution = 0;
+        for (int i = 0; i < s.length() - 1; i++) {
+            if (this.romanLetters.get(s.charAt(i)) < this.romanLetters.get(s.charAt(i + 1))) {
+                solution -= this.romanLetters.get(s.charAt(i));
+            } else {
+                solution += this.romanLetters.get(s.charAt(i));
+
+            }
+        }
+        return solution + romanLetters.get(s.charAt(s.length() - 1));
+    }
+}

cediackermann/challenges/romanToInt3/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "romanToInt3",
+    main_class = "cediackermann.challenges.romanToInt3.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/romanToInt3/Main.java

@@ -0,0 +1,10 @@
+package cediackermann.challenges.romanToInt3;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        System.out.println(
+                sol.romanToInt("MCMXCIV"));
+    }
+
+}

cediackermann/challenges/romanToInt3/Solution.java

@@ -0,0 +1,37 @@
+package cediackermann.challenges.romanToInt3;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    private final Map<Character, Integer> romanLetters = new HashMap<>();
+
+    public Solution() {
+        romanLetters.put('I', 1);
+        romanLetters.put('V', 5);
+        romanLetters.put('X', 10);
+        romanLetters.put('L', 50);
+        romanLetters.put('C', 100);
+        romanLetters.put('D', 500);
+        romanLetters.put('M', 1000);
+    }
+
+    public int romanToInt(String s) {
+        int solution = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i + 1 <= s.length() - 1) {
+                if (this.romanLetters.get(s.charAt(i)) < this.romanLetters
+                        .get(s.charAt(i + 1))) {
+                    solution += this.romanLetters.get(s.charAt(i + 1))
+                            - this.romanLetters.get(s.charAt(i));
+                    i++;
+                } else {
+                    solution += this.romanLetters.get(s.charAt(i));
+                }
+            } else {
+                solution += this.romanLetters.get(s.charAt(i));
+            }
+        }
+        return solution;
+    }
+}

cediackermann/challenges/twoSum/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "twoSum",
+    main_class = "cediackermann.challenges.twoSum.Main",
+    srcs = glob(["*.java"]),
+    deps = [
+    ],
+)

cediackermann/challenges/twoSum/Main.java

@@ -0,0 +1,12 @@
+package cediackermann.challenges.twoSum;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution sol = new Solution();
+        int[] nums = new int[] { 10, 20, 30, 17, 4 };
+        int[] solution = sol.getSolution(nums, 14);
+        for (int i : solution) {
+            System.out.println(i);
+        }
+    }
+}

cediackermann/challenges/twoSum/Solution.java

@@ -0,0 +1,14 @@
+package cediackermann.challenges.twoSum;
+
+public class Solution {
+    public int[] getSolution(int[] nums, int target) {
+        for (int i = 0; i <= nums.length; i++) {
+            for (int j = i + 1; j <= nums.length; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[] { i, j };
+                }
+            }
+        }
+        return new int[0];
+    }
+}

cediackermann/n1/Toilet.java

@@ -1,18 +1,256 @@
 package cediackermann.n1;
 
+import java.util.HashMap;
 import java.util.Scanner;
 
 public class Toilet {
-    public void readInput() {
+    static private Scanner in = new Scanner(System.in);
-        Scanner s = new Scanner(System.in);
+    static private HashMap<Character, String[]> characters = new HashMap<>();
-        String input = s.nextLine();
+
-        for (int i = 0; i < input.length(); i++) {
+    public Toilet(){
-            convertCharacter(input.charAt(i));
+        Toilet.characters.put('A', new String[]{
-        }
+            "   A   ",
-        System.out.println(input);
+            "  A A  ",
+            " AAAAA ",
+            " A   A ",
+            " A   A "
+        });
+    
+        Toilet.characters.put('B', new String[]{
+            " BBBBB ",
+            " B   B ",
+            " BBBBB ",
+            " B   B ",
+            " BBBBB "
+        });
+    
+        Toilet.characters.put('C', new String[]{
+            "  CCCCC",
+            " C     ",
+            " C     ",
+            " C     ",
+            "  CCCCC"
+        });
+    
+        Toilet.characters.put('D', new String[]{
+            " DDDD  ",
+            " D   D ",
+            " D   D ",
+            " D   D ",
+            " DDDD  "
+        });
+    
+        Toilet.characters.put('E', new String[]{
+            " EEEEE ",
+            " E     ",
+            " EEEE  ",
+            " E     ",
+            " EEEEE "
+        });
+    
+        Toilet.characters.put('F', new String[]{
+            " FFFFF ",
+            " F     ",
+            " FFFF  ",
+            " F     ",
+            " F     "
+        });
+    
+        Toilet.characters.put('G', new String[]{
+            "  GGGGG",
+            " G     ",
+            " G  GG ",
+            " G   G ",
+            "  GGGG "
+        });
+    
+        Toilet.characters.put('H', new String[]{
+            " H   H ",
+            " H   H ",
+            " HHHHH ",
+            " H   H ",
+            " H   H "
+        });
+    
+        Toilet.characters.put('I', new String[]{
+            " IIIII ",
+            "   I   ",
+            "   I   ",
+            "   I   ",
+            " IIIII "
+        });
+    
+        Toilet.characters.put('J', new String[]{
+            " JJJJJ ",
+            "     J ",
+            "     J ",
+            " J   J ",
+            "  JJJ  "
+        });
+    
+        Toilet.characters.put('K', new String[]{
+            " K   K ",
+            " K  K  ",
+            " KKK   ",
+            " K  K  ",
+            " K   K "
+        });
+    
+        Toilet.characters.put('L', new String[]{
+            " L     ",
+            " L     ",
+            " L     ",
+            " L     ",
+            " LLLLL "
+        });
+    
+        Toilet.characters.put('M', new String[]{
+            " M   M ",
+            " MM MM ",
+            " M M M ",
+            " M   M ",
+            " M   M "
+        });
+    
+        Toilet.characters.put('N', new String[]{
+            " N   N ",
+            " NN  N ",
+            " N N N ",
+            " N  NN ",
+            " N   N "
+        });
+    
+        Toilet.characters.put('O', new String[]{
+            "  OOO  ",
+            " O   O ",
+            " O   O ",
+            " O   O ",
+            "  OOO  "
+        });
+    
+        Toilet.characters.put('P', new String[]{
+            " PPPPP ",
+            " P   P ",
+            " PPPPP ",
+            " P     ",
+            " P     "
+        });
+    
+        Toilet.characters.put('Q', new String[]{
+            "  QQQ  ",
+            " Q   Q ",
+            " Q   Q ",
+            " Q  QQ ",
+            "  QQQQ "
+        });
+    
+        Toilet.characters.put('R', new String[]{
+            " RRRRR ",
+            " R   R ",
+            " RRRRR ",
+            " R  R  ",
+            " R   R "
+        });
+    
+        Toilet.characters.put('S', new String[]{
+            "  SSSSS",
+            " S     ",
+            "  SSS  ",
+            "     S ",
+            " SSSSS "
+        });
+    
+        Toilet.characters.put('T', new String[]{
+            " TTTTT ",
+            "   T   ",
+            "   T   ",
+            "   T   ",
+            "   T   "
+        });
+    
+        Toilet.characters.put('U', new String[]{
+            " U   U ",
+            " U   U ",
+            " U   U ",
+            " U   U ",
+            "  UUU  "
+        });
+    
+        Toilet.characters.put('V', new String[]{
+            " V   V ",
+            " V   V ",
+            " V   V ",
+            "  V V  ",
+            "   V   "
+        });
+    
+        Toilet.characters.put('W', new String[]{
+            " W   W ",
+            " W   W ",
+            " W W W ",
+            " WW WW ",
+            " W   W "
+        });
+    
+        Toilet.characters.put('X', new String[]{
+            " X   X ",
+            "  X X  ",
+            "   X   ",
+            "  X X  ",
+            " X   X "
+        });
+    
+        Toilet.characters.put('Y', new String[]{
+            " Y   Y ",
+            "  Y Y  ",
+            "   Y   ",
+            "   Y   ",
+            "   Y   "
+        });
+    
+        Toilet.characters.put('Z', new String[]{
+            " ZZZZZ ",
+            "    Z  ",
+            "   Z   ",
+            "  Z    ",
+            " ZZZZZ "
+        });
     }
 
-    private void convertCharacter(Character c) {
+    public void readInput() {
-        System.out.println(c);
+        String input = Toilet.in.nextLine();
+        StringBuilder line1 = new StringBuilder();
+        StringBuilder line2 = new StringBuilder();
+        StringBuilder line3 = new StringBuilder();
+        StringBuilder line4 = new StringBuilder();
+        StringBuilder line5 = new StringBuilder();
+        for (int i = 0; i < input.length(); i++) {
+            convertCharacter(input.charAt(i), line1, line2, line3, line4, line5);
+        }
+        System.out.println(line1);
+        System.out.println(line2);
+        System.out.println(line3);
+        System.out.println(line4);
+        System.out.println(line5);
     }
+
+
+    private void convertCharacter(
+            Character c,
+            StringBuilder line1,
+            StringBuilder line2,
+            StringBuilder line3,
+            StringBuilder line4,
+            StringBuilder line5) {
+        if (!Toilet.characters.containsKey(Character.toUpperCase(c))) {
+            return;
+        }
+        String[] charArray = Toilet.characters.get(Character.toUpperCase(c));
+        line1.append(charArray[0]);
+        line2.append(charArray[1]);
+        line3.append(charArray[2]);
+        line4.append(charArray[3]);
+        line5.append(charArray[4]);
+    }
+
 }

silviobraendle/n1/CharMap.java

@@ -0,0 +1,399 @@
+package silviobraendle.n1;
+
+import static java.util.Map.entry;
+import java.util.Map;
+
+public abstract class CharMap {
+    static public final Map<Character, String[]> charMap = Map.ofEntries(
+            entry('a', new String[] {
+                    "    ",
+                    " ## ",
+                    "# # ",
+                    "### ",
+                    "    "
+            }),
+            entry('b', new String[] {
+                    "#   ",
+                    "### ",
+                    "# # ",
+                    "### ",
+                    "    "
+            }),
+            entry('c', new String[] {
+                    "    ",
+                    "### ",
+                    "#   ",
+                    "### ",
+                    "    "
+            }),
+            entry('d', new String[] {
+                    "  # ",
+                    "### ",
+                    "# # ",
+                    "### ",
+                    "    "
+            }),
+            entry('e', new String[] {
+                    "    ",
+                    "### ",
+                    "##  ",
+                    "### ",
+                    "    "
+            }),
+            entry('f', new String[] {
+                    " ## ",
+                    " #  ",
+                    "### ",
+                    " #  ",
+                    "##  "
+            }),
+            entry('g', new String[] {
+                    "    ",
+                    "### ",
+                    "# # ",
+                    " ## ",
+                    "### "
+            }),
+            entry('h', new String[] {
+                    "#   ",
+                    "### ",
+                    "# # ",
+                    "# # ",
+                    "    "
+            }),
+            entry('i', new String[] {
+                    " #  ",
+                    "    ",
+                    " #  ",
+                    " ## ",
+                    "    "
+            }),
+            entry('j', new String[] {
+                    " #  ",
+                    "    ",
+                    " #  ",
+                    " #  ",
+                    "#   "
+            }),
+            entry('k', new String[] {
+                    "#   ",
+                    "# # ",
+                    "##  ",
+                    "# # ",
+                    "    "
+            }),
+            entry('l', new String[] {
+                    " #  ",
+                    " #  ",
+                    " #  ",
+                    " ## ",
+                    "    "
+            }),
+            entry('m', new String[] {
+                    "    ",
+                    "### ",
+                    "### ",
+                    "# # ",
+                    "    "
+            }),
+            entry('n', new String[] {
+                    "    ",
+                    "##  ",
+                    "# # ",
+                    "# # ",
+                    "    "
+            }),
+            entry('o', new String[] {
+                    "    ",
+                    "### ",
+                    "# # ",
+                    "### ",
+                    "    "
+            }),
+            entry('p', new String[] {
+                    "    ",
+                    "### ",
+                    "# # ",
+                    "### ",
+                    "#   "
+            }),
+            entry('q', new String[] {
+                    "    ",
+                    "### ",
+                    "# # ",
+                    "### ",
+                    "  # "
+            }),
+            entry('r', new String[] {
+                    "    ",
+                    "### ",
+                    "#   ",
+                    "#   ",
+                    "    "
+            }),
+            entry('s', new String[] {
+                    "    ",
+                    " ## ",
+                    " #  ",
+                    "##  ",
+                    "    "
+            }),
+            entry('t', new String[] {
+                    " #  ",
+                    "### ",
+                    " #  ",
+                    " ## ",
+                    "    "
+            }),
+            entry('u', new String[] {
+                    "    ",
+                    "# # ",
+                    "# # ",
+                    "### ",
+                    "    "
+            }),
+            entry('v', new String[] {
+                    "    ",
+                    "# # ",
+                    "# # ",
+                    " #  ",
+                    "    "
+            }),
+            entry('w', new String[] {
+                    "    ",
+                    "# # ",
+                    "### ",
+                    "### ",
+                    "    "
+            }),
+            entry('x', new String[] {
+                    "    ",
+                    "# # ",
+                    " #  ",
+                    "# # ",
+                    "    "
+            }),
+            entry('y', new String[] {
+                    "    ",
+                    "# # ",
+                    "### ",
+                    "  # ",
+                    "### "
+            }),
+            entry('z', new String[] {
+                    "    ",
+                    "##  ",
+                    " #  ",
+                    " ## ",
+                    "    "
+            }),
+
+            entry('A', new String[] {
+                    " #  ",
+                    "# # ",
+                    "### ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('B', new String[] {
+                    "##  ",
+                    "# # ",
+                    "##  ",
+                    "# # ",
+                    "##  "
+                }),
+
+            entry('C', new String[] {
+                    " ## ",
+                    "#   ",
+                    "#   ",
+                    "#   ",
+                    " ## "
+                }),
+
+            entry('D', new String[] {
+                    "##  ",
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    "##  "
+                }),
+
+            entry('E', new String[] {
+                    "### ",
+                    "#   ",
+                    "##  ",
+                    "#   ",
+                    "### "
+                }),
+
+            entry('F', new String[] {
+                    "### ",
+                    "#   ",
+                    "##  ",
+                    "#   ",
+                    "#   "
+                }),
+
+            entry('G', new String[] {
+                    " ## ",
+                    "#   ",
+                    "# # ",
+                    "# # ",
+                    " ## "
+                }),
+
+            entry('H', new String[] {
+                    "# # ",
+                    "# # ",
+                    "### ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('I', new String[] {
+                    "### ",
+                    " #  ",
+                    " #  ",
+                    " #  ",
+                    "### "
+                }),
+
+            entry('J', new String[] {
+                    " ## ",
+                    "  # ",
+                    "  # ",
+                    "# # ",
+                    " #  "
+                }),
+
+            entry('K', new String[] {
+                    "# # ",
+                    "# # ",
+                    "##  ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('L', new String[] {
+                    "#   ",
+                    "#   ",
+                    "#   ",
+                    "#   ",
+                    "### "
+                }),
+
+            entry('M', new String[] {
+                    "# # ",
+                    "### ",
+                    "### ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('N', new String[] {
+                    "### ",
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('O', new String[] {
+                    " #  ",
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    " #  "
+                }),
+
+            entry('P', new String[] {
+                    "##  ",
+                    "# # ",
+                    "##  ",
+                    "#   ",
+                    "#   "
+                }),
+
+            entry('Q', new String[] {
+                    " #  ",
+                    "# # ",
+                    "# # ",
+                    " ## ",
+                    "  # "
+                }),
+
+            entry('R', new String[] {
+                    "##  ",
+                    "# # ",
+                    "##  ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('S', new String[] {
+                    " ## ",
+                    "#   ",
+                    " #  ",
+                    "  # ",
+                    "##  "
+                }),
+
+            entry('T', new String[] {
+                    "### ",
+                    " #  ",
+                    " #  ",
+                    " #  ",
+                    " #  "
+                }),
+
+            entry('U', new String[] {
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    "### "
+                }),
+
+            entry('V', new String[] {
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    "# # ",
+                    " #  "
+                }),
+
+            entry('W', new String[] {
+                    "# # ",
+                    "# # ",
+                    "### ",
+                    "### ",
+                    "# # "
+                }),
+
+            entry('X', new String[] {
+                    "# # ",
+                    "# # ",
+                    " #  ",
+                    "# # ",
+                    "# # "
+                }),
+
+            entry('Y', new String[] {
+                    "# # ",
+                    "# # ",
+                    " #  ",
+                    " #  ",
+                    " #  "
+                }),
+
+            entry('Z', new String[] {
+                    "### ",
+                    "  # ",
+                    " #  ",
+                    "#   ",
+                    "### "
+                })
+        );
+}

silviobraendle/n1/Main.java

@@ -1,7 +1,9 @@
 package silviobraendle.n1;
 
-class Main {
+public class Main {
+
     public static void main(String[] args) {
-        System.out.println("Hello, World!"); 
+        Toilet toilet = new Toilet();
+        toilet.readInput();
     }
 }

silviobraendle/n1/Toilet.java

@@ -0,0 +1,42 @@
+package silviobraendle.n1;
+
+import java.util.Scanner;
+
+public class Toilet {
+    static private final Scanner in = new Scanner(System.in);
+
+    public void readInput() {
+        String input = in.nextLine();
+        StringBuilder line1 = new StringBuilder();
+        StringBuilder line2 = new StringBuilder();
+        StringBuilder line3 = new StringBuilder();
+        StringBuilder line4 = new StringBuilder();
+        StringBuilder line5 = new StringBuilder();
+        for (int i = 0; i < input.length(); i++) {
+            convertCharacter(input.charAt(i), line1, line2, line3, line4, line5);
+        }
+        System.out.println(line1);
+        System.out.println(line2);
+        System.out.println(line3);
+        System.out.println(line4);
+        System.out.println(line5);
+    }
+
+    private void convertCharacter(
+            Character c,
+            StringBuilder line1,
+            StringBuilder line2,
+            StringBuilder line3,
+            StringBuilder line4,
+            StringBuilder line5) {
+        if (!CharMap.charMap.containsKey(c)) {
+            return;
+        }
+        String[] charArray = CharMap.charMap.get(c);
+        line1.append(charArray[0]);
+        line2.append(charArray[1]);
+        line3.append(charArray[2]);
+        line4.append(charArray[3]);
+        line5.append(charArray[4]);
+    }
+}

silviobraendle/trapping_rain_water_ii/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "trapping_rain_water_ii",
+    srcs = glob(["*.java"]),
+    main_class = "silviobraendle.trapping_rain_water_ii.Main",
+    deps = [
+    ],
+)

silviobraendle/trapping_rain_water_ii/Main.java

@@ -0,0 +1,31 @@
+package silviobraendle.trapping_rain_water_ii;
+
+public class Main {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[][] heightMap = {
+                { 122, 120, 51, 39, 14, 63, 28, 100, 84, 37, 56, 19, 127, 93, 58, 16, 97, 78, 46, 31 },
+                { 91, 14, 51, 35, 75, 47, 30, 83, 124, 100, 8, 81, 78, 53, 28, 115, 111, 150, 80, 83 },
+                { 69, 135, 31, 76, 35, 111, 70, 75, 47, 49, 74, 126, 111, 4, 83, 17, 111, 74, 108, 141 },
+                { 56, 35, 144, 42, 62, 64, 22, 46, 109, 123, 115, 32, 96, 133, 71, 67, 136, 83, 48, 115 },
+                { 30, 31, 66, 14, 105, 116, 31, 148, 77, 94, 126, 111, 87, 140, 124, 25, 21, 84, 38, 49 },
+                { 84, 72, 128, 120, 54, 78, 67, 121, 138, 85, 63, 8, 144, 138, 68, 119, 123, 27, 6, 128 },
+                { 119, 4, 3, 118, 31, 68, 86, 32, 68, 42, 101, 72, 14, 121, 61, 133, 78, 95, 6, 15 },
+                { 99, 113, 31, 74, 119, 35, 133, 41, 43, 48, 100, 27, 45, 81, 114, 141, 128, 64, 91, 36 },
+                { 61, 91, 130, 133, 130, 91, 127, 52, 33, 41, 46, 88, 55, 71, 77, 45, 92, 49, 94, 9 },
+                { 65, 94, 148, 49, 36, 24, 89, 73, 15, 98, 104, 69, 42, 75, 49, 26, 98, 144, 82, 132 },
+                { 26, 79, 22, 45, 13, 138, 61, 126, 128, 25, 19, 25, 136, 50, 83, 145, 34, 72, 60, 25 },
+                { 35, 4, 39, 104, 63, 61, 62, 20, 53, 138, 24, 107, 138, 134, 0, 27, 53, 13, 40, 83 },
+                { 36, 83, 15, 117, 81, 101, 32, 95, 1, 44, 0, 141, 89, 14, 128, 68, 95, 2, 15, 133 },
+                { 108, 85, 57, 58, 19, 68, 141, 132, 100, 78, 101, 86, 135, 91, 15, 36, 94, 71, 139, 115 },
+                { 9, 107, 26, 13, 93, 147, 119, 124, 123, 45, 68, 53, 140, 87, 135, 34, 45, 120, 36, 127 },
+                { 44, 36, 38, 147, 48, 10, 60, 32, 51, 6, 78, 137, 1, 130, 132, 80, 17, 132, 12, 41 },
+                { 52, 77, 7, 135, 107, 134, 26, 150, 95, 76, 95, 52, 74, 23, 50, 72, 110, 4, 1, 62 },
+                { 73, 66, 132, 88, 147, 74, 51, 146, 84, 73, 87, 94, 58, 120, 52, 0, 58, 10, 41, 59 },
+                { 60, 18, 49, 101, 7, 2, 80, 147, 101, 26, 3, 9, 4, 13, 118, 54, 50, 106, 1, 75 },
+                { 77, 98, 112, 92, 55, 3, 66, 133, 18, 39, 83, 117, 12, 131, 28, 4, 116, 101, 22, 70 },
+        };
+        int answer = solution.trapRainWater(heightMap);
+        System.out.println(answer);
+    }
+}

silviobraendle/trapping_rain_water_ii/Solution.java

@@ -0,0 +1,96 @@
+package silviobraendle.trapping_rain_water_ii;
+
+public class Solution {
+    public int trapRainWater(int[][] heightMap) {
+        int m = heightMap.length;
+        int n = heightMap[0].length;
+
+        int maxLevel = findMaxLevel(heightMap);
+
+        int waterSum = 0;
+
+        for (int level = maxLevel; level > 0; level--) {
+            boolean[][] visited = new boolean[m][n];
+            for (int i = 0; i < m; i++) {
+                findPath(i, 0, visited, heightMap, level);
+                findPath(i, n - 1, visited, heightMap, level);
+            }
+            for (int j = 1; j < n - 1; j++) {
+                findPath(0, j, visited, heightMap, level);
+                findPath(m - 1, j, visited, heightMap, level);
+            }
+
+            waterSum += sumLevel(heightMap, level, visited);
+        }
+
+        return waterSum;
+    }
+
+    private int sumLevel(int[][] heightMap, int level, boolean[][] visited) {
+        int m = heightMap.length;
+        int n = heightMap[0].length;
+
+        int levelSum = 0;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (visited[i][j]) {
+                    continue;
+                }
+
+                if (heightMap[i][j] >= level) {
+                    continue;
+                }
+
+                levelSum++;
+            }
+        }
+        
+        return levelSum;
+    }
+
+    private void findPath(int i, int j, boolean[][] visited, int[][] heightMap, int level) {
+        int m = visited.length;
+        int n = visited[0].length;
+
+        if (!isInBounds(i, j, m, n)) {
+            return;
+        }
+
+        if (visited[i][j]) {
+            return;
+        }
+
+        if (heightMap[i][j] >= level) {
+            return;
+        }
+
+        visited[i][j] = true;
+
+        findPath(i + 1, j, visited, heightMap, level); // inc i
+        findPath(i - 1, j, visited, heightMap, level); // dec i
+        findPath(i, j + 1, visited, heightMap, level); // inc j
+        findPath(i, j - 1, visited, heightMap, level); // dec j
+    }
+
+    private boolean isInBounds(int i, int j, int m, int n) {
+        return i >= 0 && i < m && j >= 0 && j < n;
+    }
+
+    private int findMaxLevel(int[][] heightMap) {
+        int m = heightMap.length;
+        int n = heightMap[0].length;
+
+        int maxLevel = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                int value = heightMap[i][j];
+                if (value > maxLevel) {
+                    maxLevel = value;
+                }
+            }
+        }
+
+        return maxLevel;
+    }
+}

silviobraendle/two_sum/BUILD

@@ -0,0 +1,11 @@
+load("@rules_java//java:defs.bzl", "java_binary")
+
+package(default_visibility = ["//visibility:public"])
+
+java_binary(
+    name = "two_sum",
+    srcs = glob(["*.java"]),
+    main_class = "silviobraendle.two_sum.Main",
+    deps = [
+    ],
+)

silviobraendle/two_sum/Main.java

@@ -0,0 +1,32 @@
+package silviobraendle.two_sum;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Main {
+    public static void main(String[] args) {
+        int[] nums = {
+            2, 7, 11, 15
+        };
+        int target = 9;
+
+        int[] indices = twoSum(nums, target);
+        
+        System.out.println(indices[0]);
+        System.out.println(indices[1]);
+    }
+
+    public static int[] twoSum(int nums[], int target) {
+        Map<Integer, Integer> foundIndices = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int value = nums[i];
+            int complement = target-value;
+            Integer indexOfComplement = foundIndices.get(complement);
+            if (indexOfComplement != null) {
+                return new int[] {indexOfComplement, i};
+            }
+            foundIndices.put(value, i);
+        }
+        throw new Error();
+    }
+}