Tigers - Melley

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "jest.jestCommandLine": "yarn test"
+}

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.28.0",
+    "eslint-plugin-jest": "^27.1.6",
     "jest": "^24.8.0",
     "regenerator-runtime": "^0.12.1"
   },

src/adagrams.js

@@ -1,15 +1,129 @@
+const letterPool = Array(9)
+  .fill("A")
+  .concat(Array(2).fill("B"))
+  .concat(Array(2).fill("C"))
+  .concat(Array(4).fill("D"))
+  .concat(Array(12).fill("E"))
+  .concat(Array(2).fill("F"))
+  .concat(Array(3).fill("G"))
+  .concat(Array(2).fill("H"))
+  .concat(Array(9).fill("I"))
+  .concat(Array(1).fill("J"))
+  .concat(Array(1).fill("K"))
+  .concat(Array(4).fill("L"))
+  .concat(Array(2).fill("M"))
+  .concat(Array(6).fill("N"))
+  .concat(Array(8).fill("O"))
+  .concat(Array(2).fill("P"))
+  .concat(Array(1).fill("Q"))
+  .concat(Array(6).fill("R"))
+  .concat(Array(4).fill("S"))
+  .concat(Array(6).fill("T"))
+  .concat(Array(4).fill("U"))
+  .concat(Array(2).fill("V"))
+  .concat(Array(2).fill("W"))
+  .concat(Array(1).fill("X"))
+  .concat(Array(2).fill("Y"))
+  .concat(Array(1).fill("Z"));
+const scoreDict = {
+  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 adjustedLetterPool = [...letterPool];
+  let handList = [];
+  for (let i = 0; i < 10; i++) {
+    let currentLetter =
+      adjustedLetterPool[Math.floor(Math.random() * adjustedLetterPool.length)];
+    let letterIndex = adjustedLetterPool.indexOf(currentLetter);
+    adjustedLetterPool.splice(letterIndex, 1);
+    handList.push(currentLetter);
+  }
+  return handList;
 };
 
 export const usesAvailableLetters = (input, lettersInHand) => {
-  // Implement this method for wave 2
+  //   // Implement this method for wave 2
+  let lettersInHandCount = {};
+  for (const letter of lettersInHand) {
+    if (letter in lettersInHandCount) {
+      lettersInHandCount[letter] += 1;
+    } else {
+      lettersInHandCount[letter] = 1;
+    }
+  }
+
+  const upperCaseInput = input.toUpperCase();
+  for (const letter of upperCaseInput) {
+    if (!(letter in lettersInHandCount)) {
+      return false;
+    }
+    if (lettersInHandCount[letter] === 0) {
+      return false;
+    } else {
+      lettersInHandCount[letter] -= 1;
+    }
+  }
+  return true;
 };
 
 export const scoreWord = (word) => {
   // Implement this method for wave 3
+  const uppercaseWord = word.toUpperCase();
+  let score = 0;
+  for (const letter of uppercaseWord) {
+    score += scoreDict[letter];
+  }
+  if (word.length > 6) {
+    score += 8;
+  }
+  return score;
 };
 
 export const highestScoreFrom = (words) => {
   // Implement this method for wave 4
+  let highestScore = 0;
+  let winningWord = "";
+  for (const word of words) {
+    let currentScore = scoreWord(word);
+    if (word.length === 10) {
+      return { word: word, score: currentScore };
+    }
+    if (currentScore > highestScore) {
+      highestScore = currentScore;
+      winningWord = word;
+    } else if (
+      currentScore === highestScore &&
+      word.length < winningWord.length
+    ) {
+      winningWord = word;
+    }
+  }
+  return { word: winningWord, score: highestScore };
 };

test/adagrams.test.js

@@ -3,7 +3,7 @@ import {
   usesAvailableLetters,
   scoreWord,
   highestScoreFrom,
-} from "adagrams";
+} from 'adagrams';
 
 const LETTER_POOL = {
   A: 9,
@@ -34,15 +34,15 @@ const LETTER_POOL = {
   Z: 1,
 };
 
-describe("Adagrams", () => {
-  describe("drawLetters", () => {
-    it("draws ten letters from the letter pool", () => {
+  describe('Adagrams', () => {
+  describe('drawLetters', () => {
+    it('draws ten letters from the letter pool', () => {
       const drawn = drawLetters();
 
       expect(drawn).toHaveLength(10);
     });
 
-    it("returns an array, and each item is a single-letter string", () => {
+    it('returns an array, and each item is a single-letter string', () => {
       const drawn = drawLetters();
 
       expect(Array.isArray(drawn)).toBe(true);
@@ -51,52 +51,49 @@ describe("Adagrams", () => {
       });
     });
 
-    it("does not draw a letter too many times", () => {
+    it('does not draw a letter too many times', () => {
       for (let i = 0; i < 1000; i++) {
         const drawn = drawLetters();
-        const letter_freq = {};
+        const letterFreq = {};
         for (let letter of drawn) {
-          if (letter in letter_freq) {
-            letter_freq[letter] += 1;
-          } else {
-            letter_freq[letter] = 1;
+          if (letter in letterFreq) {
+            letterFreq[letter] += 1;
+          } else {letterFreq[letter] = 1;
           }
         }
 
-        for (let letter of drawn) {
-          expect(letter_freq[letter]).toBeLessThanOrEqual(LETTER_POOL[letter]);
-        }
+      for(let letter of drawn) {
+        expect(letterFreq[letter]).toBeLessThanOrEqual(LETTER_POOL[letter]);
+      }
       }
     });
   });
 
-  describe("usesAvailableLetters", () => {
-    it("returns true if the submitted letters are valid against the drawn letters", () => {
-      const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"];
-      const word = "DOG";
+  describe('usesAvailableLetters', () => {
+    it('returns true if the submitted letters are valid against the drawn letters', () => {
+      const drawn = ['D', 'O', 'G', 'X', 'X', 'X', 'X', 'X', 'X', 'X'];
+      const word = 'DOG';
 
       const isValid = 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";
+    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);
       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";
+    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);
       expect(isValid).toBe(false);
     });
   });
 
-  describe("scoreWord", () => {
+  describe('scoreWord', () => {
     const expectScores = (wordScores) => {
       Object.entries(wordScores).forEach(([word, score]) => {
         expect(scoreWord(word)).toBe(score);
@@ -120,7 +117,8 @@ describe("Adagrams", () => {
     });
 
     it("returns a score of 0 if given an empty input", () => {
-      throw "Complete test";
+      // throw "Complete test";
+      expectScores({'':0});
     });
 
     it("adds an extra 8 points if word is 7 or more characters long", () => {
@@ -133,7 +131,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 +143,8 @@ describe("Adagrams", () => {
       const words = ["XXX", "XXXX", "X", "XX"];
       const correct = { word: "XXXX", score: scoreWord("XXXX") };
 
-      throw "Complete test by adding an assertion";
+      // throw "Complete test by adding an assertion";
+      expect(highestScoreFrom(words)).toEqual(correct);
     });
 
     describe("in case of tied score", () => {