Assignment2 algorithm solution.

2022-12-04 20:53:01 +01:00
4 changed files with 169 additions and 115 deletions
--- a/README.md
+++ b/README.md
@@ -1,6 +1,12 @@
-# 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 - assignment2 javascript
+## Description
+Assignment2 involves a game of rock paper scissors. The solution uses an enum for rock, paper, scissor values it defines two functions for selecting a winning and losing hand. The winning and losing hand take advantage of the fact that each next value in the rock, paper, scissor trio beats the previous (looping back to rock). For losing it is the other way around. The winning_hand function is also used to determine the score for player. In the GUI there is a checkbox for selecting solution options (part1,part2).

 ## 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.psychologytoday.com/us/blog/the-blame-game/201504/the-surprising-psychology-rock-paper-scissors#:~:text=There%20are%20four%20possible%20outcomes,Douglas%20Walker%20and%20Graham%20Walker.
+- https://www.sohamkamani.com/javascript/enums/
+- https://codingbeautydev.com/blog/javascript-remove-all-whitespace-from-string/#:~:text=To%20remove%20all%20whitespace%20from%20a%20string%20in%20JavaScript%2C%20call,all%20whitespace%20removed%20from%20str%20.
+- https://www.geeksforgeeks.org/how-to-check-a-key-exists-in-javascript-object/#:~:text=There%20are%20mainly%20two%20methods,property%20is%20in%20the%20object.
+- https://stackoverflow.com/questions/5765398/whats-the-best-way-to-convert-a-number-to-a-string-in-javascript
+- https://www.w3schools.com/jsref/jsref_switch.asp
+- https://www.w3schools.com/tags/att_input_type_checkbox.asp
--- a/index.html
+++ b/index.html
@@ -8,7 +8,8 @@
  <body>
    <p>Assignment:</p>
    <textarea rows="15" cols="50" id="assignment"></textarea>
-
+    <input type="checkbox" id="algorithm"/>
+    <label for="algorithm">Interpret X,Y,Z as Rock Paper Scissor.</label> 
    <p>Answer:</p>
    <div id="answer">Provide input first</div>
    <script src="script.js"></script>
--- a/script.js
+++ b/script.js
@@ -1,85 +1,62 @@
 const ASSIGNMENT = 'assignment';
 const ANSWER = 'answer';
+const ALGORITHM_CHECKBOX = 'algorithm';
+const ERROR_MESSAGE_NO_SUCH_CHARACTER_IN_RPS = "Non existant character in rock paper scissor game selected: ";
+const ERROR_MESSAGE_TOO_FEW_CHARACTERS_IN_LINE = "Too few characters in line: ";
 const NEWLINE_CHARACTER = '\n';
-const MAX_SIZE = 100000;
-const UPDATE_SIZE = 30000000;
-const TOTAL_SPACE = 70000000;
+const OPTION_LOSE = 'X';
+const OPTION_TIE = 'Y';
+const OPTION_WIN = 'Z';
+
+const RPS = Object.freeze({
+    ROCK: 1,
+    PAPER: 2,
+    SCISSORS: 3,
+
+    /**
+     * Select winning hand for given hand.
+     * @param hand the chosen hand
+     * @return RPS the winning hand
+     */
+    winning_hand: function(hand) {
+        hand++;
+        if(hand > RPS.SCISSORS) {
+            hand = RPS.ROCK;
+        }
+        return hand;
+    },
+
+    /**
+     * Select losing hand for given hand.
+     * @param hand the chosen hand
+     * @return RPS the losing hand
+     */
+    losing_hand: function(hand) {
+        hand--;
+        if(hand < RPS.ROCK) {
+            hand = RPS.SCISSORS;
+        }
+        return hand;
+    }
+});
+const RPS_ALIAS_MAP = Object.freeze({
+    "A": RPS.ROCK,
+    "B": RPS.PAPER,
+    "C": RPS.SCISSORS,
+    "X": RPS.ROCK,
+    "Y": RPS.PAPER,
+    "Z": RPS.SCISSORS,
+})
+const SCORE_LOSE = 0;
+const SCORE_TIE = 3;
+const SCORE_WIN = 6;

 /**
 * 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 +65,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 interpret_as_rps = document.getElementById(ALGORITHM_CHECKBOX).checked;
+  let answer = algorithm(assignment, interpret_as_rps);

  document.getElementById(ANSWER).innerText = answer;
 }
@@ -98,50 +77,115 @@ function calculateAnswer(event) {
 * @param assignment the input from the assignment.
 * @return string the answer
 */
-function algorithm(assignment) {
-  let lines = assignment.trim().split(NEWLINE_CHARACTER);
-  console.info("Linecount:" + lines.length);
+function algorithm(assignment, interpret_as_rps) {
+    let errors = 0;
+    let lines = assignment.trim().split(NEWLINE_CHARACTER);
+    let score = 0;
+    console.info("Linecount:" + lines.length);

-  let root = new TreeNode('/');
-  let currentdir = root;
+    for(let i=0; i<lines.length; i++) {
+        let rps_match = lines[i].replace(/\s/g, ''); // remove all whitespace
+        if(rps_match.length < 2) {
+            console.error(ERROR_MESSAGE_TOO_FEW_CHARACTERS_IN_LINE + i + ", skipped.");
+            errors++;
+            continue;
+        }

-  for(let i=0; i<lines.length; i++) {
-    let terminalLine = lines[i].trim();
+        // Assign characters from line
+        let opponent_hand = map_hand_character(rps_match[0]); 
+        let player_input = rps_match[1]; 
+        let player_hand = -1;

-    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;
-      }
+        // Validate hand
+        if(opponent_hand<0) {
+            console.error(ERROR_MESSAGE_NO_SUCH_CHARACTER_IN_RPS + rps_match[0] + " for line: " + i);
+            errors++;
+            continue;
+        }

-      if(changeDirectory == "/") {
-        currentdir = root;
-        continue;
-      }
+        // How should we interpret input? match_option or Rock Paper Scissors.
+        if(interpret_as_rps) {
+            player_hand = interpret_player_hand_as_rps_input(player_input);
+        } else {
+            player_hand = interpret_player_hand_as_match_input(player_input, opponent_hand);
+        }

-      if(!currentdir.contains(changeDirectory)) {
-        currentdir.descendants.push(new TreeNode(changeDirectory, currentdir));
-      } 
+        if(player_hand<0) { // Invalid input
+            console.error(ERROR_MESSAGE_NO_SUCH_CHARACTER_IN_RPS + rps_match[1] + " for line: " + i);
+            errors++;
+            continue;
+        }

-      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);
+        score += rps_result(player_hand, opponent_hand);
    }
-  }

-  let freeDiskSpace = TOTAL_SPACE - root.size;
-  console.debug("Free disk space: " + freeDiskSpace);
+    if(errors > 0) {
+        return errors.toString() + " Error(s) in input, see console for details."
+    }

-  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 "Sum below maxSize " + MAX_SIZE + ": " + root.getSum(MAX_SIZE);
+    return "Player score: " + score;
+}
+
+/**
+ * Interpret given input for player as a rock paper scissor character.
+ * @param char input the input for hand character (A,B,C,X,Y,Z)
+ * @return the player hand character or -1 if invalid.
+ */
+function interpret_player_hand_as_rps_input(input) {
+    return map_hand_character(input); 
+}
+
+/**
+ * Interpret given input for player as a match option.
+ * @param char input the input for match option (X,Y,Z)
+ * @return the player hand character or -1 if invalid.
+ */
+function interpret_player_hand_as_match_input(input, opponent_hand) {
+    let player_hand = -1;
+    switch (input) {
+        case OPTION_LOSE:
+            player_hand = RPS.losing_hand(opponent_hand);
+            break;
+        case OPTION_WIN:
+            player_hand = RPS.winning_hand(opponent_hand);
+            break;
+        case OPTION_TIE:
+            player_hand = opponent_hand;
+            break;
+    }
+
+    return player_hand;
+}
+
+/**
+ * Maps the chosen hand character to 
+ * @param hand_character the chosen character
+ * @return RPS the rock paper scissor hand or -1 if invalid
+ */
+function map_hand_character(hand_character) {
+    if(!(hand_character in RPS_ALIAS_MAP)) {
+        return -1;
+    }
+
+    return RPS_ALIAS_MAP[hand_character];
+}
+
+/**
+ * Calculate the result of rock paper scissor match
+ * @param RPS player_hand the player's choice
+ * @param RPS opponent_hand the opponent's choice
+ * @return score
+ */
+function rps_result(player_hand, opponent_hand) {
+    let score = 0;
+    if(player_hand == opponent_hand) {
+        score = SCORE_TIE + player_hand;  // TIE
+    } else if(player_hand == RPS.winning_hand(opponent_hand)) {
+        score = SCORE_WIN + player_hand; // WIN
+    } else {
+        score = SCORE_LOSE + player_hand; // LOSE
+    }
+
+    console.debug("score:" + score + ", player: " + player_hand + ", opponent: " + opponent_hand);
+    return score;
 }
--- a/style.css
+++ b/style.css
@@ -6,6 +6,9 @@ body {
    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
  }
  
+  textarea {
+    display: block;
+  }
  #answer {
    color: purple
  }