Generate tests classes

Author: ignacio-chiazzo

LeetcodeProblemsTests/3Sum_Test.js

@@ -0,0 +1,22 @@
+const assert = require('assert');
+const threeSum = require('../LeetcodeProblems/3Sum').threeSum;
+
+var test = function () {
+  assert.deepEqual(threeSum([]), []);
+  assert.deepEqual(threeSum([0]), []);
+  assert.deepEqual(threeSum([0, 0]), []);
+  assert.deepEqual(
+    threeSum([0, 0, 0]), 
+    [[0, 0, 0]]
+  );
+  assert.deepEqual(
+    threeSum([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]), 
+    [[0, 0, 0]]
+  );
+  assert.deepEqual(
+    threeSum([-1, 0, 1, 2, -1, -4]), 
+    [ [ -1, 2, -1 ], [ 0, 1, -1 ] ]
+  );
+}
+
+module.exports.test = test;

LeetcodeProblemsTests/Add_Two_Numbers_Test.js

@@ -0,0 +1,29 @@
+const assert = require('assert');
+const addTwoNumbers = require('../LeetcodeProblems/Add_Two_Numbers').addTwoNumbers;
+const ListNodeTestHelper = require('../utilsClasses/ListNodeTestHelper');
+var ListNode = require('../UtilsClasses/ListNode').ListNode;
+
+function test() {
+  const list1 = ListNode.linkenList([1,2,3,4]);
+  const list2 = ListNode.linkenList([1,2,3,4]);
+  ListNodeTestHelper.assertList(
+    addTwoNumbers(list1, list2),
+    [2, 4, 6, 8]
+  );
+
+  const list3 = ListNode.linkenList([1]);
+  const list4 = ListNode.linkenList([1,2]);
+  ListNodeTestHelper.assertList(
+    addTwoNumbers(list3, list4),
+    [2, 2]
+  );
+
+  const list5 = ListNode.linkenList([]);
+  const list6 = ListNode.linkenList([1,2]);
+  ListNodeTestHelper.assertList(
+    addTwoNumbers(list5, list6),
+    [1, 2]
+  );
+}
+
+module.exports.test = test;

LeetcodeProblemsTests/Award_Budget_Cuts_Test.js

@@ -0,0 +1,15 @@
+const assert = require('assert');
+const cutAwardBadges = require('../LeetcodeProblems/Award_Budget_Cuts').cutAwardBadges;
+
+function test() {
+  assert.deepEqual(
+    cutAwardBadges([2, 100, 50, 120, 1000], 190),
+    [ 47, 47, 47, 47, 2 ]
+  );
+  assert.deepEqual(
+    cutAwardBadges([2, 100, 50, 120, 1000], 5),
+    [ 1, 1, 1, 1, 1 ]
+  );
+}
+
+module.exports.test = test;

LeetcodeProblemsTests/Backspace_String_Compare_Test.js

@@ -0,0 +1,18 @@
+const assert = require('assert');
+const backspaceCompare = require('../LeetcodeProblems/Backspace_String_Compare').backspaceCompare;
+const backspaceCompare2 = require('../LeetcodeProblems/Backspace_String_Compare').backspaceCompare2;
+
+function test() {
+  assert.equal(backspaceCompare("ab#c", "ad#c"), true); // true
+  assert.equal(backspaceCompare("ab##", "c#d#"), true); // true
+  assert.equal(backspaceCompare("a##c", "#a#c"), true); // true
+  assert.equal(backspaceCompare("a#c", "b"), false); // false
+
+  assert.equal(backspaceCompare2("ab#c", "ad#c"), true); // true
+  assert.equal(backspaceCompare2("ab##", "c#d#"), true); // true
+  assert.equal(backspaceCompare2("a##c", "#a#c"), true); // true
+  assert.equal(backspaceCompare2("a#c", "b"), false); // false
+}
+test();
+
+module.exports.test = test;

LeetcodeProblemsTests/Best_Time_To_Buy_And_Sell_Stock_II_Test.js

@@ -0,0 +1,68 @@
+/*
+https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/
+Best Time to Buy and Sell Stock II
+
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).
+
+Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+
+Example 1:
+
+Input: [7,1,5,3,6,4]
+Output: 7
+Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+             Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+Example 2:
+
+Input: [1,2,3,4,5]
+Output: 4
+Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
+             engaging multiple transactions at the same time. You must sell before buying again.
+Example 3:
+
+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
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+  var profit = 0;
+  var iter = 0;
+  
+  while(iter < prices.length) {
+    while(iter < prices.length - 1 && prices[iter] > prices[iter + 1]) {
+      iter++;
+    }
+    const buy = prices[iter];
+    iter++;
+    while(iter < prices.length - 1 && prices[iter] < prices[iter + 1]) {
+      iter++;
+    }
+    
+    if(iter < prices.length) {
+      const sell = prices[iter];
+      profit = profit + sell - buy;
+    }
+  }
+  
+  return profit;
+};
+
+var main = function() {
+  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;

LeetcodeProblemsTests/Binary_Gap_Test.js

@@ -0,0 +1,73 @@
+/*
+Binary Gap
+https://leetcode.com/problems/binary-gap/description/
+
+Given a positive integer N, find and return the longest distance between two consecutive 1's in the binary representation of N.
+
+If there aren't two consecutive 1's, return 0. 
+
+Example 1:
+
+Input: 22
+Output: 2
+Explanation: 
+22 in binary is 0b10110.
+In the binary representation of 22, there are three ones, and two consecutive pairs of 1's.
+The first consecutive pair of 1's have distance 2.
+The second consecutive pair of 1's have distance 1.
+The answer is the largest of these two distances, which is 2.
+Example 2:
+
+Input: 5
+Output: 2
+Explanation: 
+5 in binary is 0b101.
+Example 3:
+
+Input: 6
+Output: 1
+Explanation: 
+6 in binary is 0b110.
+Example 4:
+
+Input: 8
+Output: 0
+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
+ * @return {number}
+ */
+var binaryGap = function(N) {
+  var maxDist = 0;
+  var currentDist = 0;
+  while(N > 0) {
+    const bit = N % 2;
+    N >>= 1;
+    if(bit === 1) {
+      currentDist = 1;
+      while(N > 0 && N % 2 === 0 ) {
+        currentDist++;
+        N >>= 1; 
+      }
+      if(N !== 0 && currentDist > maxDist)
+        maxDist = currentDist;
+    }
+  }
+  return maxDist;
+};
+
+var main = function() {
+  test();
+}
+
+function test() {
+  assert.equal(binaryGap(22), 2); // 10110
+  assert.equal(binaryGap(8), 0); // 1000
+}
+
+module.exports.main = main;

LeetcodeProblemsTests/Clone_Graph_Test.js

@@ -0,0 +1,99 @@
+/*
+Clone Graph
+https://leetcode.com/problems/clone-graph/description/
+
+Given the head of a graph, return a deep copy (clone) of the graph. Each node in the graph contains a label (int) and a list (List[UndirectedGraphNode]) of its neighbors. There is an edge between the given node and each of the nodes in its neighbors.
+
+
+OJ's undirected graph serialization (so you can understand error output):
+Nodes are labeled uniquely.
+
+We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.
+ 
+
+As an example, consider the serialized graph {0,1,2#1,2#2,2}.
+
+The graph has a total of three nodes, and therefore contains three parts as separated by #.
+
+First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
+Second node is labeled as 1. Connect node 1 to node 2.
+Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.
+ 
+
+Visually, the graph looks like the following:
+
+       1
+      / \
+     /   \
+    0 --- 2
+         / \
+         \_/
+Note: The information about the tree serialization is only meant so that you can understand error output if you get a wrong answer. 
+You don't need to understand the serialization to solve the problem.
+*/
+
+/**
+ * Definition for undirected graph.
+ * function UndirectedGraphNode(label) {
+ *     this.label = label;
+ *     this.neighbors = [];   // Array of UndirectedGraphNode
+ * }
+ */
+
+
+// SOLUTION 1 Using DFS
+/**
+ * @param {UndirectedGraphNode} graph
+ * @return {UndirectedGraphNode}
+ */
+var cloneGraph = function(graph) {
+  if(!graph)
+      return graph;
+  
+  return dfs(graph, {});
+};
+
+var dfs = function(graph, visited) {
+  if(visited[graph.label]) 
+      return visited[graph.label];
+  
+  var newNode = new UndirectedGraphNode(graph.label);
+  visited[newNode.label] = newNode;
+  
+  for(var i = 0; i < graph.neighbors.length; i++) {
+      const neighbor = dfs(graph.neighbors[i], visited);
+      newNode.neighbors.push(neighbor);
+  }
+  
+  return newNode;
+}
+
+// SOLUTION 2 Using DFS
+var cloneGraphBFS = function(graph) {
+    if(graph === null)
+        return graph;
+    
+    var visitedMap = {};
+    var queue = [graph];
+    var copyReturn = new UndirectedGraphNode(graph.label);
+    visitedMap[graph.label] = copyReturn;
+    
+    while(queue.length > 0) {
+        var node = queue.shift();
+        var nodeCopied = visitedMap[node.label];
+        
+        for(var i = 0; i < node.neighbors.length; i++) {
+            var neighbor = node.neighbors[i];
+            
+            if(!visitedMap[neighbor.label]) {
+                var copyNeighbor = new UndirectedGraphNode(neighbor.label);
+                visitedMap[neighbor.label] = copyNeighbor;
+                queue.push(neighbor);
+            }
+            
+            nodeCopied.neighbors.push(visitedMap[neighbor.label]);
+        }
+    }
+    
+    return copyReturn;
+}