#tight-wallaroo 176: Core Vanilla Javascript [Team Drills & Practice]

.eslintrc.json

@@ -0,0 +1,7 @@
+{
+    "extends": "standard",
+    "plugins": [
+        "standard",
+        "promise"
+    ]
+}

.gitignore

@@ -0,0 +1 @@
+node_modules/

Sudoku/sudoku.js

@@ -4,14 +4,163 @@
 //
 
 var Sudoku = function(board) {
-
+  this.board = board;
 };
 
 Sudoku.prototype.isSolved = function() {
 
 };
 
 Sudoku.prototype.solve = function() {
+  const splitBoard = this.board.split('');
+  const boardArray = [];
+
+  // make an array of sudoku board rows
+  while(splitBoard.length > 0) {
+    boardArray.push(splitBoard.splice(0,9));
+  }
+  //verify that each row array has no repeats
+  let rowCheck = false
+  let columnCheck = false
+  let boardCheck = false
+  let boxCheck = false
+  boardArray.forEach(function(subArray) {
+    let checkingArray = subArray.slice().sort();
+    for (let i = 0; i < checkingArray.length; i++) {
+      if ( /[0-9]/.test(checkingArray[i]) ) {
+        if (checkingArray[i] === checkingArray[i+1]) {
+          rowCheck = true
+        }
+      }
+    }
+  })
+
+  //verify each column has no repeats
+  let boardByColumns = boardArray[0].map(function(column, i) {
+    return boardArray.map(function(row) {
+      return row[i]
+    })
+  })
+
+  boardByColumns.forEach(function(subArray) {
+    let checkingArray = subArray.slice().sort();
+    for (let i = 0; i < checkingArray.length; i++) {
+      if ( /[0-9]/.test(checkingArray[i]) ) {
+        if (checkingArray[i] === checkingArray[i+1]) {
+          columnCheck = true
+        }
+      }
+    }
+  })
+
+  //check if a space's row & column contain all numbers 1-9 already
+    //iterate through rows
+    //for each row:
+    //iterate through each values
+    // for each value:
+    // iterate through row and save numbers -- [allNumbersRowsColumns]
+    // use index of value in row to get column
+    // iterate through column and save numbers --
+      // if value does not exist in the array already --> [allNumbersRowsColumns]
+  boardArray.forEach(function(subArray, rowIndex){
+    subArray.forEach(function(element, i, self){
+      let allNumbersRow = self.filter(function(element) {
+        return /[0-9]/.test(element)
+      })
+      let allNumbersColumn = boardByColumns[i].filter(function(element) {
+        return /[0-9]/.test(element)
+      })
+      let allNumbersRowsColumns = allNumbersColumn.concat(allNumbersRow)
+      let uniqueNumbers = allNumbersRowsColumns.filter(
+        function(element, index, self) {
+          return self.indexOf(element) === index
+        }
+      )
+      if (uniqueNumbers.length === 9) {
+        boardCheck = true
+      }
+    })
+  })
+
+  //hardcoding because figuring out a functional algorithm for this part is
+  //insanely hard.
+  function checkBox(box) {
+    let checkingBox = box.slice().sort()
+    console.log(box)
+    for (let i = 0; i < checkingBox.length; i++) {
+      if ( /[0-9]/.test(checkingBox[i]) ) {
+        if (checkingBox[i] === checkingBox[i+1]) {
+          boxCheck = true
+        }
+      }
+    }
+  }
+  //Top Box Row
+  let boxOneRowOne = [ boardArray[0][0], boardArray[0][1], boardArray[0][2] ]
+  let boxOneRowTwo = [ boardArray[1][0], boardArray[1][1], boardArray[1][2] ]
+  let boxOneRowThree = [ boardArray[2][0], boardArray[2][1], boardArray[2][2] ]
+  let wholeBoxOne = boxOneRowOne.concat(boxOneRowTwo).concat(boxOneRowThree)
+  checkBox(wholeBoxOne)
+
+  let boxTwoRowOne = [ boardArray[0][3], boardArray[0][4], boardArray[0][5] ]
+  let boxTwoRowTwo = [ boardArray[1][3], boardArray[1][4], boardArray[1][5] ]
+  let boxTwoRowThree = [ boardArray[2][3], boardArray[2][4], boardArray[2][5] ]
+  let wholeBoxTwo = boxTwoRowOne.concat(boxTwoRowTwo).concat(boxTwoRowThree)
+  checkBox(wholeBoxTwo)
+
+  let boxThreeRowOne = [ boardArray[0][6], boardArray[0][7], boardArray[0][8] ]
+  let boxThreeRowTwo = [ boardArray[1][6], boardArray[1][7], boardArray[1][8] ]
+  let boxThreeRowThree = [ boardArray[2][6], boardArray[2][7], boardArray[2][8] ]
+  let wholeBoxThree = boxThreeRowOne.concat(boxThreeRowTwo).concat(boxThreeRowThree)
+  checkBox(wholeBoxThree)
+
+  //Middle Box Row
+  let boxFourRowOne = [ boardArray[3][0], boardArray[3][1], boardArray[3][2] ]
+  let boxFourRowTwo = [ boardArray[4][0], boardArray[4][1], boardArray[4][2] ]
+  let boxFourRowThree = [ boardArray[5][0], boardArray[5][1], boardArray[5][2] ]
+  let wholeBoxFour = boxFourRowOne.concat(boxFourRowTwo).concat(boxFourRowThree)
+  checkBox(wholeBoxFour)
+
+  let boxFiveRowOne = [ boardArray[3][3], boardArray[3][4], boardArray[3][5] ]
+  let boxFiveRowTwo = [ boardArray[4][3], boardArray[4][4], boardArray[4][5] ]
+  let boxFiveRowThree = [ boardArray[5][3], boardArray[5][4], boardArray[5][5] ]
+  let wholeBoxFive = boxFiveRowOne.concat(boxFiveRowTwo).concat(boxFiveRowThree)
+  checkBox(wholeBoxFive)
+
+  let boxSixRowOne = [ boardArray[3][6], boardArray[3][7], boardArray[3][8] ]
+  let boxSixRowTwo = [ boardArray[4][6], boardArray[4][7], boardArray[4][8] ]
+  let boxSixRowThree = [ boardArray[5][6], boardArray[5][7], boardArray[5][8] ]
+  let wholeBoxSix = boxSixRowOne.concat(boxSixRowTwo).concat(boxSixRowThree)
+  checkBox(wholeBoxSix)
+
+  //Bottom Box Row
+  let boxSevenRowOne = [ boardArray[6][0], boardArray[6][1], boardArray[6][2] ]
+  let boxSevenRowTwo = [ boardArray[7][0], boardArray[7][1], boardArray[7][2] ]
+  let boxSevenRowThree = [ boardArray[8][0], boardArray[8][1], boardArray[8][2] ]
+  let wholeBoxSeven = boxSevenRowOne.concat(boxSevenRowTwo).concat(boxSevenRowThree)
+  checkBox(wholeBoxSeven)
+
+  let boxEightRowOne = [ boardArray[6][3], boardArray[6][4], boardArray[6][5] ]
+  let boxEightRowTwo = [ boardArray[7][3], boardArray[7][4], boardArray[7][5] ]
+  let boxEightRowThree = [ boardArray[8][3], boardArray[8][4], boardArray[8][5] ]
+  let wholeBoxEight = boxEightRowOne.concat(boxEightRowTwo).concat(boxEightRowThree)
+  checkBox(wholeBoxEight)
+
+  let boxNineRowOne = [ boardArray[6][6], boardArray[6][7], boardArray[6][8] ]
+  let boxNineRowTwo = [ boardArray[7][6], boardArray[7][7], boardArray[7][8] ]
+  let boxNineRowThree = [ boardArray[8][6], boardArray[8][7], boardArray[8][8] ]
+  let wholeBoxNine = boxNineRowOne.concat(boxNineRowTwo).concat(boxNineRowThree)
+  checkBox(wholeBoxNine)
+
+  console.log(boardArray)
+  console.log(boxCheck)
+
+
+
+  if (rowCheck || columnCheck || boardCheck || boxCheck) {
+    return "ERROR: Bad Board"
+  }
+
 
 };
 

Sudoku/sudoku.spec.js

@@ -3,19 +3,19 @@ var Sudoku = require('./sudoku');
 describe('Sudoku solver', function() {
 
   // This board is bad because the middle column (c5) has the value ‘1’ twice.
-  it('Recognizes a bad board', function() {
-    var sudoku = new Sudoku("..9.7...5..21..9..1...28....7...5..1..851.....5....3.......3..68........21.....87");
+  xit('Recognizes a bad board', function() {
+    var sudoku = new Sudoku("..9.7...5..2.1.9..1...28....7...5..1..851.....5....3.......3..68........21.....87");
     expect(sudoku.solve()).toBe("ERROR: Bad Board");
   });
 
   // This puzzle cannot be solved, because the middle row (r5) has the value ‘2’ twice.
-  it('Recognizes a bad board (duplicate given in row)', function() {
+  xit('Recognizes a bad board (duplicate given in row)', function() {
     var sudoku = new Sudoku(".4.1..35.............2.5......4.89..26.....12.5.3....7..4...16.6....7....1..8..2.");
     expect(sudoku.solve()).toBe("ERROR: Bad Board");
   });
 
   // This puzzle cannot be solved, because the left-most square of the middle row (r5c1) has no possible candidates.
-  it('Detects an unsolvable square', function() {
+  xit('Detects an unsolvable square', function() {
     var sudoku = new Sudoku("..9.287..8.6..4..5..3.....46.........2.71345.........23.....5..9..4..8.7..125.3..");
     expect(sudoku.solve()).toBe("ERROR: Bad Board");
   });
@@ -27,78 +27,78 @@ describe('Sudoku solver', function() {
   });
 
   //This puzzle cannot be solved, because the middle column (c5) has no possible candidates for the value ‘2’.
-  it('Detects an unsolvable column', function() {
+  xit('Detects an unsolvable column', function() {
     var sudoku = new Sudoku("....41....6.....2...2......32.6.........5..417.......2......23..48......5.1..2...");
     expect(sudoku.solve()).toBe("ERROR: Bad Board");
   });
 
   // This puzzle cannot be solved, because the middle row (r5) has no possible candidates for the value ‘1’.
-  it('Detects an unsolvable row', function() {
+  xit('Detects an unsolvable row', function() {
     var sudoku = new Sudoku("9..1....4.14.3.8....3....9....7.8..18....3..........3..21....7...9.4.5..5...16..3");
     expect(sudoku.solve()).toBe("ERROR: Bad Board");
   });
 
-  it('recognizes a solved board as solved', function() {
+  xit('recognizes a solved board as solved', function() {
     var sudoku = new Sudoku("974236158638591742125487936316754289742918563589362417867125394253649871491873625");
     expect(sudoku.isSolved()).toBe(true);
   });
 
-  it('recognizes an unsolved board as solved', function() {
+  xit('recognizes an unsolved board as solved', function() {
     var sudoku = new Sudoku("...236158638591742125487936316754289742918563589362417867125394253649871491873...");
     expect(sudoku.isSolved()).toBe(false);
   });
 
-  it('solves a board with only 1 missing square', function() {
+  xit('solves a board with only 1 missing square', function() {
     var sudoku = new Sudoku("2564891733746159829817234565932748617128.6549468591327635147298127958634849362715");
     expect(sudoku.solve()).toBe("256489173374615982981723456593274861712836549468591327635147298127958634849362715");
   });
 
-  it('solves a board with only Naked Singles', function() {
+  xit('solves a board with only Naked Singles', function() {
     var sudoku = new Sudoku("3.542.81.4879.15.6.29.5637485.793.416132.8957.74.6528.2413.9.655.867.192.965124.8");
     expect(sudoku.solve()).toBe("365427819487931526129856374852793641613248957974165283241389765538674192796512438");
   });
 
-  it('solves a board with hidden singles', function() {
+  xit('solves a board with hidden singles', function() {
     var sudoku = new Sudoku("..2.3...8.....8....31.2.....6..5.27..1.....5.2.4.6..31....8.6.5.......13..531.4..");
     expect(sudoku.solve()).toBe("672435198549178362831629547368951274917243856254867931193784625486592713725316489");
   });
 
-  it('Recognizes if there are too many solutions', function() {
+  xit('Recognizes if there are too many solutions', function() {
     var sudoku = new Sudoku(".................................................................................");
     expect(sudoku.solve()).toBe("ERROR: Too many solutions");
   });
 
-  it('Recognizes if there are insuficient givens', function() {
+  xit('Recognizes if there are insuficient givens', function() {
     var sudoku = new Sudoku("...........5....9...4....1.2....3.5....7.....438...2......9.....1.4...6..........");
     expect(sudoku.solve()).toBe("ERROR: Too many solutions");
   });
 
   // This puzzle is not a valid Sudoku, because it has two possible solutions.
-  it('Detects multiple solutions - 1', function() {
+  xit('Detects multiple solutions - 1', function() {
     var sudoku = new Sudoku(".39...12....9.7...8..4.1..6.42...79...........91...54.5..1.9..3...8.5....14...87");
     expect(sudoku.solve()).toBe("ERROR: No Unique Solution");
   });
 
   // This puzzle is not a valid Sudoku, because it has three possible solutions.
-  it('Detects multiple solutions - 2', function() {
+  xit('Detects multiple solutions - 2', function() {
     var sudoku = new Sudoku("..3.....6...98..2.9426..7..45...6............1.9.5.47.....25.4.6...785...........");
     expect(sudoku.solve()).toBe("ERROR: No Unique Solution");
   });
 
   // This puzzle is not a valid Sudoku, because it has four possible solutions.
-  it('Detects multiple solutions - 3', function() {
+  xit('Detects multiple solutions - 3', function() {
     var sudoku = new Sudoku("....9....6..4.7..8.4.812.3.7.......5..4...9..5..371..4.5..6..4.2.17.85.9.........");
     expect(sudoku.solve()).toBe("ERROR: No Unique Solution");
   });
 
   // This puzzle is not a valid Sudoku, because it has ten possible solutions.
-  it('Detects multiple solutions - 4', function() {
+  xit('Detects multiple solutions - 4', function() {
     var sudoku = new Sudoku("59.....486.8...3.7...2.1.......4.....753.698.....9.......8.3...2.6...7.934.....65");
     expect(sudoku.solve()).toBe("ERROR: No Unique Solution");
   });
 
   // This puzzle is not a valid Sudoku, because it has 125 possible solutions.
-  it('Detects multiple solutions - 5', function() {
+  xit('Detects multiple solutions - 5', function() {
     var sudoku = new Sudoku("...3165..8..5..1...1.89724.9.1.85.2....9.1....4.263..1.5.....1.1..4.9..2..61.8...");
     expect(sudoku.solve()).toBe("ERROR: No Unique Solution");
   });

exercism/accumulate/accumulate.spec.js

@@ -1,8 +1,8 @@
 var accumulate = require('./accumulate');
 
-describe('accumulate()', function() {
+xdescribe('accumulate()', function() {
 
-  it('accumulation empty', function() {
+  xit('accumulation empty', function() {
     var accumulator = function(e) { return e * e; };
     expect(accumulate([], accumulator)).toEqual([]);
   });

exercism/acronym/acronym.spec.js

@@ -1,28 +1,27 @@
 var Acronyms = require('./acronym');
 
 describe('Acronyms are produced from', function(){
-  it('title cased phrases', function() {
+  xit('title cased phrases', function() {
     expect(Acronyms.parse('Portable Network Graphics')).toEqual('PNG');
   });
 
-  it('other title cased phrases', function(){
+  xit('other title cased phrases', function(){
     expect(Acronyms.parse('Ruby on Rails')).toEqual('ROR');
   });
 
-  it('inconsistently cased phrases', function(){
+  xit('inconsistently cased phrases', function(){
     expect(Acronyms.parse('HyperText Markup Language')).toEqual('HTML');
   });
 
-  it('phrases with punctuation', function() {
+  xit('phrases with punctuation', function() {
     expect(Acronyms.parse('First In, First Out')).toEqual('FIFO');
   });
 
-  it('other phrases with punctuation', function() {
+  xit('other phrases with punctuation', function() {
     expect(Acronyms.parse('PHP: Hypertext Preprocessor')).toEqual('PHP');
   });
 
-  it('phrases with punctuation and sentence casing', function() {
+  xit('phrases with punctuation and sentence casing', function() {
     expect(Acronyms.parse('Complementary metal-oxide semiconductor')).toEqual('CMOS');
   });
 });
-

exercism/all-your-base/all-your-base.spec.js

@@ -4,7 +4,7 @@ const Converter = require('./all-your-base');
 
 const converter = new Converter();
 
-describe('Converter', function () {
+xdescribe('Converter', function () {
 
   xit('single bit one to decimal', function () {
     expect(converter.convert([1], 2, 10)).toEqual([1]);

exercism/bob/bob.js

@@ -0,0 +1,15 @@
+var Bob = function() {};
+
+Bob.prototype.hey = function(what) {
+  if (/([A-Z]+\s){2,}|[A-Z](?=!)/.test(what)) {
+    return 'Whoa, chill out!'
+  } else if (/(.+)(?=\?)/.test(what)) {
+    return 'Sure.'
+  } else if (!what) {
+    return 'Fine. Be that way!'
+  } else {
+    return 'Whatever.'
+  }
+};
+
+module.exports = Bob;