Move to tests - Round 5

Author: ignacio-chiazzo

LeetcodeProblems/Implement_stack_using_queues.js

@@ -23,7 +23,7 @@ You must use only standard operations of a queue -- which means only push to bac
 Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
 You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).
 */
-
+const assert = require('assert');
 class MyStack  {
   constructor() {
     this.q1 = [];
@@ -78,19 +78,22 @@ class MyStack  {
 }
 
 var main = function() {
+  test();
+}
 
-var myStack = new MyStack();
+var test = function () {
+  var myStack = new MyStack();
   myStack.push(4);
   myStack.push(3);
   myStack.push(2);
   myStack.push(1);
-  console.log(myStack.pop());
-  console.log(myStack.top());
-  console.log(myStack.push(1));
-  console.log(myStack.top());
-  console.log(myStack.pop());
-  console.log(myStack.pop());
-  console.log(myStack.pop());
+  assert.equal(myStack.pop(), 1);
+  assert.equal(myStack.top(), 2);
+  myStack.push(1);
+  assert.equal(myStack.top(), 1);
+  assert.equal(myStack.pop(), 1);
+  assert.equal(myStack.pop(), 2);
+  assert.equal(myStack.pop(), 3);
 }
 
 module.exports.main = main;

LeetcodeProblems/Kth_Largest_Element_in_an_Array.js

@@ -15,6 +15,7 @@ Output: 4
 Note: 
 You may assume k is always valid, 1 ≤ k ≤ array's length.
 */
+const assert = require('assert');
 
 /**
  * @param {number[]} nums
@@ -57,10 +58,14 @@ var swap = function(nums, a, b) {
 }
 
 var main = function(nums) {
-  console.log(findKthLargest([3,2,1,5,6,4], 2));
-  console.log(findKthLargest([3,2,3,1,2,4,5,5,6], 4));
-  console.log(findKthLargest([0], 1));
-  console.log(findKthLargest([], 1));
+  test();
+}
+
+function test() {
+  assert.equal(findKthLargest([3,2,1,5,6,4], 2), 5);
+  assert.equal(findKthLargest([3,2,3,1,2,4,5,5,6], 4), 4);
+  assert.equal(findKthLargest([0], 1), 0);
+  assert.equal(findKthLargest([], 1), undefined);
 }
 
 module.exports.main = main;

LeetcodeProblems/Linked_List_Cycle_II.js

@@ -9,7 +9,7 @@ Note: Do not modify the linked list.
 Follow up:
 Can you solve it without using extra space?
 */
-
+const assert = require('assert');
 var ListNode = require('../UtilsClasses/ListNode').ListNode;
 
 // Optimal solution
@@ -58,8 +58,14 @@ var detectCycle2 = function(head) {
 };
 
 var main = function() {
-  const head = buildCycle();
-  console.log(detectCycle(head));
+  test();
+}
+
+var test = function() {
+  const cycle = buildCycle();
+  var list = cycle.list;
+  var nodeCycle = cycle.nodeCycle;
+  assert.equal(detectCycle(list), nodeCycle);
 }
 
 function buildCycle() {
@@ -73,8 +79,12 @@ function buildCycle() {
   node2.next = node3;
   node3.next = node4;
   node4.next = node5;
-  node5.next = node2; 
-  return node1;
+  node5.next = node2;
+
+  return {
+    list: node1,
+    nodeCycle: node2,
+  };
 }
 
 module.exports.main = main;

LeetcodeProblems/Longest_Consecutive_Sequence.js

@@ -12,6 +12,7 @@ Input: [100, 4, 200, 1, 3, 2]
 Output: 4
 Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.
 */
+const assert = require('assert');
 
 /**
  * @param {number[]} nums
@@ -54,11 +55,15 @@ var longestConsecutive = function(nums) {
 };
 
 var main = function() {
-  console.log(longestConsecutive([100, 1, 200, 3, 2, 400, 201]));
-  console.log(longestConsecutive([1,2,3,4, 100, 1, 200, 3, 2, 400, 201]));
-  console.log(longestConsecutive([1, 400, 201, 403, 398]));
-  console.log(longestConsecutive([]));
-  console.log(longestConsecutive([2]));
+  test();
+}
+
+function test() {
+  assert.equal(longestConsecutive([100, 1, 200, 3, 2, 400, 201]), 3);
+  assert.equal(longestConsecutive([1,2,3,4, 100, 1, 200, 3, 2, 400, 201]), 4);
+  assert.equal(longestConsecutive([1, 400, 201, 403, 398]), 1);
+  assert.equal(longestConsecutive([]), 0);
+  assert.equal(longestConsecutive([2]), 1);
 }
 
 module.exports.main

LeetcodeProblems/Longest_Palindromic_Substring.js

@@ -14,6 +14,7 @@ Example 2:
 Input: "cbbd"
 Output: "bb"
 */
+const assert = require('assert');
 
 /**
  * @param {string} s
@@ -64,12 +65,16 @@ var longestPalindrome = function(str) {
 }
 
 var main = function() {
-  console.log(longestPalindrome("pabcdcbte"));
-  console.log(longestPalindrome("bb"));
-  console.log(longestPalindrome(""));
-  console.log(longestPalindrome("bbb"));
-  console.log(longestPalindrome("bbbb"));
-  console.log(longestPalindrome("ptabbbbat"));
+  test();
+}
+
+function test() {
+  assert.equal(longestPalindrome("pabcdcbte"), "bcdcb");
+  assert.equal(longestPalindrome("bb"), "bb");
+  assert.equal(longestPalindrome(""), "");
+  assert.equal(longestPalindrome("bbb"), "bbb");
+  assert.equal(longestPalindrome("bbbb"), "bbbb");
+  assert.equal(longestPalindrome("ptabbbbat"), "tabbbbat");
 }
 
 module.exports.main = main

LeetcodeProblems/Lowest_Common_Ancestor_of_a_Binary_Tree.js

@@ -33,6 +33,7 @@ Note:
 All of the nodes' values will be unique.
 p and q are different and both values will exist in the binary tree.
 */
+const assert = require('assert');
 
 var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
 

LeetcodeProblems/Majority_Element.js

@@ -17,6 +17,7 @@ Output: 2
 
 Note: You should have a better solution than O(N)
 */
+const assert = require('assert');
 
 /**
  * @param {number[]} nums
@@ -45,9 +46,13 @@ var majorityElement = function(nums) {
 };
 
 var main = function() {
-  console.log(majorityElement([2,2,3]));
-  console.log(majorityElement([2,3,2]));
-  console.log(majorityElement([1,1,1,2,3,45,1,2,4,1,1]));
+  test();
+}
+
+function test() {
+  assert.equal(majorityElement([2,2,3]), 2);
+  assert.equal(majorityElement([2,3,2]), 2);
+  assert.equal(majorityElement([1,1,1,2,3,45,1,2,4,1,1]), 1);
 }
 
 module.exports.main = main

LeetcodeProblems/Maximal_Square.js

@@ -15,6 +15,7 @@ Input:
 
 Output: 4
 */
+const assert = require('assert');
 
 /**
  * @param {character[][]} matrix
@@ -65,11 +66,16 @@ var getCurrentMaxSideLength = function(matrix, i, j) {
 }
 
 var main = function() {
-  console.log(maximalSquare([["1","0"]]));
-  console.log(maximalSquare([["1"]]));
-  console.log(maximalSquare([["0"]]));
-  console.log(
-    maximalSquare([["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]])
+  test();
+}
+
+function test() {
+  assert.equal(maximalSquare([["1","0"]]), 1);
+  assert.equal(maximalSquare([["1"]]), 1);
+  assert.equal(maximalSquare([["0"]]), 0);
+  assert.equal(
+    maximalSquare([["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]),
+    4
   );
 }
 

LeetcodeProblems/Maximun_Subarray.js

@@ -13,6 +13,7 @@ Explanation: [4,-1,2,1] has the largest sum = 6.
 Follow up:
 
 */
+const assert = require('assert');
 
 var maxSubArray = function(nums) {
   if(nums.length == 0) 
@@ -34,10 +35,14 @@ var max = function(i, j) {
 }
 
 var main = function() {
-  console.log(maxSubArray([]));
-  console.log(maxSubArray([-4]));
-  console.log(maxSubArray([2]));
-  console.log(maxSubArray([4,1,-1,4,5,6,7,-200]));
+  test();
+}
+
+function test() {
+  assert.equal(maxSubArray([]), 0);
+  assert.equal(maxSubArray([-4]), -4);
+  assert.equal(maxSubArray([2]), 2);
+  assert.equal(maxSubArray([4,1,-1,4,5,6,7,-200]), 26);
 }
 
 module.exports.main = main;

LeetcodeProblems/Min_Stack.js

@@ -19,6 +19,7 @@ minStack.pop();
 minStack.top();      --> Returns 0.
 minStack.getMin();   --> Returns -2.
 */
+const assert = require('assert');
 
 class MinStack {
   constructor() {
@@ -74,14 +75,18 @@ class MinStack {
 }
 
 var main = function() {
+  test();
+}
+
+function test() {
   var minStack = new MinStack();
   minStack.push(-2);
   minStack.push(0);
   minStack.push(-3);
-  console.log(minStack.getMin());
-  console.log(minStack.pop());
-  console.log(minStack.top());
-  console.log(minStack.getMin());
+  assert.equal(minStack.getMin(), -3);
+  assert.equal(minStack.pop(), -3);
+  assert.equal(minStack.top(), 0);
+  assert.equal(minStack.getMin(), -2);
 }
 
 module.exports.main = main;