Messy initial solution.

2022-12-06 17:03:21 +01:00
4 changed files with 147 additions and 114 deletions
--- a/README.md
+++ b/README.md
@@ -1,6 +1,13 @@
-# Advent of Code 2022 - Assignment7 javascript
-Assignment 7 involves parsing linux directory commands/results into a tree. The solution defines a root TreeNode first and sets it as currentdirectory. Whenever a cd command is found a new node is created if it does not exist and set to currentdir. Whenever a cd .. is found currentdirectory is set to parent. Whenever a file is found size is recursively increased for current node and parent nodes.
+# Advent of Code 2022 - Assignment5 javascript
+This repository contains answers to the assignments of Advent of Coding 2022

 ## References
- https://adrianmejia.com/data-structures-for-beginners-trees-binary-search-tree-tutorial/
- https://stackoverflow.com/questions/8376525/get-value-of-a-string-after-last-slash-in-javascript
+- 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
--- a/index.html
+++ b/index.html
@@ -8,6 +8,8 @@
  <body>
    <p>Assignment:</p>
    <textarea rows="15" cols="50" id="assignment"></textarea>
+    <input type="checkbox" id="algorithm"/>
+    <label for="algorithm">All containers at once?</label>

    <p>Answer:</p>
    <div id="answer">Provide input first</div>
--- a/script.js
+++ b/script.js
@@ -1,85 +1,18 @@
 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 MAX_SIZE = 100000;
-const UPDATE_SIZE = 30000000;
-const TOTAL_SPACE = 70000000;

 /**
 * Main function
 */
 window.onload = function() {
    document.getElementById(ASSIGNMENT).addEventListener("input", calculateAnswer);
-}
-
-class TreeNode {
-  constructor(value, parent) {
-    console.debug(((!parent)?"Root ":"") + "node created: " + value);
-
-    this.parent = parent;
-    this.value = value;
-    this.size = 0;
-    this.descendants = [];
-  }
-
-  getDir = function(path) {
-    for(let descendant of this.descendants) {
-      if(descendant.value == path) {
-        return descendant;
-      }
-    }
-  }
-
-  contains = function(path) {
-    // Recursive case
-    let subPathIndex = path.indexOf('/');
-    let subPath = path.substring(0, subPathIndex-1);
-    let leftOverPath = path.substring(subPathIndex);
-
-    // Base case
-    if(subPath == '') {
-      return false;
-    }
-
-    for(let descendant of this.descendants) {
-      if(descendant.value == subPath) {
-        return descendant.contains(subPath);
-      }
-    }
-  }
-
-  findClosestNodeToSize = function(minSize) {
-    let closest = this;
-
-    for(let descendant of this.descendants) {
-      let closestDescendant = descendant.findClosestNodeToSize(minSize);
-
-      if (closestDescendant.size > minSize && closestDescendant.size < closest.size) {
-        console.debug("New closest:" + closestDescendant.size);
-        closest = closestDescendant;
-      }
-    }
-
-    return closest;
-  }
-
-  increaseSize = function(size) {
-    // TODO: Wat doen we met duplicate files?
-    this.size += size;
-    if(this.parent) {
-      this.parent.increaseSize(size);
-    }
-  }
-
-  getSum = function(maxSize) {
-    let result = (this.size < maxSize) ? this.size: 0;
-
-    for(let descendant of this.descendants) {
-      result += descendant.getSum(maxSize);
-    }
-
-    return result;
-  }
+    document.getElementById(ALGORITHM_CHECKBOX).addEventListener("click", calculateAnswer);
 }

 /**
@@ -88,7 +21,9 @@ class TreeNode {
 */
 function calculateAnswer(event) {
  console.info("Calculating answer for input...");
-  let answer = algorithm(event.target.value);
+  let assignment = document.getElementById(ASSIGNMENT).value;
+  let allAtOnce = document.getElementById(ALGORITHM_CHECKBOX).checked;
+  let answer = algorithm(assignment, allAtOnce);

  document.getElementById(ANSWER).innerText = answer;
 }
@@ -96,52 +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) {
-  let lines = assignment.trim().split(NEWLINE_CHARACTER);
-  console.info("Linecount:" + lines.length);
+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);

-  let root = new TreeNode('/');
-  let currentdir = root;
+    let parsec = true;
+    for(let i=0; i<lines.length; i++) {
+        if(parsec) {

-  for(let i=0; i<lines.length; i++) {
-    let terminalLine = lines[i].trim();
+            // Parse containers
+            let containerLine = lines[i];

-    if(terminalLine.substring(0, 4) == "$ cd") {
-      let changeDirectory = terminalLine.substring(5).trim();
-      if(changeDirectory == "..") {
-        console.debug("One directory up from: " + currentdir.value);
-        currentdir = currentdir.parent;
-        console.debug("navigates to: " + currentdir.value);
-        continue;
-      }
+            // Skip numbers
+            if(containerLine[1] == '1') {
+                parsec = false;
+                i+=1;
+                console.table(containerPlan);
+                continue;
+            }

-      if(changeDirectory == "/") {
-        currentdir = root;
-        continue;
-      }
+            let containers = parseContainers(containerLine);
+            if(containers == -1) {
+                // invalid containerline
+                // TODO: error
+                console.error("Container parse failure.");
+                continue;
+            }

-      if(!currentdir.contains(changeDirectory)) {
-        currentdir.descendants.push(new TreeNode(changeDirectory, currentdir));
-      } 
+            // 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);

-      currentdir = currentdir.getDir(changeDirectory);
-    } else if(terminalLine.substring(0, 3) != 'dir' && !terminalLine.includes('$')) {
-      console.debug(terminalLine);
-      spaceIndex = terminalLine.indexOf(' ');
-      size = parseInt(terminalLine.substring(0, spaceIndex));
-      currentdir.increaseSize(size);
+            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 freeDiskSpace = TOTAL_SPACE - root.size;
-  console.debug("Free disk space: " + freeDiskSpace);
+    let result="";
+    for(let k=0; k<containerPlan.length; k++) {
+        result += containerPlan[k][0];
+    }

-  console.debug("Root size:" + root.size);
-  console.debug("Value to find: " + (UPDATE_SIZE - freeDiskSpace));
-  let closestNode = root.findClosestNodeToSize(UPDATE_SIZE - freeDiskSpace);
-  console.debug("Closest value: " + closestNode.size);
+    return "Top containers on the stack are: " + result;
+}

-  return "Sum below maxSize " + MAX_SIZE + ": " + root.getSum(MAX_SIZE);
+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;
 }
--- a/style.css
+++ b/style.css
@@ -6,6 +6,10 @@ body {
    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
  }
  
+  textarea {
+    display: block;
+  }
+  
  #answer {
    color: purple
  }