Move tests to its own files Round 1

Author: ignacio-chiazzo

LeetcodeProblemsTests/Best_Time_To_Buy_And_Sell_Stock_II_Test.js

@@ -1,68 +1,9 @@
-/*
-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();
-}
+const maxProfit = require('../LeetcodeProblems/Best_Time_To_Buy_And_Sell_Stock_II').maxProfit;
 
 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;
+module.exports.test = test;

LeetcodeProblemsTests/Binary_Gap_Test.js

@@ -1,73 +1,9 @@
-/*
-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();
-}
+const binaryGap = require('../LeetcodeProblems/Binary_Gap').binaryGap;
 
 function test() {
   assert.equal(binaryGap(22), 2); // 10110
   assert.equal(binaryGap(8), 0); // 1000
 }
 
-module.exports.main = main;
+module.exports.test = test;

LeetcodeProblemsTests/Clone_Graph_Test.js

@@ -1,99 +1,5 @@
-/*
-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;
+var test = function() {
+  // TODO
 }
 
-// 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;
-}
+module.exports.test = test;

LeetcodeProblemsTests/Coin_Change_Test.js

@@ -1,110 +1,5 @@
-/*
-Coin Change
-https://leetcode.com/problems/coin-change/
-
-You are given coins of different denominations and a total amount of money amount. 
-Write a function to compute the fewest number of coins that you need to make up that amount. 
-If that amount of money cannot be made up by any combination of the coins, return -1.
-
-Example 1:
-
-Input: coins = [1, 2, 5], amount = 11
-Output: 3 
-Explanation: 11 = 5 + 5 + 1
-Example 2:
-
-Input: coins = [2], amount = 3
-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) {
-  var memo = [];
-  for(var i = 0; i <= amount; i++)
-    memo[i] = Number.POSITIVE_INFINITY;
-
-  memo[0] = 0;
-  for(var i = 0; i < coins.length; i++) {
-    const coin = coins[i];
-    for(var j = coin; j < memo.length; j++)
-      memo[j] = min2(memo[j], memo[j - coin] + 1);
-  }
-
-  return (memo[amount] == Number.POSITIVE_INFINITY) ? -1 : memo[amount];
-};
-
-var min2 = function(a, b) {
-  return (a < b) ? a : b;
-}
-
-// Solution 2
-var buildMemoKey = function(position, amount) {
-  return position + "-" + amount;
-}
-
-var coinChange2 = function(coins, amount) {
-  var memo = {};
-  var solution = coinChangeAux2(coins, amount, 0, memo, Number.POSITIVE_INFINITY);
-  return solution == Number.POSITIVE_INFINITY ? -1 : solution;
-};
-
-var coinChangeAux2 = function(coins, amount, pos, memo) {
-  var key = buildMemoKey(pos, amount);
-  if(memo[key])
-    return memo[key];
-    
-  if(amount < 0) {
-    return Number.POSITIVE_INFINITY; 
-  } else if(amount == 0) {
-    return 0;
-  } else if(pos >= coins.length) {
-    return Number.POSITIVE_INFINITY;
-  }
-  
-  var left = coinChangeAux2(coins, amount, pos + 1, memo);
-  var middle = 1 + coinChangeAux2(coins, amount - coins[pos], pos + 1, memo);
-  var right = 1 + coinChangeAux2(coins, amount - coins[pos], pos, memo);
-  
-  var solution = min(left, middle, right);
-  memo[key] = solution;
-  return solution;
-}
-
-// Solution 1 naive
-var coinChange1 = function(coins, amount) {
-  var solution = coinChangeAux1(coins, amount, 0);
-  return solution == Number.POSITIVE_INFINITY ? -1 : solution;
-};
-
-var coinChangeAux1 = function(coins, amount, pos) {
-  if(amount < 0) {
-    return Number.POSITIVE_INFINITY; 
-  } else if(amount == 0) {
-    return 0;
-  } else if(pos >= coins.length) {
-    return Number.POSITIVE_INFINITY;
-  }
-  
-  var left = coinChangeAux1(coins, amount, pos + 1);
-  var middle = 1 + coinChangeAux1(coins, amount - coins[pos], pos + 1);
-  var right = 1 + coinChangeAux1(coins, amount - coins[pos], pos);
-  
-  var partialSol = min(left, middle, right);
-  return partialSol;
-}
-
-var min = function(a, b, c) {
-  if(a < b) 
-    return (a < c) ? a : c;
-  return (b < c) ? b : c;
-}
-
-function main() {
-  test();
-}
+const coinChange = require('../LeetcodeProblems/Coin_Change').coinChange;
 
 function test() {
   assert.equal(coinChange([], 3), -1);
@@ -114,4 +9,4 @@ function test() {
   assert.equal(coinChange([370, 417, 408, 156, 143, 434, 168, 83, 177, 280, 117], 9953), 24);
 }
 
-module.exports.main = main;
+module.exports.test = test;