Messy initial solution.

README.md

@@ -1,17 +1,13 @@
-# Advent of Code 2022 - assignment 1
-This is the first assignment for Advent of Code 2022. The provided solution uses 3 variables: currentScore, highestCalorieScore, currentElf, highestElf.
-It is complexity O(n+m) since it loops through every line exactly once (n) and the iterates for recalculating highscore (m).
-The GUI also provides a checkbox to toggle top3 or top1.
+# Advent of Code 2022 - Assignment5 javascript
+This repository contains answers to the assignments of Advent of Coding 2022
 
-## Solution description
-Every iteration the score is added to the currentScore. If an empty line is detected we check if currentscore exceeds one of our highestCalorieScore, if yes we assign currentElf to highestElf.
-
-## references
-- https://adventofcode.com/2022/day/1
-- https://stackoverflow.com/questions/17595361/how-to-read-text-line-by-line-in-a-html-text-area
-- https://bobbyhadz.com/blog/javascript-get-value-of-textarea
-- https://stackoverflow.com/questions/154059/how-do-i-check-for-an-empty-undefined-null-string-in-javascript
-- https://www.geeksforgeeks.org/convert-a-string-to-an-integer-in-javascript/#:~:text=In%20JavaScript%20parseInt()%20function,argument%20of%20parseInt()%20function.
-- https://stackoverflow.com/questions/1230233/how-to-find-the-sum-of-an-array-of-numbers
-- https://www.w3schools.com/js/js_break.asp
-- https://2ality.com/2018/12/creating-arrays.html
+## References
+- https://www.w3schools.com/jsref/jsref_includes.asp
+- https://stackoverflow.com/questions/10261986/how-to-detect-string-which-contains-only-spaces
+- https://www.w3schools.com/jsref/jsref_indexof.asp
+- https://stackoverflow.com/questions/8073673/how-can-i-add-new-array-elements-at-the-beginning-of-an-array-in-javascript
+- https://stackoverflow.com/questions/966225/how-can-i-create-a-two-dimensional-array-in-javascript
+- https://www.w3schools.com/jsref/jsref_ceil.asp
+- https://stackoverflow.com/questions/30561056/console-log-a-multi-dimensional-array
+- https://teamtreehouse.com/community/removing-more-than-1-element-using-pop-and-shift-method
+- https://stackoverflow.com/questions/14723848/push-multiple-elements-to-array

index.html

@@ -9,7 +9,7 @@
     <p>Assignment:</p>
     <textarea rows="15" cols="50" id="assignment"></textarea>
     <input type="checkbox" id="algorithm"/>
-    <label for="algorithm">TOP 3</label> 
+    <label for="algorithm">All containers at once?</label>
 
     <p>Answer:</p>
     <div id="answer">Provide input first</div>

script.js

@@ -1,9 +1,11 @@
 const ASSIGNMENT = 'assignment';
 const ANSWER = 'answer';
 const ALGORITHM_CHECKBOX = 'algorithm';
+const CONTAINER_NULL_CHARACTER=0;
+const INSTRUCTION_FROM='from';
+const INSTRUCTION_MOVE='move';
+const INSTRUCTION_TO='to';
 const NEWLINE_CHARACTER = '\n';
-const TOP_1 = 1;
-const TOP_N = 3;
 
 /**
  * Main function
@@ -20,51 +22,146 @@ window.onload = function() {
 function calculateAnswer(event) {
   console.info("Calculating answer for input...");
   let assignment = document.getElementById(ASSIGNMENT).value;
-  let top3 = document.getElementById(ALGORITHM_CHECKBOX).checked;
-  let answer = algorithm(assignment, (top3)? TOP_N: 1);
+  let allAtOnce = document.getElementById(ALGORITHM_CHECKBOX).checked;
+  let answer = algorithm(assignment, allAtOnce);
 
   document.getElementById(ANSWER).innerText = answer;
 }
 
 /**
- * Calculate the answer to assignment1 with 2 variables, count and highest.
+ * Calculate the answer to assignment.
  * @param assignment the input from the assignment.
- * @param topn the
- * @return string the elf with the highest calory count
+ * @param allAtOnce should all containers be moved at once.
+ * @return string the answer
  */
-function algorithm(assignment, topn) {
-    let currentCalorieScore = 0;
-    let highestCalorieScores = Array.from({length: topn}, () => (0));
-    let currentElf = 1;
-
-    let lines = assignment.trim().split(NEWLINE_CHARACTER);
+function algorithm(assignment, allAtOnce) {
+    let lines = assignment.split(NEWLINE_CHARACTER);
+    let containerPlan = Array.from({length:(lines[0].length+1)/4}, () => [])
     console.info("Linecount:" + lines.length);
 
-    for(var i = 0; i < lines.length; i++){
-        let line = lines[i];
+    let parsec = true;
+    for(let i=0; i<lines.length; i++) {
+        if(parsec) {
 
-        if(!line && currentCalorieScore > 0) { // Check for empty line and skip subsequent emptylines
-            console.debug("Calculated score for elf " + currentElf + ": " + currentCalorieScore);
+            // Parse containers
+            let containerLine = lines[i];
 
-            for(let j=0; j < highestCalorieScores.length; j++) {
-                if(currentCalorieScore > highestCalorieScores[j]) {
-                    console.debug("New highest #"+(j+1) + " elf found, with score:" + currentCalorieScore);
-                    let oldHighestCalorieScore = highestCalorieScores[j];
-                    highestCalorieScores[j] = currentCalorieScore;
-                    currentCalorieScore = oldHighestCalorieScore;
-                }
+            // Skip numbers
+            if(containerLine[1] == '1') {
+                parsec = false;
+                i+=1;
+                console.table(containerPlan);
+                continue;
             }
 
-            // Reset values
-            currentCalorieScore = 0;
-            currentElf++;
-            continue;
+            let containers = parseContainers(containerLine);
+            if(containers == -1) {
+                // invalid containerline
+                // TODO: error
+                console.error("Container parse failure.");
+                continue;
+            }
+
+            // Add containers
+            //console.debug(containers);
+            for(let j=0; j<containers.length; j++) {
+                let container = containers[j];
+                //console.debug(container);
+                if(container != CONTAINER_NULL_CHARACTER) {
+                    //console.debug(j);
+                    //console.debug(containerPlan);
+                    containerPlan[j].push(container);
+                }
+            }
+            //console.table(containerPlan);
+        } else {
+            // Parse instructions
+            let instructionLine = lines[i];
+            let instruction = parseInstruction(instructionLine);
+
+            console.debug(instruction);
+            if(instruction == -1) {
+                // invalid instructionline
+                // TODO: error
+                console.error("Instruction parse failure.");
+                continue;
+            }
+
+            // Execute instruction
+            let movecount=0;
+            if(allAtOnce) {
+                while(instruction.move > 0) {
+                    let container = containerPlan[instruction.from].shift();
+                    containerPlan[instruction.to].unshift(container);
+                    instruction.move--;
+                    movecount++;
+                }
+                console.debug("moved:" + movecount);
+            } else {
+                let splicedContainers = containerPlan[instruction.from].splice(0, instruction.move);
+                containerPlan[instruction.to].unshift(...splicedContainers);
+            }
+
+            //console.table(containerPlan);
         }
-            
-        let calorieScore = parseInt(line);
-        currentCalorieScore += calorieScore;
     }
 
-    console.debug(highestCalorieScores);
-    return "The highest of sum of calorie amount: " + highestCalorieScores.reduce(function(a, b) { return a + b; }, 0);
+    let result="";
+    for(let k=0; k<containerPlan.length; k++) {
+        result += containerPlan[k][0];
+    }
+
+    return "Top containers on the stack are: " + result;
+}
+
+function parseInstruction(instructionLine) {
+    let instruction={
+        move:0,
+        from:0,
+        to:0,
+    }
+
+    instructionLine.replace(/\s/g, ''); // Remove whitespace
+    let fromIndex = instructionLine.indexOf(INSTRUCTION_FROM);
+    let moveIndex = instructionLine.indexOf(INSTRUCTION_MOVE);
+    let toIndex = instructionLine.indexOf(INSTRUCTION_TO);
+
+    // Validate
+    if(fromIndex < 0 || moveIndex < 0 || toIndex < 0) {
+        // Error
+        return -1;
+    }
+
+    // TODO validate check for numbers after indices.
+
+    // Parse
+    instruction.move = parseInt(instructionLine.substring(moveIndex + INSTRUCTION_MOVE.length + 1, fromIndex));
+    instruction.from = parseInt(instructionLine.substring(fromIndex + INSTRUCTION_FROM.length + 1, toIndex)) -1;
+    instruction.to = parseInt(instructionLine.substring(toIndex + INSTRUCTION_TO.length + 1)) -1;
+
+    return instruction;
+}
+
+function parseContainers(containerLine) {
+    let containerLineLength = (containerLine.length+1);
+    //console.debug("Parse ContainerLine, length: " + containerLineLength);
+
+    if(!containerLine.includes('[') || !containerLine.includes(']') || containerLineLength % 4 != 0) {
+        return -1;
+    }
+
+    let containers = [];
+    for(let i=0; i<containerLineLength; i+=4) {
+        let containerLineSubString = containerLine.substring(i, i+4).trim();
+        let character = containerLineSubString[1];
+        if(containerLineSubString[0] != '[' || containerLineSubString[2] != ']') {
+                // Warning invalid container format
+                // TODO: warning
+        }
+
+        containers.push((!character)? CONTAINER_NULL_CHARACTER: character);
+    }
+    //console.debug(containers);
+
+    return containers;
 }