Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- faecher:informatik:oberstufe:java:aoc:aco2023:day19:start [21.12.2023 19:25] – angelegt Marco Kuemmel
+++ faecher:informatik:oberstufe:java:aoc:aco2023:day19:start [22.12.2023 23:26] (aktuell) – Marco Kuemmel
@@ Zeile 112: / Zeile 112: @@
     return summe;
+}
+</code>
+++++
+===== Lösungsvorschlag Teil 2 =====
+  * Gehe rückwärts vor: suche alle ''A''(accepted) in den Workflows/Regeln und gehe von dort aus die Regeln rückwärts durch, bis du bei der Regel "in" gelandet bist. Merke dir auf dem Weg dahin alle größer/kleiner-Vergleiche. Setze anhand dieser Vergleiche die Maximums- und Minimumsgrenzen, um die erlaubte Differenz pro x/m/a/s zu bilden.
+++++ Lösungsvorschlag Teil 2 |
+<code java>
+private ArrayList<ArrayList<String[]>> allPaths;
+public long partTwo() {
+    workflow = new HashMap<String, Workflow>();
+    // lies nur die workflows ein
+    for (String line: inputLines) {
+        if (line.length() == 0) {
+            continue;
+        } else if (!line.startsWith("{")) {
+            workflow.put(line.split("\\{")[0], new Workflow(line.split("\\{")[1].split("\\}")[0]));
+        }
+    }
+    Workflow start = workflow.get("in");
+    allPaths = new ArrayList();
+    ArrayList<String[]> path = new ArrayList<String[]>();
+    getPathsToA(start, 0, path);
+    long ergebnis = 0;
+    for (ArrayList<String[]> p: allPaths) {
+        int[][] range = new int[4][2];
+        for (int i = 0; i < 4; i++) {
+            range[i][0] = 1;
+            range[i][1] = 4000;
+        }
+        for (String[] r: p) {
+            int comp;
+            if (r[1].equals(">") && Integer.parseInt(r[2]) > range[Integer.parseInt(r[0])][0]) {
+                range[Integer.parseInt(r[0])][0] = Integer.parseInt(r[2]);
+            } else if (r[1].equals("<") && Integer.parseInt(r[2]) < range[Integer.parseInt(r[0])][1]) {
+                range[Integer.parseInt(r[0])][1] = Integer.parseInt(r[2]);
+            }
+        }
+        long teilergebnis = 1;
+        for (int i = 0; i < 4; i++) {
+            teilergebnis *= range[i][1] - range[i][0] + 1;
+        }
+        ergebnis += teilergebnis;
+    }
+    return ergebnis;
+}
+private void getPathsToA(Workflow w, int step, ArrayList<String[]> path) {
+    if (step >= w.getSteps().size()) {
+        String nachfolger = w.getOtherwise();
+        if (nachfolger.equals("A")) {
+            allPaths.add(path);
+        } else if (nachfolger.equals("R")) {
+            // do nothing
+        } else {
+            getPathsToA(workflow.get(nachfolger), 0, (ArrayList<String[]>)path.clone());
+        }
+        return;
+    }
+    String[] stepX = w.getSteps().get(step);
+    // annahme, es sei false -> gehe zum nächsten step
+    ArrayList<String[]> p1 = (ArrayList<String[]>)path.clone();
+    //invertieren
+    if (stepX[1].equals("<")) {
+        p1.add(new String[]{stepX[0], ">", stepX[2]});
+    } else if (stepX[1].equals(">")) {
+        p1.add(new String[]{stepX[0], "<", stepX[2]});
+    }
+    getPathsToA(w, step + 1, p1);
+    // annahme, es sei true -> gehe zum neuen workflow
+    if (stepX[1].equals("<")) {
+        path.add(new String[]{stepX[0], "<", String.valueOf(Integer.parseInt(stepX[2])-1)});
+    } else if (stepX[1].equals(">")) {
+        path.add(new String[]{stepX[0], ">", String.valueOf(Integer.parseInt(stepX[2])+1)});
+    }
+    if (stepX[3].equals("A")) {
+        allPaths.add(path);
+        return;
+    } else if (stepX[3].equals("R")) {
+        return;
+    }
+    getPathsToA(workflow.get(stepX[3]), 0, path);
 }
 </code>