Move to tests - Round 6

Author: ignacio-chiazzo

LeetcodeProblems/Best_Time_To_Buy_And_Sell_Stock_II.js

@@ -27,6 +27,7 @@ Input: [7,6,4,3,1]
 Output: 0
 Explanation: In this case, no transaction is done, i.e. max profit = 0.
 */
+const assert = require('assert');
 
 /**
  * @param {number[]} prices
@@ -56,8 +57,12 @@ var maxProfit = function(prices) {
 };
 
 var main = function() {
-  console.log(maxProfit([7,1,5,3,6,4]));
-  console.log(maxProfit([7,1,5,3320,6,4]));
+  test();
+}
+
+function test() {
+  assert.equal(maxProfit([7,1,5,3,6,4]), 7);
+  assert.equal(maxProfit([7,1,5,3320,6,4]), 3319);
 }
 
 module.exports.main = main;

LeetcodeProblems/Binary_Gap.js

@@ -36,6 +36,7 @@ Explanation:
 8 in binary is 0b1000.
 There aren't any consecutive pairs of 1's in the binary representation of 8, so we return 0.
 */
+const assert = require('assert');
 
 /**
  * @param {number} N
@@ -61,8 +62,12 @@ var binaryGap = function(N) {
 };
 
 var main = function() {
-  console.log(binaryGap(22)); // 10110
-  console.log(binaryGap(8)); // 1000
+  test();
+}
+
+function test() {
+  assert.equal(binaryGap(22), 2); // 10110
+  assert.equal(binaryGap(8), 0); // 1000
 }
 
 module.exports.main = main;

LeetcodeProblems/Coin_Change.js

@@ -18,6 +18,7 @@ Output: -1
 Note:
 You may assume that you have an infinite number of each kind of coin.
 */
+const assert = require('assert');
 
 // Solution 3 
 var coinChange = function(coins, amount) {
@@ -102,13 +103,15 @@ var min = function(a, b, c) {
 }
 
 function main() {
-  console.log("-------------");
-  console.log("Solution Optimal")
-  console.log(coinChange([], 3));
-  console.log(coinChange([2], 3));
-  console.log(coinChange([1, 2, 5], 11));
-  console.log(coinChange([3, 7, 405, 436], 8839));
-  console.log(coinChange([370, 417, 408, 156, 143, 434, 168, 83, 177, 280, 117], 9953));
+  test();
+}
+
+function test() {
+  assert.equal(coinChange([], 3), -1);
+  assert.equal(coinChange([2], 3), -1);
+  assert.equal(coinChange([1, 2, 5], 11), 3);
+  assert.equal(coinChange([3, 7, 405, 436], 8839), 25);
+  assert.equal(coinChange([370, 417, 408, 156, 143, 434, 168, 83, 177, 280, 117], 9953), 24);
 }
 
 module.exports.main = main;

LeetcodeProblems/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js

@@ -27,6 +27,7 @@ Return the following binary tree:
  *     this.left = this.right = null;
  * }
  */
+const assert = require('assert');
 
 var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
 
@@ -59,6 +60,10 @@ var buildTreeAux = function(preorder, pl, ph, inorder, il, ih) {
 }
 
 var main = function() {
+  test();
+}
+
+function test() {
   console.log(buildTree([3,9,20,15,7], [9,3,15,20,7]));
 }
 

LeetcodeProblems/Deletion_Distance.js

@@ -18,6 +18,7 @@ output: 9
 input:  str1 = "", str2 = ""
 output: 0
 */
+const assert = require('assert');
 
 // Solution 3 Using DP
 var deletionDistanceDP = function(str1, str2) {
@@ -107,20 +108,24 @@ var min = function(a, b) {
 }
 
 function main() {
-  console.log(deletionDistance("dog", "frog")); //output: 3
-  console.log(deletionDistance("some", "some")); //output: 0
-  console.log(deletionDistance("some", "thing")); //output: 9
-  console.log(deletionDistance("", "")); // =  0
-
-  console.log(deletionDistance2("dog", "frog")); //output: 3
-  console.log(deletionDistance2("some", "some")); //output: 0
-  console.log(deletionDistance2("some", "thing")); //output: 9
-  console.log(deletionDistance2("", "")); // =  0
-
-  console.log(deletionDistanceDP("dog", "frog")); //output: 3
-  console.log(deletionDistanceDP("some", "some")); //output: 0
-  console.log(deletionDistanceDP("some", "thing")); //output: 9
-  console.log(deletionDistanceDP("", "")); // =  0
+  test();
+}
+
+function test() {
+  assert.equal(deletionDistance("dog", "frog"), 3);
+  assert.equal(deletionDistance("some", "some"), 0);
+  assert.equal(deletionDistance("some", "thing"), 9);
+  assert.equal(deletionDistance("", ""), 0);
+
+  assert.equal(deletionDistance2("dog", "frog"), 3);
+  assert.equal(deletionDistance2("some", "some"), 0);
+  assert.equal(deletionDistance2("some", "thing"), 9);
+  assert.equal(deletionDistance2("", ""), 0);
+
+  assert.equal(deletionDistanceDP("dog", "frog"), 3);
+  assert.equal(deletionDistanceDP("some", "some"), 0);
+  assert.equal(deletionDistanceDP("some", "thing"), 9);
+  assert.equal(deletionDistanceDP("", ""), 0);
 }
 
 module.exports.main = main

LeetcodeProblems/Design_Circular_Deque.js

@@ -35,7 +35,7 @@ All values will be in the range of [0, 1000].
 The number of operations will be in the range of [1, 1000].
 Please do not use the built-in Deque library.
 */
-
+const assert = require('assert');
 
 /**
  * Initialize your data structure here. Set the size of the deque to be k.
@@ -133,16 +133,20 @@ MyCircularDeque.prototype.isFull = function() {
 };
 
 var main = function(){
+  test();
+};
+
+var test =  function() {
   const obj = new MyCircularDeque(3);
-  console.log(obj.insertLast(1));
-  console.log(obj.insertLast(2));
-  console.log(obj.insertFront(3));
-  console.log(obj.insertFront(4));
-  console.log(obj.getRear());
-  console.log(obj.isFull());
-  console.log(obj.deleteLast());
-  console.log(obj.insertFront(4));
-  console.log(obj.getFront());  
+  assert.equal(obj.insertLast(1), true);
+  assert.equal(obj.insertLast(2), true);
+  assert.equal(obj.insertFront(3), true);
+  assert.equal(obj.insertFront(4), false);
+  assert.equal(obj.getRear(), 2);
+  assert.equal(obj.isFull(), true);
+  assert.equal(obj.deleteLast(), true);
+  assert.equal(obj.insertFront(4), true);
+  assert.equal(obj.getFront(), 4);
 }
 
 module.exports.main = main;

LeetcodeProblems/Edit_Distance.js

@@ -28,6 +28,7 @@ enention -> exention (replace 'n' with 'x')
 exention -> exection (replace 'n' with 'c')
 exection -> execution (insert 'u')
 */
+const assert = require('assert');
 
 // Optimal solution
 var minDistance = function(word1, word2) {
@@ -98,15 +99,15 @@ var min = function(a, b, c) {
 }
 
 var main = function() {
-  console.log("-------------");
-  console.log("Approach 1");
-  console.log(minDistance("ros", "horse"));
-  console.log(minDistance("intention", "execution"));
+  test();
+}
+
+function test() {
+  assert.equal(minDistance("ros", "horse"), 3);
+  assert.equal(minDistance("intention", "execution"), 5);
 
-  console.log("-------------");
-  console.log("Approach 2");
-  console.log(minDistance2("ros", "horse"));
-  console.log(minDistance2("intention", "execution"));
+  assert.equal(minDistance2("ros", "horse"), 3);
+  assert.equal(minDistance2("intention", "execution"), 5);
 }
 
 module.exports.main = main;

LeetcodeProblems/Escape_The_Ghosts.js

@@ -36,6 +36,7 @@ Note:
 All points have coordinates with absolute value <= 10000.
 The number of ghosts will not exceed 100.
 */
+const assert = require('assert');
 
 /**
  * @param {number[][]} ghosts
@@ -60,9 +61,13 @@ var getDistance = function(a, b) {
 }
 
 var main = function() {
-  console.log(escapeGhosts([[1, 0], [0, 3]], [0, 1]));
-  console.log(escapeGhosts([[1, 0]], [2, 0]));
-  console.log(escapeGhosts([[2, 0]], [1, 0]));
+  test();
+}
+
+function test() {
+  assert.equal(escapeGhosts([[1, 0], [0, 3]], [0, 1]), true);
+  assert.equal(escapeGhosts([[1, 0]], [2, 0]), false);
+  assert.equal(escapeGhosts([[2, 0]], [1, 0]), true);
 }
 
 module.exports.main = main

LeetcodeProblems/Flood_Fill.js

@@ -28,6 +28,7 @@ The length of image and image[0] will be in the range [1, 50].
 The given starting pixel will satisfy 0 <= sr < image.length and 0 <= sc < image[0].length.
 The value of each color in image[i][j] and newColor will be an integer in [0, 65535].
 */
+const assert = require('assert');
 
 var floodFill = function(image, sr, sc, newColor) {
   var oldColor = image[sr][sc];
@@ -53,7 +54,14 @@ var floodFill = function(image, sr, sc, newColor) {
 };
 
 function main() {
-  console.log(floodFill([[1,1,1],[1,1,0],[1,0,1]], 1, 1, 2))
+  test();
 }
 
-module.exports.main = main;
+function test() {
+  assert.deepEqual(
+    [ [ 2, 2, 2 ], [ 2, 2, 0 ], [ 2, 0, 1 ] ],
+    floodFill([[1,1,1],[1,1,0],[1,0,1]], 1, 1, 2)
+  );
+}
+
+module.exports.main = main;

LeetcodeProblems/Group_Anagrams.js

@@ -18,6 +18,7 @@ Note:
 All inputs will be in lowercase.
 The order of your output does not matter.
 */
+const assert = require('assert');
 
 var groupAnagrams = function(strs) {
   var ret = [];
@@ -48,7 +49,14 @@ var sortString = function(str) {
 }
 
 var main = function() {
-  console.log(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]));
+  test();
+}
+
+function test() {
+  assert.deepEqual(
+    groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]),
+    [ [ 'eat', 'tea', 'ate' ], [ 'tan', 'nat' ], [ 'bat' ] ]
+  )
 }
 
 module.exports.main = main;