zoisite gwen

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,193 @@
+
+
+
+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
+};
+const pointValues = {
+  "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,
+};
+
 export const drawLetters = () => {
   // Implement this method for wave 1
+  let tiles = [];
+  let letterPoolList = [];
+  let letterFrequency = {};
+  let count = 0;
+
+  for (let letter of Object.keys(letterPool)){
+    for (let i= 0; i <= letterPool[letter] - 1; i++){
+      letterPoolList.push(letter);
+    }
+  }
+
+  while (count <= 9){
+    const random = () => {
+      return letterPoolList[Math.floor(Math.random()* letterPoolList.length)];
+    };
+
+    let randomLetter = random();
+
+
+
+    if (randomLetter in Object.keys(letterFrequency)){
+      if ((letterFrequency[randomLetter] + 1) > letterPool[[randomLetter]]){
+        randomLetter = random();
+      } else {
+        letterFrequency[randomLetter] ++;
+      }
+    } else {
+      letterFrequency[randomLetter] = 1;
+    }
+    tiles.push(randomLetter);
+    count++;
+  }
+
+  return tiles;
+
+
+
 };
 
+
+
 export const usesAvailableLetters = (input, lettersInHand) => {
-  // Implement this method for wave 2
+  let lettersInHandFreq = {};
+  let inputFreq = {};
+  input.toUpperCase();
+
+  for(let letter of lettersInHand){
+    if(letter in lettersInHandFreq){
+      lettersInHandFreq[letter] += 1
+    } else {
+      lettersInHandFreq[letter] = 1
+    }
+  }
+
+  for(let char of input){
+    if(char in lettersInHandFreq){
+      if(char in inputFreq){
+        inputFreq[char] += 1
+      } else {
+        inputFreq[char] = 1
+      }
+    } else {
+      return false;
+    }
+  }
+
+  for(let letter of Object.keys(inputFreq)){
+    if(inputFreq[letter] > lettersInHandFreq[letter]){
+      return false;
+    } 
+  }
+  return true;
+
 };
 
 export const scoreWord = (word) => {
-  // Implement this method for wave 3
+  let totalPoints = 0;
+
+
+  if (word.length >= 7) {
+    totalPoints += 8;
+  }
+
+  for(let index in word){
+    let letterPointValue = pointValues[(word[index]).toUpperCase()]
+    totalPoints += letterPointValue;
+  }
+
+  return totalPoints;
 };
 
 export const highestScoreFrom = (words) => {
-  // Implement this method for wave 4
+  let wordPoints = {};
+  let pointList = [];
+
+  for(let word of words){
+    let points = scoreWord(word)
+    pointList.push(points)
+    if(points in wordPoints){
+      wordPoints[points].push(word)
+    } else {
+      wordPoints[points] = [word]
+    }
+  }
+
+  let highestPoints = Math.max(...pointList);
+  let highestScoredWords = wordPoints[highestPoints];
+
+  let currentWinner = highestScoredWords[0]
+
+  if(highestScoredWords.length === 1){
+    return {'word' : currentWinner, 'score': highestPoints};
+  }
+
+  let range = highestScoredWords.length - 1;
+
+  for(let i=1; i <= range; i++){
+    if(currentWinner.length === 10){
+      return {'word' : currentWinner, 'score': highestPoints};
+    } else if((highestScoredWords[i]).length === 10){
+      return {'word' : highestScoredWords[i], 'score': highestPoints};
+    } else if(currentWinner.length > (highestScoredWords[i]).length){
+      currentWinner = highestScoredWords[i]
+    }
+
+  }
+  return {'word' : currentWinner, 'score': highestPoints}
+
+
 };
+

test/adagrams.test.js

@@ -120,7 +120,8 @@ describe("Adagrams", () => {
     });
 
     it("returns a score of 0 if given an empty input", () => {
-      throw "Complete test";
+      const word = '';
+      expect(scoreWord(word)).toBe(0);
     });
 
     it("adds an extra 8 points if word is 7 or more characters long", () => {
@@ -133,7 +134,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 +146,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", () => {