Ocelots - Lisa Utsett

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/src/adagrams.js"
+        }
+    ]
+}

package.json

@@ -32,6 +32,7 @@
   },
   "dependencies": {
     "core-js": "^3.8.0",
+    "package.json": "^2.0.1",
     "vorpal": "^1.12.0"
   }
 }

src/adagrams.js

@@ -1,15 +1,130 @@
-export const drawLetters = () => {
-  // Implement this method for wave 1
-};
+"use strict";
 
-export const usesAvailableLetters = (input, lettersInHand) => {
-  // Implement this method for wave 2
-};
+class Adagrams{
 
-export const scoreWord = (word) => {
-  // Implement this method for wave 3
-};
+  drawLetters = () => {
+    const letterPool = {
+      A: 9, B: 2, C: 2, D: 4, 
+      E: 12, F: 2, G: 3, H: 2, 
+      I: 9, J: 1, K: 1, L: 4, 
+      M: 2, N: 6, O: 8, P: 2, 
+      Q: 1, R: 6, S: 4, T: 6, 
+      U: 4, V: 2, W: 2, X: 1, 
+      Y: 2, Z: 1
+    }; 
+      //creates a bag of letters
+      let bagOfLetters = [];
+      for (let letter in letterPool) {
+        for (let i = 0; i < letterPool[letter]; ++i) {
+          bagOfLetters.push(letter);
+        }
+      }
+      const drawnLetters = [];
+
+
+      // adds ten random letters to hand 
+      for (let i = 0; i < 10; ++i) {
+        let randomIndex = Math.floor((Math.random() * bagOfLetters.length));
+        let randomLetter = bagOfLetters[randomIndex]; 
+        drawnLetters.push(randomLetter); //adds letter to hand
+        bagOfLetters.splice(randomIndex, 1); //removes letter from bag
+      }
+      return drawnLetters;
+  };
+
+  usesAvailableLetters = (input, lettersInHand) => {
+    // dictionary with letters in hand as keys and their frequencies as values
+    const letterFreqMap = {}; 
+
+    // anonymous function that is called in the forEach method below
+    // purpose: populates letterFreqMap
+    const createMap = function(letter){
+      if (letter in letterFreqMap) {
+        letterFreqMap[letter]++;
+      }
+      else {
+        letterFreqMap[letter] = 1;
+      }
+    }
 
-export const highestScoreFrom = (words) => {
-  // Implement this method for wave 4
+    lettersInHand.forEach(createMap);
+
+    // loops through every letter in input
+    // checks if letter is in hand
+    // if letter is there BUT there are no available letters left, return false
+    // if letter is there BUT there are available letters left, decrement the frequency of the letter by 1
+    // if letter is not there, return false
+    for (let i = 0; i < input.length; ++i) {
+        if (lettersInHand.includes(input[i])){
+          if (letterFreqMap[input[i]] === 0) {
+            return false;
+          }
+          else {
+            letterFreqMap[input[i]]--;
+          }
+        }
+        else {
+            return false;
+        }
+    }
+    return true;
+
+  };
+
+  scoreWord = (word) => {
+    const scoreChart = {
+      A: 1, B: 3, C: 3, D: 2, 
+      E: 1, F: 4, G: 2, H: 4, 
+      I: 1, J: 8, K: 5, L: 1, 
+      M: 3, N: 1, O: 1, P: 3, 
+      Q: 10, R: 1, S: 1, T: 1, 
+      U: 1, V: 4, W: 4, X: 8, 
+      Y: 4, Z: 10
+  };
+
+    let score = 0;
+    if (word.length > 0) {
+      for (let letter in word){
+          score += scoreChart[word[letter].toUpperCase()];
+      }
+      if (word.length >=7){
+        score += 8;
+      }
+    }
+    return score;
+  };
+
+  highestScoreFrom = (words) => {
+    let highestWordAndScore = ["", 0];
+    let score = 0;
+    for (let i in words) {
+      score = this.scoreWord(words[i]);
+      if (score > highestWordAndScore[1]) {
+        highestWordAndScore = [words[i], score];
+      }
+      // check if scores are tied
+      else if (score === highestWordAndScore[1]) {
+        // check if the lengths of both words are the same
+        // if they are, do nothing
+        if (words[i].length != highestWordAndScore[0].length) {
+        // if they arent, check if word is 10 letters long
+          if (words[i].length === 10) {
+            highestWordAndScore = [words[i], score];
+          }
+        // if not, check if word with highest score is not 10 letters long
+          else if (highestWordAndScore[0].length != 10) {
+            // if not, check which word has fewer letters
+            if (words[i].length < highestWordAndScore[0].length) {
+                highestWordAndScore = [words[i], score];
+            }
+          }
+        }
+      }
+
+    }
+
+      return {"score":highestWordAndScore[1], "word":highestWordAndScore[0]};
+  };
 };
+
+export default Adagrams;

test/adagrams.test.js

@@ -1,9 +1,4 @@
-import {
-  drawLetters,
-  usesAvailableLetters,
-  scoreWord,
-  highestScoreFrom,
-} from "adagrams";
+import Adagrams from "adagrams";
 
 const LETTER_POOL = {
   A: 9,
@@ -35,15 +30,16 @@ const LETTER_POOL = {
 };
 
 describe("Adagrams", () => {
+  let adagrams = new Adagrams();
   describe("drawLetters", () => {
     it("draws ten letters from the letter pool", () => {
-      const drawn = drawLetters();
+      const drawn = adagrams.drawLetters();
 
       expect(drawn).toHaveLength(10);
     });
 
     it("returns an array, and each item is a single-letter string", () => {
-      const drawn = drawLetters();
+      const drawn = adagrams.drawLetters();
 
       expect(Array.isArray(drawn)).toBe(true);
       drawn.forEach((l) => {
@@ -53,7 +49,7 @@ describe("Adagrams", () => {
 
     it("does not draw a letter too many times", () => {
       for (let i = 0; i < 1000; i++) {
-        const drawn = drawLetters();
+        const drawn = adagrams.drawLetters();
         const letter_freq = {};
         for (let letter of drawn) {
           if (letter in letter_freq) {
@@ -75,31 +71,31 @@ describe("Adagrams", () => {
       const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"];
       const word = "DOG";
 
-      const isValid = usesAvailableLetters(word, drawn);
+      const isValid = adagrams.usesAvailableLetters(word, drawn);
       expect(isValid).toBe(true);
     });
 
     it("returns false when word contains letters not in the drawn letters", () => {
       const drawn = ["D", "O", "X", "X", "X", "X", "X", "X", "X", "X"];
       const word = "DOG";
 
-      const isValid = usesAvailableLetters(word, drawn);
+      const isValid = adagrams.usesAvailableLetters(word, drawn);
       expect(isValid).toBe(false);
     });
 
     it("returns false when word contains repeated letters more than in the drawn letters", () => {
       const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"];
       const word = "GOOD";
 
-      const isValid = usesAvailableLetters(word, drawn);
+      const isValid = adagrams.usesAvailableLetters(word, drawn);
       expect(isValid).toBe(false);
     });
   });
 
   describe("scoreWord", () => {
     const expectScores = (wordScores) => {
       Object.entries(wordScores).forEach(([word, score]) => {
-        expect(scoreWord(word)).toBe(score);
+        expect(adagrams.scoreWord(word)).toBe(score);
       });
     };
 
@@ -120,7 +116,7 @@ describe("Adagrams", () => {
     });
 
     it("returns a score of 0 if given an empty input", () => {
-      throw "Complete test";
+      expectScores({"":0});
     });
 
     it("adds an extra 8 points if word is 7 or more characters long", () => {
@@ -133,24 +129,24 @@ describe("Adagrams", () => {
     });
   });
 
-  describe.skip("highestScoreFrom", () => {
+  describe("highestScoreFrom", () => {
     it("returns a hash that contains the word and score of best word in an array", () => {
       const words = ["X", "XX", "XXX", "XXXX"];
-      const correct = { word: "XXXX", score: scoreWord("XXXX") };
+      const correct = { word: "XXXX", score: adagrams.scoreWord("XXXX") };
 
-      expect(highestScoreFrom(words)).toEqual(correct);
+      expect(adagrams.highestScoreFrom(words)).toEqual(correct);
     });
 
     it("accurately finds best scoring word even if not sorted", () => {
       const words = ["XXX", "XXXX", "X", "XX"];
-      const correct = { word: "XXXX", score: scoreWord("XXXX") };
+      const correct = { word: "XXXX", score: adagrams.scoreWord("XXXX") };
 
-      throw "Complete test by adding an assertion";
+      expect(adagrams.highestScoreFrom(words)).toEqual(correct);
     });
 
     describe("in case of tied score", () => {
       const expectTie = (words) => {
-        const scores = words.map((word) => scoreWord(word));
+        const scores = words.map((word) => adagrams.scoreWord(word));
         const highScore = scores.reduce((h, s) => (h < s ? s : h), 0);
         const tiedWords = scores.filter((s) => s == highScore);
 
@@ -162,37 +158,37 @@ describe("Adagrams", () => {
         const words = ["AAAAAAAAAA", "BBBBBB"];
         const correct = {
           word: "AAAAAAAAAA",
-          score: scoreWord("AAAAAAAAAA"),
+          score: adagrams.scoreWord("AAAAAAAAAA"),
         };
         expectTie(words);
 
-        expect(highestScoreFrom(words)).toEqual(correct);
-        expect(highestScoreFrom(words.reverse())).toEqual(correct);
+        expect(adagrams.highestScoreFrom(words)).toEqual(correct);
+        expect(adagrams.highestScoreFrom(words.reverse())).toEqual(correct);
       });
 
       it("selects the word with fewer letters when neither are 10 letters", () => {
         const words = ["MMMM", "WWW"];
-        const correct = { word: "WWW", score: scoreWord("WWW") };
+        const correct = { word: "WWW", score: adagrams.scoreWord("WWW") };
         expectTie(words);
 
-        expect(highestScoreFrom(words)).toEqual(correct);
-        expect(highestScoreFrom(words.reverse())).toEqual(correct);
+        expect(adagrams.highestScoreFrom(words)).toEqual(correct);
+        expect(adagrams.highestScoreFrom(words.reverse())).toEqual(correct);
       });
 
       it("selects the first word when both have same length", () => {
         const words = ["AAAAAAAAAA", "EEEEEEEEEE"];
         const first = {
           word: "AAAAAAAAAA",
-          score: scoreWord("AAAAAAAAAA"),
+          score: adagrams.scoreWord("AAAAAAAAAA"),
         };
         const second = {
           word: "EEEEEEEEEE",
-          score: scoreWord("EEEEEEEEEE"),
+          score: adagrams.scoreWord("EEEEEEEEEE"),
         };
         expectTie(words);
 
-        expect(highestScoreFrom(words)).toEqual(first);
-        expect(highestScoreFrom(words.reverse())).toEqual(second);
+        expect(adagrams.highestScoreFrom(words)).toEqual(first);
+        expect(adagrams.highestScoreFrom(words.reverse())).toEqual(second);
       });
     });
   });