From 5312dc5b03b4d064462fc3eb4a955a7f9c458331 Mon Sep 17 00:00:00 2001 From: Elaine Date: Tue, 17 Jan 2023 14:16:05 -0800 Subject: [PATCH 01/16] start wave01 --- src/adagrams.js | 42 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index 7ec5afc7..e7ee6ed2 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -1,5 +1,45 @@ +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, +}; + + export const drawLetters = () => { - // Implement this method for wave 1 + let letters = []; + for (let i = 0; i < 10; ++i) { + let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + if (!letters.includes(letter) && LETTER_POOL[letter] > 0) { + LETTER_POOL[letter] -= 1; + letters.push(letter); + } else { + letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + }; + }; + return letters; }; export const usesAvailableLetters = (input, lettersInHand) => { From 58d46e13a85648cfdc0e4760e1e143cd29d03454 Mon Sep 17 00:00:00 2001 From: Elaine Date: Tue, 17 Jan 2023 14:19:54 -0800 Subject: [PATCH 02/16] change the drawLetters --- src/adagrams.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index e7ee6ed2..6ed0dd8e 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -32,7 +32,7 @@ export const drawLetters = () => { let letters = []; for (let i = 0; i < 10; ++i) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - if (!letters.includes(letter) && LETTER_POOL[letter] > 0) { + if (LETTER_POOL[letter] > 0) { LETTER_POOL[letter] -= 1; letters.push(letter); } else { From e17107a08317af39002677fbf3b0ae679634ea23 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sat, 21 Jan 2023 02:03:20 -0800 Subject: [PATCH 03/16] Finish Wave02 --- src/adagrams.js | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index 6ed0dd8e..d5b7bfe3 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -27,12 +27,11 @@ const LETTER_POOL = { Z: 1, }; - export const drawLetters = () => { let letters = []; for (let i = 0; i < 10; ++i) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - if (LETTER_POOL[letter] > 0) { + if ( LETTER_POOL[letter] > 0) { LETTER_POOL[letter] -= 1; letters.push(letter); } else { @@ -43,7 +42,22 @@ export const drawLetters = () => { }; export const usesAvailableLetters = (input, lettersInHand) => { - // Implement this method for wave 2 + input = input.toUpperCase(); + + let letterFreq = {}; + for (let i=0; i < lettersInHand.length; i++) { + letterFreq[lettersInHand[i]] = (letterFreq[lettersInHand[i]] || 0) +1 ; + }; + + for (let i=0; i < input.length; i++) { + let letter = input[i]; + if ((letter in letterFreq)&&(letterFreq[letter] > 0)) { + letterFreq[letter] -= 1; + } else { + return false; + } + }; + return true; }; export const scoreWord = (word) => { From 8307c2dec2dc8118b87b90cf7bf57e244477775e Mon Sep 17 00:00:00 2001 From: Elaine Date: Sat, 21 Jan 2023 02:26:34 -0800 Subject: [PATCH 04/16] start wave03 --- src/adagrams.js | 38 +++++++++++++++++++++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index d5b7bfe3..a2abb8d2 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -59,9 +59,45 @@ export const usesAvailableLetters = (input, lettersInHand) => { }; return true; }; +const LETTER_SCORE = { + 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 scoreWord = (word) => { - // Implement this method for wave 3 + word = word.toUpperCase(); + let point = 0; + for (let i=0; i < word.length; ++i){ + point += LETTER_SCORE[word[i]]; + } + if(word.length >= 7){ + point += 8; + } + return point; }; export const highestScoreFrom = (words) => { From e38aa82f013426390708ea085e9fc32c1ef60d93 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sat, 21 Jan 2023 02:46:59 -0800 Subject: [PATCH 05/16] Start wave04 --- src/adagrams.js | 21 ++++++++++++++++++++- test/adagrams.test.js | 2 +- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index a2abb8d2..f68f174b 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -101,5 +101,24 @@ export const scoreWord = (word) => { }; export const highestScoreFrom = (words) => { - // Implement this method for wave 4 + let highestWord = ""; + let highestScore = 0; + for (let word of words) { + let score = scoreWord(word); + if (score > highestScore){ + highestWord = word; + highestScore = score; + } else if (score === highestScore) { + if(highestWord.length === 10){ + continue; + } else if ((word.length === 10)||(highestWord.length > word.length)){ + highestWord = word; + highestScore = score; + }; + }; + }; + return { + word: highestWord, + score: highestScore + }; }; diff --git a/test/adagrams.test.js b/test/adagrams.test.js index 1a0dc94e..71d1d221 100644 --- a/test/adagrams.test.js +++ b/test/adagrams.test.js @@ -133,7 +133,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") }; From 2e1a2f1bf985f32e765a8a2fc9d7125667182057 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sat, 21 Jan 2023 03:25:12 -0800 Subject: [PATCH 06/16] add tests and finish wave03_04 --- src/adagrams.js | 95 +++++++++++++++++++++++-------------------- test/adagrams.test.js | 11 +++-- 2 files changed, 58 insertions(+), 48 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index f68f174b..e1b86ecb 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -1,38 +1,38 @@ -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, -}; export const drawLetters = () => { let letters = []; + let 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, + }; for (let i = 0; i < 10; ++i) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - if ( LETTER_POOL[letter] > 0) { - LETTER_POOL[letter] -= 1; + if ( letter_pool[letter] > 0) { + letter_pool[letter] -= 1; letters.push(letter); } else { letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); @@ -91,34 +91,39 @@ const LETTER_SCORE = { export const scoreWord = (word) => { word = word.toUpperCase(); let point = 0; + for (let i=0; i < word.length; ++i){ point += LETTER_SCORE[word[i]]; } + if(word.length >= 7){ point += 8; } + return point; }; export const highestScoreFrom = (words) => { - let highestWord = ""; - let highestScore = 0; + let highest = { + word: "", + score: 0 + } + for (let word of words) { - let score = scoreWord(word); - if (score > highestScore){ - highestWord = word; - highestScore = score; - } else if (score === highestScore) { - if(highestWord.length === 10){ + let point = scoreWord(word); + + if (point > highest.score){ + highest.word = word; + highest.score = point; + } else if (point === highest.score) { + if(highest.word.length === 10){ continue; - } else if ((word.length === 10)||(highestWord.length > word.length)){ - highestWord = word; - highestScore = score; + } else if ((word.length === 10)||(highest.word.length > word.length)){ + highest.word = word; + highest.score = point; }; }; }; - return { - word: highestWord, - score: highestScore - }; + + return highest }; diff --git a/test/adagrams.test.js b/test/adagrams.test.js index 71d1d221..f6a353ed 100644 --- a/test/adagrams.test.js +++ b/test/adagrams.test.js @@ -120,7 +120,11 @@ describe("Adagrams", () => { }); it("returns a score of 0 if given an empty input", () => { - throw "Complete test"; + expectScores({ + "": 0 + }); + + // throw "Complete test"; }); it("adds an extra 8 points if word is 7 or more characters long", () => { @@ -144,8 +148,9 @@ describe("Adagrams", () => { it("accurately finds best scoring word even if not sorted", () => { 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); + // throw "Complete test by adding an assertion"; }); describe("in case of tied score", () => { From 309e7b12cea5b81effb99b877b22f1d17b31f9ca Mon Sep 17 00:00:00 2001 From: Elaine Date: Sun, 22 Jan 2023 21:18:20 -0800 Subject: [PATCH 07/16] Finish Optional Wave05 --- src/adagrams.js | 2 +- src/adagrams_class.js | 148 ++++++++++++++++++++++++++ test/adagrams_class.test.js | 200 ++++++++++++++++++++++++++++++++++++ 3 files changed, 349 insertions(+), 1 deletion(-) create mode 100644 src/adagrams_class.js create mode 100644 test/adagrams_class.test.js diff --git a/src/adagrams.js b/src/adagrams.js index e1b86ecb..4afad62b 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -1,6 +1,6 @@ export const drawLetters = () => { - let letters = []; + let letters = new Array(); let letter_pool = { A: 9, B: 2, diff --git a/src/adagrams_class.js b/src/adagrams_class.js new file mode 100644 index 00000000..dde3cde3 --- /dev/null +++ b/src/adagrams_class.js @@ -0,0 +1,148 @@ +class Adagrams{ + 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, + }; + + LETTER_SCORE = { + 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, + }; + + constructor() { + this.input = ""; + this.word = ""; + this.highest = { + word: "", + score: 0 + }; + + this.lettersInHand = new Array(); + + }; + + drawLetters = () => { + + for (let i = 0; i < 10; ++i) { + let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + + if ( this.LETTER_POOL[letter] > 0) { + this.LETTER_POOL[letter] -= 1; + this.lettersInHand.push(letter); + } else { + letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + }; + }; + return this.lettersInHand; + }; + + usesAvailableLetters = (input, lettersInHand) => { + this.input = input.toUpperCase(); + this.lettersInHand = lettersInHand; + + let letterFreq = {}; + for (let i=0; i < this.lettersInHand.length; i++) { + let letter = this.lettersInHand[i] + letterFreq[letter] = (letterFreq[letter] || 0) +1 ; + }; + + for (let i=0; i < this.input.length; i++) { + let letter = this.input[i]; + if ((letter in letterFreq)&&(letterFreq[letter] > 0)) { + letterFreq[letter] -= 1; + } else { + return false; + } + }; + return true; + }; + + scoreWord = (word) => { + this.word = word.toUpperCase(); + let point = 0; + + for (let i=0; i < this.word.length; ++i){ + point += this.LETTER_SCORE[this.word[i]]; + } + + if(this.word.length >= 7){ + point += 8; + } + + return point; + }; + + highestScoreFrom = (words) => { + + for (let word of words) { + let point = this.scoreWord(word); + + if (point > this.highest.score){ + this.highest.word = word; + this.highest.score = point; + } else if (point === this.highest.score) { + if(this.highest.word.length === 10){ + continue; + } else if ((word.length === 10)||(this.highest.word.length > word.length)){ + this.highest.word = word; + this.highest.score = point; + }; + }; + }; + + return this.highest + }; + +;} + +export default Adagrams; + + diff --git a/test/adagrams_class.test.js b/test/adagrams_class.test.js new file mode 100644 index 00000000..d26225e8 --- /dev/null +++ b/test/adagrams_class.test.js @@ -0,0 +1,200 @@ +import Adagrams from "../src/adagrams_class" + +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, +}; + +describe("Adagrams", () => { + describe("drawLetters", () => { + it("draws ten letters from the letter pool", () => { + const drawn = new Adagrams().drawLetters(); + + expect(drawn).toHaveLength(10); + }); + + it("returns an array, and each item is a single-letter string", () => { + const drawn = new Adagrams().drawLetters(); + + expect(Array.isArray(drawn)).toBe(true); + drawn.forEach((l) => { + expect(l).toMatch(/^[A-Z]$/); + }); + }); + + it("does not draw a letter too many times", () => { + for (let i = 0; i < 1000; i++) { + const drawn = new Adagrams().drawLetters(); + const letter_freq = {}; + for (let letter of drawn) { + if (letter in letter_freq) { + letter_freq[letter] += 1; + } else { + letter_freq[letter] = 1; + } + } + + for (let letter of drawn) { + expect(letter_freq[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"; + + const isValid = new 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 = new 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 = new Adagrams().usesAvailableLetters(word, drawn); + expect(isValid).toBe(false); + }); + }); + + describe("scoreWord", () => { + const expectScores = (wordScores) => { + Object.entries(wordScores).forEach(([word, score]) => { + const expectScore = new Adagrams().scoreWord(word); + expect(expectScore).toBe(score); + }); + } + + it("returns an accurate numerical score according to the score chart", () => { + expectScores({ + A: 1, + DOG: 5, + WHIMSY: 17, + }); + }); + + it("returns a score regardless of the input case", () => { + expectScores({ + a: 1, + dog: 5, + wHiMsY: 17, + }); + }); + + it("returns a score of 0 if given an empty input", () => { + expectScores({ + "": 0 + }); + + // throw "Complete test"; + }); + + it("adds an extra 8 points if word is 7 or more characters long", () => { + expectScores({ + XXXXXXX: 64, + XXXXXXXX: 72, + XXXXXXXXX: 80, + XXXXXXXXXX: 88, + }); + }); + }); + + 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: new Adagrams().scoreWord("XXXX") }; + + expect(new 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: new Adagrams().scoreWord("XXXX") }; + + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); + // throw "Complete test by adding an assertion"; + }); + + describe("in case of tied score", () => { + const expectTie = (words) => { + const scores = words.map((word) => new Adagrams().scoreWord(word)); + const highScore = scores.reduce((h, s) => (h < s ? s : h), 0); + const tiedWords = scores.filter((s) => s == highScore); + + // Expect at least two tied words + expect(tiedWords.length).toBeGreaterThan(1); + }; + + it("selects the word with 10 letters", () => { + const words = ["AAAAAAAAAA", "BBBBBB"]; + const correct = { + word: "AAAAAAAAAA", + score: new Adagrams().scoreWord("AAAAAAAAAA"), + }; + expectTie(words); + + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); + expect(new 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: new Adagrams().scoreWord("WWW") }; + expectTie(words); + + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); + expect(new 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: new Adagrams().scoreWord("AAAAAAAAAA"), + }; + const second = { + word: "EEEEEEEEEE", + score: new Adagrams().scoreWord("EEEEEEEEEE"), + }; + expectTie(words); + + expect(new Adagrams().highestScoreFrom(words)).toEqual(first); + expect(new Adagrams().highestScoreFrom(words.reverse())).toEqual(second); + }); + }); + }); +}); From c7f9ebbd1bdae17b634ce8938d089106ef4cdbc7 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sun, 22 Jan 2023 21:21:17 -0800 Subject: [PATCH 08/16] Apply class to adagrams --- src/adagrams.js | 195 +++++++++++++++++++---------------- src/adagrams_class.js | 148 -------------------------- test/adagrams.test.js | 56 +++++----- test/adagrams_class.test.js | 200 ------------------------------------ 4 files changed, 133 insertions(+), 466 deletions(-) delete mode 100644 src/adagrams_class.js delete mode 100644 test/adagrams_class.test.js diff --git a/src/adagrams.js b/src/adagrams.js index 4afad62b..dde3cde3 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -1,7 +1,5 @@ - -export const drawLetters = () => { - let letters = new Array(); - let letter_pool = { +class Adagrams{ + LETTER_POOL = { A: 9, B: 2, C: 2, @@ -29,101 +27,122 @@ export const drawLetters = () => { Y: 2, Z: 1, }; - for (let i = 0; i < 10; ++i) { - let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - if ( letter_pool[letter] > 0) { - letter_pool[letter] -= 1; - letters.push(letter); - } else { - letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - }; + + LETTER_SCORE = { + 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, }; - return letters; -}; + + constructor() { + this.input = ""; + this.word = ""; + this.highest = { + word: "", + score: 0 + }; + + this.lettersInHand = new Array(); -export const usesAvailableLetters = (input, lettersInHand) => { - input = input.toUpperCase(); + }; - let letterFreq = {}; - for (let i=0; i < lettersInHand.length; i++) { - letterFreq[lettersInHand[i]] = (letterFreq[lettersInHand[i]] || 0) +1 ; + drawLetters = () => { + + for (let i = 0; i < 10; ++i) { + let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + + if ( this.LETTER_POOL[letter] > 0) { + this.LETTER_POOL[letter] -= 1; + this.lettersInHand.push(letter); + } else { + letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + }; + }; + return this.lettersInHand; }; - for (let i=0; i < input.length; i++) { - let letter = input[i]; - if ((letter in letterFreq)&&(letterFreq[letter] > 0)) { - letterFreq[letter] -= 1; - } else { - return false; + usesAvailableLetters = (input, lettersInHand) => { + this.input = input.toUpperCase(); + this.lettersInHand = lettersInHand; + + let letterFreq = {}; + for (let i=0; i < this.lettersInHand.length; i++) { + let letter = this.lettersInHand[i] + letterFreq[letter] = (letterFreq[letter] || 0) +1 ; + }; + + for (let i=0; i < this.input.length; i++) { + let letter = this.input[i]; + if ((letter in letterFreq)&&(letterFreq[letter] > 0)) { + letterFreq[letter] -= 1; + } else { + return false; + } + }; + return true; + }; + + scoreWord = (word) => { + this.word = word.toUpperCase(); + let point = 0; + + for (let i=0; i < this.word.length; ++i){ + point += this.LETTER_SCORE[this.word[i]]; } + + if(this.word.length >= 7){ + point += 8; + } + + return point; }; - return true; -}; -const LETTER_SCORE = { - 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 scoreWord = (word) => { - word = word.toUpperCase(); - let point = 0; - for (let i=0; i < word.length; ++i){ - point += LETTER_SCORE[word[i]]; - } + highestScoreFrom = (words) => { - if(word.length >= 7){ - point += 8; - } + for (let word of words) { + let point = this.scoreWord(word); + + if (point > this.highest.score){ + this.highest.word = word; + this.highest.score = point; + } else if (point === this.highest.score) { + if(this.highest.word.length === 10){ + continue; + } else if ((word.length === 10)||(this.highest.word.length > word.length)){ + this.highest.word = word; + this.highest.score = point; + }; + }; + }; - return point; -}; + return this.highest + }; -export const highestScoreFrom = (words) => { - let highest = { - word: "", - score: 0 - } +;} - for (let word of words) { - let point = scoreWord(word); +export default Adagrams; - if (point > highest.score){ - highest.word = word; - highest.score = point; - } else if (point === highest.score) { - if(highest.word.length === 10){ - continue; - } else if ((word.length === 10)||(highest.word.length > word.length)){ - highest.word = word; - highest.score = point; - }; - }; - }; - return highest -}; diff --git a/src/adagrams_class.js b/src/adagrams_class.js deleted file mode 100644 index dde3cde3..00000000 --- a/src/adagrams_class.js +++ /dev/null @@ -1,148 +0,0 @@ -class Adagrams{ - 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, - }; - - LETTER_SCORE = { - 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, - }; - - constructor() { - this.input = ""; - this.word = ""; - this.highest = { - word: "", - score: 0 - }; - - this.lettersInHand = new Array(); - - }; - - drawLetters = () => { - - for (let i = 0; i < 10; ++i) { - let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - - if ( this.LETTER_POOL[letter] > 0) { - this.LETTER_POOL[letter] -= 1; - this.lettersInHand.push(letter); - } else { - letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - }; - }; - return this.lettersInHand; - }; - - usesAvailableLetters = (input, lettersInHand) => { - this.input = input.toUpperCase(); - this.lettersInHand = lettersInHand; - - let letterFreq = {}; - for (let i=0; i < this.lettersInHand.length; i++) { - let letter = this.lettersInHand[i] - letterFreq[letter] = (letterFreq[letter] || 0) +1 ; - }; - - for (let i=0; i < this.input.length; i++) { - let letter = this.input[i]; - if ((letter in letterFreq)&&(letterFreq[letter] > 0)) { - letterFreq[letter] -= 1; - } else { - return false; - } - }; - return true; - }; - - scoreWord = (word) => { - this.word = word.toUpperCase(); - let point = 0; - - for (let i=0; i < this.word.length; ++i){ - point += this.LETTER_SCORE[this.word[i]]; - } - - if(this.word.length >= 7){ - point += 8; - } - - return point; - }; - - highestScoreFrom = (words) => { - - for (let word of words) { - let point = this.scoreWord(word); - - if (point > this.highest.score){ - this.highest.word = word; - this.highest.score = point; - } else if (point === this.highest.score) { - if(this.highest.word.length === 10){ - continue; - } else if ((word.length === 10)||(this.highest.word.length > word.length)){ - this.highest.word = word; - this.highest.score = point; - }; - }; - }; - - return this.highest - }; - -;} - -export default Adagrams; - - diff --git a/test/adagrams.test.js b/test/adagrams.test.js index f6a353ed..74f77763 100644 --- a/test/adagrams.test.js +++ b/test/adagrams.test.js @@ -1,9 +1,4 @@ -import { - drawLetters, - usesAvailableLetters, - scoreWord, - highestScoreFrom, -} from "adagrams"; +import Adagrams from "../src/adagrams" const LETTER_POOL = { A: 9, @@ -37,13 +32,13 @@ const LETTER_POOL = { describe("Adagrams", () => { describe("drawLetters", () => { it("draws ten letters from the letter pool", () => { - const drawn = drawLetters(); + const drawn = new Adagrams().drawLetters(); expect(drawn).toHaveLength(10); }); it("returns an array, and each item is a single-letter string", () => { - const drawn = drawLetters(); + const drawn = new Adagrams().drawLetters(); expect(Array.isArray(drawn)).toBe(true); drawn.forEach((l) => { @@ -53,7 +48,7 @@ describe("Adagrams", () => { it("does not draw a letter too many times", () => { for (let i = 0; i < 1000; i++) { - const drawn = drawLetters(); + const drawn = new Adagrams().drawLetters(); const letter_freq = {}; for (let letter of drawn) { if (letter in letter_freq) { @@ -75,7 +70,7 @@ describe("Adagrams", () => { const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"]; const word = "DOG"; - const isValid = usesAvailableLetters(word, drawn); + const isValid = new Adagrams().usesAvailableLetters(word, drawn); expect(isValid).toBe(true); }); @@ -83,7 +78,7 @@ describe("Adagrams", () => { const drawn = ["D", "O", "X", "X", "X", "X", "X", "X", "X", "X"]; const word = "DOG"; - const isValid = usesAvailableLetters(word, drawn); + const isValid = new Adagrams().usesAvailableLetters(word, drawn); expect(isValid).toBe(false); }); @@ -91,7 +86,7 @@ describe("Adagrams", () => { const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"]; const word = "GOOD"; - const isValid = usesAvailableLetters(word, drawn); + const isValid = new Adagrams().usesAvailableLetters(word, drawn); expect(isValid).toBe(false); }); }); @@ -99,9 +94,10 @@ describe("Adagrams", () => { describe("scoreWord", () => { const expectScores = (wordScores) => { Object.entries(wordScores).forEach(([word, score]) => { - expect(scoreWord(word)).toBe(score); - }); - }; + const expectScore = new Adagrams().scoreWord(word); + expect(expectScore).toBe(score); + }); + } it("returns an accurate numerical score according to the score chart", () => { expectScores({ @@ -140,22 +136,22 @@ describe("Adagrams", () => { 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: new Adagrams().scoreWord("XXXX") }; - expect(highestScoreFrom(words)).toEqual(correct); + expect(new 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: new Adagrams().scoreWord("XXXX") }; - expect(highestScoreFrom(words)).toEqual(correct); + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); // throw "Complete test by adding an assertion"; }); describe("in case of tied score", () => { const expectTie = (words) => { - const scores = words.map((word) => scoreWord(word)); + const scores = words.map((word) => new Adagrams().scoreWord(word)); const highScore = scores.reduce((h, s) => (h < s ? s : h), 0); const tiedWords = scores.filter((s) => s == highScore); @@ -167,37 +163,37 @@ describe("Adagrams", () => { const words = ["AAAAAAAAAA", "BBBBBB"]; const correct = { word: "AAAAAAAAAA", - score: scoreWord("AAAAAAAAAA"), + score: new Adagrams().scoreWord("AAAAAAAAAA"), }; expectTie(words); - expect(highestScoreFrom(words)).toEqual(correct); - expect(highestScoreFrom(words.reverse())).toEqual(correct); + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); + expect(new 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: new Adagrams().scoreWord("WWW") }; expectTie(words); - expect(highestScoreFrom(words)).toEqual(correct); - expect(highestScoreFrom(words.reverse())).toEqual(correct); + expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); + expect(new 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: new Adagrams().scoreWord("AAAAAAAAAA"), }; const second = { word: "EEEEEEEEEE", - score: scoreWord("EEEEEEEEEE"), + score: new Adagrams().scoreWord("EEEEEEEEEE"), }; expectTie(words); - expect(highestScoreFrom(words)).toEqual(first); - expect(highestScoreFrom(words.reverse())).toEqual(second); + expect(new Adagrams().highestScoreFrom(words)).toEqual(first); + expect(new Adagrams().highestScoreFrom(words.reverse())).toEqual(second); }); }); }); diff --git a/test/adagrams_class.test.js b/test/adagrams_class.test.js deleted file mode 100644 index d26225e8..00000000 --- a/test/adagrams_class.test.js +++ /dev/null @@ -1,200 +0,0 @@ -import Adagrams from "../src/adagrams_class" - -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, -}; - -describe("Adagrams", () => { - describe("drawLetters", () => { - it("draws ten letters from the letter pool", () => { - const drawn = new Adagrams().drawLetters(); - - expect(drawn).toHaveLength(10); - }); - - it("returns an array, and each item is a single-letter string", () => { - const drawn = new Adagrams().drawLetters(); - - expect(Array.isArray(drawn)).toBe(true); - drawn.forEach((l) => { - expect(l).toMatch(/^[A-Z]$/); - }); - }); - - it("does not draw a letter too many times", () => { - for (let i = 0; i < 1000; i++) { - const drawn = new Adagrams().drawLetters(); - const letter_freq = {}; - for (let letter of drawn) { - if (letter in letter_freq) { - letter_freq[letter] += 1; - } else { - letter_freq[letter] = 1; - } - } - - for (let letter of drawn) { - expect(letter_freq[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"; - - const isValid = new 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 = new 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 = new Adagrams().usesAvailableLetters(word, drawn); - expect(isValid).toBe(false); - }); - }); - - describe("scoreWord", () => { - const expectScores = (wordScores) => { - Object.entries(wordScores).forEach(([word, score]) => { - const expectScore = new Adagrams().scoreWord(word); - expect(expectScore).toBe(score); - }); - } - - it("returns an accurate numerical score according to the score chart", () => { - expectScores({ - A: 1, - DOG: 5, - WHIMSY: 17, - }); - }); - - it("returns a score regardless of the input case", () => { - expectScores({ - a: 1, - dog: 5, - wHiMsY: 17, - }); - }); - - it("returns a score of 0 if given an empty input", () => { - expectScores({ - "": 0 - }); - - // throw "Complete test"; - }); - - it("adds an extra 8 points if word is 7 or more characters long", () => { - expectScores({ - XXXXXXX: 64, - XXXXXXXX: 72, - XXXXXXXXX: 80, - XXXXXXXXXX: 88, - }); - }); - }); - - 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: new Adagrams().scoreWord("XXXX") }; - - expect(new 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: new Adagrams().scoreWord("XXXX") }; - - expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); - // throw "Complete test by adding an assertion"; - }); - - describe("in case of tied score", () => { - const expectTie = (words) => { - const scores = words.map((word) => new Adagrams().scoreWord(word)); - const highScore = scores.reduce((h, s) => (h < s ? s : h), 0); - const tiedWords = scores.filter((s) => s == highScore); - - // Expect at least two tied words - expect(tiedWords.length).toBeGreaterThan(1); - }; - - it("selects the word with 10 letters", () => { - const words = ["AAAAAAAAAA", "BBBBBB"]; - const correct = { - word: "AAAAAAAAAA", - score: new Adagrams().scoreWord("AAAAAAAAAA"), - }; - expectTie(words); - - expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); - expect(new 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: new Adagrams().scoreWord("WWW") }; - expectTie(words); - - expect(new Adagrams().highestScoreFrom(words)).toEqual(correct); - expect(new 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: new Adagrams().scoreWord("AAAAAAAAAA"), - }; - const second = { - word: "EEEEEEEEEE", - score: new Adagrams().scoreWord("EEEEEEEEEE"), - }; - expectTie(words); - - expect(new Adagrams().highestScoreFrom(words)).toEqual(first); - expect(new Adagrams().highestScoreFrom(words.reverse())).toEqual(second); - }); - }); - }); -}); From 8679811b3b470fb3ddeba8094d7e83d559e11ea3 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sun, 22 Jan 2023 22:37:46 -0800 Subject: [PATCH 09/16] correct drawLetters --- src/adagrams.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index dde3cde3..1e144f68 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -77,9 +77,9 @@ class Adagrams{ if ( this.LETTER_POOL[letter] > 0) { this.LETTER_POOL[letter] -= 1; this.lettersInHand.push(letter); - } else { - letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - }; + } + letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); + }; return this.lettersInHand; }; From 2df381552a7f13b163895c1e30f0bb9b11780032 Mon Sep 17 00:00:00 2001 From: Elaine Date: Sun, 22 Jan 2023 22:43:13 -0800 Subject: [PATCH 10/16] Change drawLetters --- src/adagrams.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index 1e144f68..16872dfa 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -71,7 +71,7 @@ class Adagrams{ drawLetters = () => { - for (let i = 0; i < 10; ++i) { + while (this.lettersInHand.length < 10) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); if ( this.LETTER_POOL[letter] > 0) { From afdb887e81c296fb3cfa51a79ad30edc54a66cc8 Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 13:50:37 -0800 Subject: [PATCH 11/16] Start demo_game --- src/adagrams.js | 2 +- src/demo/model.js | 7 +++++++ test/demo/model.test.js | 6 +++--- 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index 16872dfa..d6879d36 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -74,7 +74,7 @@ class Adagrams{ while (this.lettersInHand.length < 10) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); - if ( this.LETTER_POOL[letter] > 0) { + if (this.LETTER_POOL[letter] > 0) { this.LETTER_POOL[letter] -= 1; this.lettersInHand.push(letter); } diff --git a/src/demo/model.js b/src/demo/model.js index 1a0ba47b..2335a7e6 100644 --- a/src/demo/model.js +++ b/src/demo/model.js @@ -80,6 +80,13 @@ class Model { _valid(word, letterBank = this.letterBank) { if(word.length < 1) return false; + + for(let i=0; i < word.length; ++i){ + + if (!(/^[A-Z]$/.test(word[i])) ){ + return false; + } + } return Adagrams.usesAvailableLetters(word, letterBank); } diff --git a/test/demo/model.test.js b/test/demo/model.test.js index 49bf9599..ca84b9db 100644 --- a/test/demo/model.test.js +++ b/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', @@ -318,9 +318,9 @@ describe.skip('Game Model', () => { it('it returns null', () => { const model = getModel(); const word = getWord(model); - - expect(model.playWord(word)).toBe(null); + expect(model.playWord('123')).toBe(null); + expect(model.playWord(word)).toBe(null); expect(model.playWord('')).toBe(null); }); From 2e2f74b96196c8385aaf44a469b3751f509d4251 Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 14:11:17 -0800 Subject: [PATCH 12/16] Add input validation helper --- src/adagrams.js | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index d6879d36..17550872 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -83,9 +83,24 @@ class Adagrams{ }; return this.lettersInHand; }; - + + isValid(word){ + if(word.length < 1) return false; + + for(let i=0; i < word.length; ++i){ + + if (!(/^[A-Z]$/.test(word[i])) ){ + return false; + } + } + return true; + }; + usesAvailableLetters = (input, lettersInHand) => { this.input = input.toUpperCase(); + if (!this.isValid(this.input)){ + return false; + } this.lettersInHand = lettersInHand; let letterFreq = {}; From 46f493a1185241d9a48a450f284a5c940db85c2d Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 14:20:48 -0800 Subject: [PATCH 13/16] Add input validation to scoreWord --- src/adagrams.js | 3 +++ test/adagrams.test.js | 1 - 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/adagrams.js b/src/adagrams.js index 17550872..8d52d325 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -122,6 +122,9 @@ class Adagrams{ scoreWord = (word) => { this.word = word.toUpperCase(); + if (!this.isValid(this.word)){ + return 0; + } let point = 0; for (let i=0; i < this.word.length; ++i){ diff --git a/test/adagrams.test.js b/test/adagrams.test.js index 74f77763..b41b3641 100644 --- a/test/adagrams.test.js +++ b/test/adagrams.test.js @@ -119,7 +119,6 @@ describe("Adagrams", () => { expectScores({ "": 0 }); - // throw "Complete test"; }); From 2770af8cc19eba33c59382088919b45b5190ec6b Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 17:52:36 -0800 Subject: [PATCH 14/16] fix class method --- src/adagrams.js | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/adagrams.js b/src/adagrams.js index 8d52d325..ef896a69 100644 --- a/src/adagrams.js +++ b/src/adagrams.js @@ -69,8 +69,7 @@ class Adagrams{ }; - drawLetters = () => { - + drawLetters() { while (this.lettersInHand.length < 10) { let letter = String.fromCharCode(Math.floor(Math.random() * 26) + 65); @@ -84,7 +83,7 @@ class Adagrams{ return this.lettersInHand; }; - isValid(word){ + isValid(word) { if(word.length < 1) return false; for(let i=0; i < word.length; ++i){ @@ -96,7 +95,7 @@ class Adagrams{ return true; }; - usesAvailableLetters = (input, lettersInHand) => { + usesAvailableLetters(input, lettersInHand) { this.input = input.toUpperCase(); if (!this.isValid(this.input)){ return false; @@ -120,7 +119,7 @@ class Adagrams{ return true; }; - scoreWord = (word) => { + scoreWord(word) { this.word = word.toUpperCase(); if (!this.isValid(this.word)){ return 0; @@ -138,7 +137,7 @@ class Adagrams{ return point; }; - highestScoreFrom = (words) => { + highestScoreFrom(words) { for (let word of words) { let point = this.scoreWord(word); From 98cb5099bd68d8ca268467361bb608b895c76d59 Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 17:53:02 -0800 Subject: [PATCH 15/16] Apply class to demo --- src/demo/adagrams.js | 16 +++------------- test/demo/model.test.js | 6 +++--- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/src/demo/adagrams.js b/src/demo/adagrams.js index 135abd7f..d21d3240 100644 --- a/src/demo/adagrams.js +++ b/src/demo/adagrams.js @@ -1,16 +1,6 @@ -import { - drawLetters, - usesAvailableLetters, - scoreWord, - highestScoreFrom, -} from "adagrams"; - -const Real = { - drawLetters, - usesAvailableLetters, - scoreWord, - highestScoreFrom, -}; +import Adagrams from "../adagrams"; + +const Real = new Adagrams(); const Stub = { drawLetters() { diff --git a/test/demo/model.test.js b/test/demo/model.test.js index ca84b9db..d9ea1c77 100644 --- a/test/demo/model.test.js +++ b/test/demo/model.test.js @@ -318,9 +318,9 @@ describe('Game Model', () => { it('it returns null', () => { const model = getModel(); const word = getWord(model); - - expect(model.playWord('123')).toBe(null); + expect(model.playWord(word)).toBe(null); + expect(model.playWord('123')).toBe(null); expect(model.playWord('')).toBe(null); }); @@ -335,4 +335,4 @@ describe('Game Model', () => { }); }); }); -}); +}); \ No newline at end of file From 7e2fa49e64ccaa19ee774905297da208d8e0ebc2 Mon Sep 17 00:00:00 2001 From: Elaine Date: Mon, 23 Jan 2023 18:09:57 -0800 Subject: [PATCH 16/16] recover it to the original --- src/demo/model.js | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/src/demo/model.js b/src/demo/model.js index 2335a7e6..635cd73f 100644 --- a/src/demo/model.js +++ b/src/demo/model.js @@ -19,7 +19,6 @@ class Model { ["APPLE", "PAPA", "LEAP"], // round 1 ["WALK", "WALKER", "RAKE"], // round 2 ], - playerTwo: [ ["PALE", "PELT"], // round 1 ["REAL", "WALTER", "TALKER"], // round 2 @@ -80,13 +79,6 @@ class Model { _valid(word, letterBank = this.letterBank) { if(word.length < 1) return false; - - for(let i=0; i < word.length; ++i){ - - if (!(/^[A-Z]$/.test(word[i])) ){ - return false; - } - } return Adagrams.usesAvailableLetters(word, letterBank); } @@ -144,4 +136,4 @@ class Model { } } -export default Model; +export default Model; \ No newline at end of file