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;
+}