G Quinn Kunzite JS Adagrams

package.json

@@ -27,6 +27,8 @@
     "babel-core": "^7.0.0-bridge.0",
     "babel-jest": "^24.8.0",
     "babel-plugin-module-resolver": "^3.2.0",
+    "eslint": "^8.41.0",
+    "eslint-plugin-jest": "^27.2.1",
     "jest": "^24.8.0",
     "regenerator-runtime": "^0.12.1"
   },

src/adagrams.js

@@ -1,15 +1,148 @@
 export const drawLetters = () => {
   // Implement this method for wave 1
+  const letters= []
+  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
+  }
+  while (letters.length <10){
+    const keys = Object.keys(letterPool);
+    const len = keys.length;
+    const rnd = Math.floor(Math.random() * len);
+    const key = keys[rnd];
+
+    if (letterPool[key] > 0){
+      letterPool[key]-=1;
+    }else{
+      continue;
+    }
+
+
+    letters.push(key);
+
+  }
+  return letters;
+
+
 };
 
 export const usesAvailableLetters = (input, lettersInHand) => {
   // Implement this method for wave 2
+  const lettersInHandCopy = [...lettersInHand];
+  for (const letter of input){
+    if (!lettersInHandCopy.includes(letter)){
+      return false;
+    } const index = lettersInHandCopy.indexOf(letter);
+    let temp = lettersInHandCopy[lettersInHandCopy.length - 1]  
+    lettersInHandCopy[lettersInHandCopy.length - 1] = lettersInHandCopy[index];
+    lettersInHandCopy[index]=temp;
+    lettersInHandCopy.pop();
+
+  }return true;
 };
 
 export const scoreWord = (word) => {
   // Implement this method for wave 3
-};
+
+  const points =[]
+  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
+}
+
+if (!word){
+   points.push(0)
+}
+
+let newWord = word.toUpperCase();
+
+for (const letter of newWord){
+  if (letter in scoreChart){
+    points.push(scoreChart[letter])
+  } 
+}
+  console.log(points)
+let total = points.reduce((sum, num) => sum + num);
+console.log(total);
+if (word.length >= 7){
+  (total += 8);
+  }
+
+  return total;
+}
 
 export const highestScoreFrom = (words) => {
   // Implement this method for wave 4
+  const scoresDict = {};
+  let maximum = 0;
+  let maxKey = null;
+  let score = 0;
+
+  words.sort((a, b) => a.length - b.length);
+  for (const word of words) {
+      score = scoreWord(word);
+      scoresDict[word] = score;
+  }
+
+  for (const scores in scoresDict) {
+      if (scoresDict[scores] > maximum) {
+          maximum = scoresDict[scores];
+          maxKey = scores;
+      } else if (words[words.length - 1].length === words[words.length - 2].length && score === maximum) {
+          maxKey = words[words.length - 2];
+      } else if (words[words.length - 1].length === 10 && score=== maximum) {
+          maxKey = words[words.length - 1];
+      }
+  }
+  return {word:maxKey, score:maximum};
+
 };
+

test/adagrams.test.js

@@ -120,7 +120,9 @@ 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,7 +135,7 @@ 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") };
@@ -145,7 +147,7 @@ describe("Adagrams", () => {
       const words = ["XXX", "XXXX", "X", "XX"];
       const correct = { word: "XXXX", score: scoreWord("XXXX") };
 
-      throw "Complete test by adding an assertion";
+      expect(highestScoreFrom(words)).toEqual(correct);
     });
 
     describe("in case of tied score", () => {