Zoisite - Muniba K.

src/adagrams.js

@@ -1,15 +1,128 @@
+const LETTER_POOL = {
+    '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 SCORE_CHART_DICT = {
+    1: ['A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'],
+    2: ['D', 'G'],
+    3: ['B', 'C', 'M', 'P'],
+    4: ['F', 'H', 'V', 'W', 'Y'],
+    5: ['K'],
+    8: ['J', 'X'],
+    10: ['Q','Z']
+};
+
 export const drawLetters = () => {
-  // Implement this method for wave 1
+  const arrLetterPool = [];
+
+  // Convert letterPool to list
+  for (let [letter, frequency] of Object.entries(LETTER_POOL)) {
+    let countLetters = 0;
+    while (countLetters < frequency) {
+      arrLetterPool.push(letter);
+      countLetters++;
+    }
+  }
+
+  const drawnLetters = [];
+
+  while (drawnLetters.length < 10) {
+    let randomLetter = Math.floor(Math.random() * arrLetterPool.length);
+    let removedLetter = arrLetterPool.splice(randomLetter, 1)[0];
+    drawnLetters.push(removedLetter);
+  }
+
+  return drawnLetters;
 };
 
+// Test code
+// console.log(drawLetters());
+
 export const usesAvailableLetters = (input, lettersInHand) => {
-  // Implement this method for wave 2
-};
+  let lettersInHandCopy = Array.from(lettersInHand);
+
+  for (let i = 0; i < input.length; i++) {
+    const currentLetter = input[i];
+    //Line below is needed because the letterIndex is what is used to loop through the lettersInHandCopy array
+    //If the currentLetter is not found, indexOf() returns -1.
+    const letterIndex = lettersInHandCopy.indexOf(currentLetter)
+    if (letterIndex !== -1) {
+      lettersInHandCopy.splice (letterIndex, 1);
+    } else {
+      return false;
+    }
+  }
+  return true;
+  }
 
 export const scoreWord = (word) => {
-  // Implement this method for wave 3
+  let score = 0;
+
+  if (word.length >= 7) {
+    score += 8;
+  }
+
+  const wordUpper = word.toUpperCase();
+
+  for (let letter of wordUpper) {
+    for (let [points, letters] of Object.entries(SCORE_CHART_DICT)) {
+      if (letters.includes(letter)) {
+        score += parseInt(points);
+      }
+    }
+  }
+  return score;
 };
 
 export const highestScoreFrom = (words) => {
   // Implement this method for wave 4
+  const scoresObj = {};
+  for (let word of words) {
+    scoresObj[word] = scoreWord(word);
+  }
+
+  let highScore = 0;
+  let shortestWord = "";
+
+  for (let [word, score] of Object.entries(scoresObj)) {
+    if (score > highScore) {
+      highScore = score;
+      shortestWord = word;
+    } else if (score === highScore) {
+      if (shortestWord.length === 10) {
+        shortestWord = shortestWord;
+      } else if (word.length === 10) {
+        shortestWord = word;
+      } else if (word.length < shortestWord.length) {
+        shortestWord = word;
+      }
+    }
+  }
+  const winningScore = { "score": highScore, "word": shortestWord };
+  return winningScore;
 };

test/adagrams.test.js

@@ -34,6 +34,16 @@ const LETTER_POOL = {
   Z: 1,
 };
 
+const SCORE_CHART_DICT = {
+  1: ['A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'],
+  2: ['D', 'G'],
+  3: ['B', 'C', 'M', 'P'],
+  4: ['F', 'H', 'V', 'W', 'Y'],
+  5: ['K'],
+  8: ['J', 'X'],
+  10: ['Q','Z']
+};
+
 describe("Adagrams", () => {
   describe("drawLetters", () => {
     it("draws ten letters from the letter pool", () => {
@@ -120,7 +130,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 +145,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 +157,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", () => {

test/demo/model.test.js

@@ -1,7 +1,7 @@
 import Model from 'demo/model';
 import Adagrams from 'demo/adagrams';
 
-describe.skip('Game Model', () => {
+describe('Game Model', () => {
   const config = {
     players: [
       'Player A',