Messy initial solution.

README.md

@@ -1,8 +1,13 @@
-# Advent of Code 2022 - Assignment8 javascript
+# Advent of Code 2022 - Assignment5 javascript
-## Description
+This repository contains answers to the assignments of Advent of Coding 2022
-This problem is all about walking through a grid. In this solution, we look through an entire column and row until we find a node with height <= height.
 
 ## References
-- https://www.w3schools.com/jsref/jsref_charat.asp
+- https://www.w3schools.com/jsref/jsref_includes.asp
-- https://stackabuse.com/javascript-check-if-variable-is-a-number/
+- https://stackoverflow.com/questions/10261986/how-to-detect-string-which-contains-only-spaces
-- https://www.w3schools.com/jsref/jsref_abs.asp
+- 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">Highest scenic score?</label>
+    <label for="algorithm">All containers at once?</label>
 
     <p>Answer:</p>
     <div id="answer">Provide input first</div>

script.js

@@ -1,6 +1,10 @@
 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';
 
 /**
@@ -18,8 +22,8 @@ window.onload = function () {
 function calculateAnswer(event) {
   console.info("Calculating answer for input...");
   let assignment = document.getElementById(ASSIGNMENT).value;
-  let getHighestScenicScore = document.getElementById(ALGORITHM_CHECKBOX).checked;
+  let allAtOnce = document.getElementById(ALGORITHM_CHECKBOX).checked;
-  let answer = algorithm(assignment, getHighestScenicScore);
+  let answer = algorithm(assignment, allAtOnce);
 
   document.getElementById(ANSWER).innerText = answer;
 }
@@ -27,108 +31,137 @@ function calculateAnswer(event) {
 /**
  * Calculate the answer to assignment.
  * @param assignment the input from the assignment.
+ * @param allAtOnce should all containers be moved at once.
  * @return string the answer
  */
-function algorithm(assignment, getHighestScenicScore) {
+function algorithm(assignment, allAtOnce) {
-  let lines = assignment.trim().split(NEWLINE_CHARACTER);
+    let lines = assignment.split(NEWLINE_CHARACTER);
+    let containerPlan = Array.from({length:(lines[0].length+1)/4}, () => [])
     console.info("Linecount:" + lines.length);
 
-  let visibleTreeCount = 0;
+    let parsec = true;
-  let highestScenicScore = 0;
-
     for(let i=0; i<lines.length; i++) {
-    let row = lines[i].trim();
+        if(parsec) {
 
-    for (let j = 0; j < row.length; j++) {
+            // Parse containers
-      if (i <= 0 || i >= lines.length - 1 || j <= 0 || j >= row.length - 1) { // Edge node
+            let containerLine = lines[i];
-        //console.debug("Edge node found.");
+
-        visibleTreeCount++;
+            // Skip numbers
+            if(containerLine[1] == '1') {
+                parsec = false;
+                i+=1;
+                console.table(containerPlan);
                 continue;
             }
 
-      let height = parseInt(lines[i].charAt(j));
+            let containers = parseContainers(containerLine);
-      if (!walkRowVisible(height, j, row) && !walkColumnVisible(height, i, j, lines)) {
+            if(containers == -1) {
-        console.log("Found invisible tree, height:" + height + ", i:" + i + ", j:" + j);
+                // invalid containerline
-        visibleTreeCount--;
+                // TODO: error
+                console.error("Container parse failure.");
+                continue;
             }
 
-      if (getHighestScenicScore) {
+            // Add containers
-        let scenicScore = walkRowCount(height, j, row) * walkColumnCount(height, i, j, lines);
+            //console.debug(containers);
-        if (scenicScore > highestScenicScore) {
+            for(let j=0; j<containers.length; j++) {
-          console.debug("Found new highest scenic score: " + scenicScore);
+                let container = containers[j];
-          highestScenicScore = scenicScore;
+                //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);
         }
     }
 
-      // Tree is on edge.
+    let result="";
-      visibleTreeCount++;
+    for(let k=0; k<containerPlan.length; k++) {
-    }
+        result += containerPlan[k][0];
     }
 
-  if (getHighestScenicScore) {
+    return "Top containers on the stack are: " + result;
-    return "Highest scenic score: " + highestScenicScore;
 }
 
-  return "Amount of visible trees in the grid: " + visibleTreeCount;
+function parseInstruction(instructionLine) {
+    let instruction={
+        move:0,
+        from:0,
+        to:0,
     }
 
-function walkColumnCount(height, index, rowIndex, column) {
+    instructionLine.replace(/\s/g, ''); // Remove whitespace
-  return walkCount(height, index, column, false, rowIndex);
+    let fromIndex = instructionLine.indexOf(INSTRUCTION_FROM);
-}
+    let moveIndex = instructionLine.indexOf(INSTRUCTION_MOVE);
+    let toIndex = instructionLine.indexOf(INSTRUCTION_TO);
 
-function walkRowCount(height, index, row) {
+    // Validate
-  return walkCount(height, index, row, true, -1);
+    if(fromIndex < 0 || moveIndex < 0 || toIndex < 0) {
-}
+        // Error
-
-function walkColumnVisible(height, index, rowIndex, column) {
-  return walkVisible(height, index, column, false, rowIndex);
-}
-
-function walkRowVisible(height, index, row) {
-  return walkVisible(height, index, row, true, -1);
-}
-
-function walkCount(height, index, line, isRow, rowIndex) {
-  let visibleLeftCount = __walkHelper(height, index, line, isRow, -1, rowIndex, 0);
-  let visibleRightCount = __walkHelper(height, index, line, isRow, 1, rowIndex, 0);
-
-  return visibleLeftCount * visibleRightCount;
-}
-
-function walkVisible(height, index, line, isRow, rowIndex) {
-  let visibleLeft = __walkHelper(height, index, line, isRow, -1, rowIndex);
-  let visibleRight = __walkHelper(height, index, line, isRow, 1, rowIndex);
-
-  return visibleLeft || visibleRight;
-}
-
-function __walkHelper(height, index, line, isRow, direction, rowIndex, count) {
-  if (direction == 0) {
-    console.error("Invalid direction 0 in __walkhelper");
         return -1;
     }
 
-  direction = direction / Math.abs(direction);
+    // TODO validate check for numbers after indices.
 
-  // Edge reached
+    // Parse
-  if ((direction < 0 && index <= 0) || (direction > 0 && index >= line.length - 1)) {
+    instruction.move = parseInt(instructionLine.substring(moveIndex + INSTRUCTION_MOVE.length + 1, fromIndex));
-    return (count == undefined) ? true : count;
+    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;
 }
 
-  let nextIndex = index + direction;
+function parseContainers(containerLine) {
-  let nextHeightCharacter = (isRow) ? line.charAt(nextIndex) : line[nextIndex].trim().charAt(rowIndex);
+    let containerLineLength = (containerLine.length+1);
-  let nextHeight = parseInt(nextHeightCharacter);
+    //console.debug("Parse ContainerLine, length: " + containerLineLength);
 
-  if (isNaN(height) || isNaN(nextHeightCharacter)) {
+    if(!containerLine.includes('[') || !containerLine.includes(']') || containerLineLength % 4 != 0) {
-    console.error("Invalid height found, height:" + height + ", nextHeight: " + nextHeightCharacter);
         return -1;
     }
 
-  if (height <= nextHeight) {
+    let containers = [];
-    if (count == undefined)
+    for(let i=0; i<containerLineLength; i+=4) {
-      return false;
+        let containerLineSubString = containerLine.substring(i, i+4).trim();
-    return count + 1;
+        let character = containerLineSubString[1];
+        if(containerLineSubString[0] != '[' || containerLineSubString[2] != ']') {
+                // Warning invalid container format
+                // TODO: warning
         }
 
-  return __walkHelper(height, nextIndex, line, isRow, direction, rowIndex, (count !=undefined)? count + 1 : undefined);
+        containers.push((!character)? CONTAINER_NULL_CHARACTER: character);
+    }
+    //console.debug(containers);
+
+    return containers;
 }