From a1f48980c6e3f8342df59c9b7f56ac8dd8642a7a Mon Sep 17 00:00:00 2001 From: Kirsten Anderson Date: Sun, 15 Sep 2019 16:46:25 -0700 Subject: [PATCH 1/2] all tests pass --- lib/exercises.js | 65 ++++++++++++++++++++++++++++++++++++++++-- test/exercises.test.js | 52 +++++++++++++++++++++++++++++---- 2 files changed, 110 insertions(+), 7 deletions(-) diff --git a/lib/exercises.js b/lib/exercises.js index 648394e..99944a7 100644 --- a/lib/exercises.js +++ b/lib/exercises.js @@ -3,7 +3,22 @@ // Time Complexity: ? // Space Complexity: ? function grouped_anagrams(strings) { - throw new Error("Method hasn't been implemented yet!"); + const indexHash = {}; + strings.forEach ((string) => { + const tempString = string.split('').sort().join(''); + if (!indexHash[tempString]) { + indexHash[tempString] = [string]; + } else { + indexHash[tempString].push(string); + } + }) + + const returnArray = [] + + for (let key in indexHash) { + returnArray.push(indexHash[key]) + } +return returnArray; } // This method will return the k most common elements @@ -23,7 +38,53 @@ function top_k_frequent_elements(list, k) { // Time Complexity: ? // Space Complexity: ? function valid_sudoku(table) { - throw new Error("Method hasn't been implemented yet!"); + // check rows + + for (let row = 0; row < table.length; row++) { + const rowHash = {}; + for (let i = 0; i < table[row].length; i++) { + let char = table[row][i] + if (char !== ".") { + if (rowHash[char]) { + return false; + } + rowHash[char] = 1; + } + } + } + + for (let i = 0; i < table[0].length; i++) { + const colHash = {}; + for (let col = 0; col < table.length; col++) { + let char = table[col][i]; + if (char !== '.') { + if (colHash[char]) { + return false; + } + colHash[char] = 1; + } + } + } + + const subboxes = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]; + + for (let counter1 = 0; counter1 < 3; counter1++) { + for (let counter2 = 0; counter2 < 3; counter2++) { + const subboxHash = {}; + for (let counter3 = 0; counter3 < 3; counter3++) { + for (let counter4 = 0; counter4 < 3; counter4++) { + let char = table[subboxes[counter1][counter3]][subboxes[counter2][counter4]]; + if (char !== '.') { + if (subboxHash[char]) { + return false; + } + subboxHash[char] = 1; + } + } + } + } + } + return true; } module.exports = { diff --git a/test/exercises.test.js b/test/exercises.test.js index 93461ab..6dc6b24 100644 --- a/test/exercises.test.js +++ b/test/exercises.test.js @@ -137,7 +137,49 @@ describe("exercises", function() { }); }); - describe.skip("valid sudoku", function() { + describe("valid sudoku", function() { + it("is not valid if a row has duplicate values", function() { + // Arrange + const table = [ + ["5","3",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".","5","5",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."] + ]; + + // Act + const valid = valid_sudoku(table); + + // Assert + expect(valid).to.be.false; + }); + + it("is not valid if a column has duplicate values", function() { + // Arrange + const table = [ + ["5",".",".",".",".",".",".",".","."], + ["2",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".","4",".",".",".","."], + [".",".",".",".","4",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."], + [".",".",".",".",".",".",".",".","."] + ]; + + // Act + const valid = valid_sudoku(table); + + // Assert + expect(valid).to.be.false; + }); + it("works for the table given in the README", function() { // Arrange const table = [ @@ -156,7 +198,7 @@ describe("exercises", function() { const valid = valid_sudoku(table); // Assert - expect(valid).toEqual(true); + expect(valid).to.eql(true); }); it("fails for the table given in the README", function() { @@ -177,7 +219,7 @@ describe("exercises", function() { const valid = valid_sudoku(table); // Assert - expect(valid).toEqual(false); + expect(valid).to.eql(false); }); it("fails for a duplicate number in a sub-box", function() { @@ -198,7 +240,7 @@ describe("exercises", function() { const valid = valid_sudoku(table); // Assert - expect(valid).toEqual(false); + expect(valid).to.eql(false); }); it("fails for a duplicate number in a bottom right sub-box", function() { @@ -219,7 +261,7 @@ describe("exercises", function() { const valid = valid_sudoku(table); // Assert - expect(valid).toEqual(false); + expect(valid).to.eql(false); }); }); }); From 3ef92d1a7b874462da870f3795c92201c1de7924 Mon Sep 17 00:00:00 2001 From: Kirsten Anderson Date: Sun, 15 Sep 2019 17:04:00 -0700 Subject: [PATCH 2/2] time and space complexity --- lib/exercises.js | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/lib/exercises.js b/lib/exercises.js index 99944a7..13fd8cc 100644 --- a/lib/exercises.js +++ b/lib/exercises.js @@ -1,7 +1,7 @@ // This method will return an array of arrays. // Each subarray will have strings which are anagrams of each other -// Time Complexity: ? -// Space Complexity: ? +// Time Complexity: O(n log n), where n is the combined length of the input strings (since the strings are being sorted) +// Space Complexity: O(n), where n is the length of the input array. function grouped_anagrams(strings) { const indexHash = {}; strings.forEach ((string) => { @@ -21,22 +21,14 @@ function grouped_anagrams(strings) { return returnArray; } -// This method will return the k most common elements -// in the case of a tie it will select the first occuring element. -// Time Complexity: ? -// Space Complexity: ? -function top_k_frequent_elements(list, k) { - throw new Error("Method hasn't been implemented yet!"); -} - // This method will return the true if the table is still // a valid sudoku table. // Each element can either be a ".", or a digit 1-9 // The same digit cannot appear twice or more in the same // row, column or 3x3 subgrid -// Time Complexity: ? -// Space Complexity: ? +// Time Complexity: O(n), where n is the number of elements in the sudoku table +// Space Complexity: O(n), where n is the number of elements in the sudoku table function valid_sudoku(table) { // check rows