Move tests to its own files Round 2

Author: ignacio-chiazzo

LeetcodeProblemsTests/Edit_Distance_Test.js

@@ -9,5 +9,5 @@ function test() {
   assert.equal(minDistance2("ros", "horse"), 3);
   assert.equal(minDistance2("intention", "execution"), 5);
 }
-test();
+
 module.exports.test = test;

LeetcodeProblemsTests/Escape_The_Ghosts_Test.js

@@ -1,73 +1,11 @@
-/*
-Escape The Ghosts
-https://leetcode.com/problems/escape-the-ghosts/description/
 
-You are playing a simplified Pacman game. You start at the point (0, 0), and your destination is (target[0], target[1]). There are several ghosts on the map, the i-th ghost starts at (ghosts[i][0], ghosts[i][1]).
-
-Each turn, you and all ghosts simultaneously *may* move in one of 4 cardinal directions: north, east, west, or south, going from the previous point to a new point 1 unit of distance away.
-
-You escape if and only if you can reach the target before any ghost reaches you (for any given moves the ghosts may take.)  If you reach any square (including the target) at the same time as a ghost, it doesn't count as an escape.
-
-Return True if and only if it is possible to escape.
-
-Example 1:
-Input: 
-ghosts = [[1, 0], [0, 3]]
-target = [0, 1]
-Output: true
-Explanation: 
-You can directly reach the destination (0, 1) at time 1, while the ghosts located at (1, 0) or (0, 3) have no way to catch up with you.
-Example 2:
-Input: 
-ghosts = [[1, 0]]
-target = [2, 0]
-Output: false
-Explanation: 
-You need to reach the destination (2, 0), but the ghost at (1, 0) lies between you and the destination.
-Example 3:
-Input: 
-ghosts = [[2, 0]]
-target = [1, 0]
-Output: false
-Explanation: 
-The ghost can reach the target at the same time as you.
-Note:
-
-All points have coordinates with absolute value <= 10000.
-The number of ghosts will not exceed 100.
-*/
 const assert = require('assert');
-
-/**
- * @param {number[][]} ghosts
- * @param {number[]} target
- * @return {boolean}
- */
-var escapeGhosts = function(ghosts, target) {
-  var distancePacman = getDistance([0,0], target);
-  for(ghost in ghosts) {
-    const distanceGhost = getDistance(ghosts[ghost], target);
-    if(distancePacman > distanceGhost)
-      return false
-  }
-    
-  return true;
-};
-
-var getDistance = function(a, b) {
-  const horizontalMoves = Math.abs(a[0] - b[0]);
-  const verticalMoves = Math.abs(a[1] - b[1]);
-  return horizontalMoves + verticalMoves;
-}
-
-var main = function() {
-  test();
-}
+var escapeGhosts = require('../LeetcodeProblems/Escape_The_Ghosts').escapeGhosts;
 
 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
+module.exports.test = test;

LeetcodeProblemsTests/Flood_Fill_Test.js

@@ -1,67 +1,10 @@
-/*
-Flood Fill
-https://leetcode.com/problems/flood-fill/description/
-
-An image is represented by a 2-D array of integers, each integer representing the pixel value of the image (from 0 to 65535).
-
-Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, and a pixel value newColor, "flood fill" the image.
-
-To perform a "flood fill", consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, 
-plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on. 
-Replace the color of all of the aforementioned pixels with the newColor.
-
-At the end, return the modified image.
-
-Example 1:
-Input: 
-image = [[1,1,1],[1,1,0],[1,0,1]]
-sr = 1, sc = 1, newColor = 2
-Output: [[2,2,2],[2,2,0],[2,0,1]]
-Explanation: 
-From the center of the image (with position (sr, sc) = (1, 1)), all pixels connected 
-by a path of the same color as the starting pixel are colored with the new color.
-Note the bottom corner is not colored 2, because it is not 4-directionally connected
-to the starting pixel.
-Note:
-
-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];
-  
-  if(newColor == oldColor)
-    return image;
-  
-  image[sr][sc] = newColor;
-  
-  if(sr > 0 && image[sr - 1][sc] == oldColor)
-    floodFill(image, sr - 1, sc, newColor); //Left
-  
-  if(sc > 0 && image[sr][sc - 1] == oldColor)
-    floodFill(image, sr, sc - 1, newColor); //Up
-
-  if(sr < image.length - 1 && image[sr + 1][sc] == oldColor)
-    floodFill(image, sr + 1, sc, newColor); //Down
-      
-  if(sc < image[0].length - 1 && image[sr][sc + 1] == oldColor)
-    floodFill(image, sr, sc + 1, newColor); // Right
-      
-  return image;
-};
-
-function main() {
-  test();
-}
-
 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;
+module.exports.test = test;

LeetcodeProblemsTests/Generate_Parenthesis_Test.js

@@ -1,94 +1,5 @@
-/* 
-Generate Parentheses
-https://leetcode.com/problems/generate-parentheses
-
-Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
-
-For example, given n = 3, a solution set is:
-
-[
-  "((()))",
-  "(()())",
-  "(())()",
-  "()(())",
-  "()()()"
-]
-*/
-
-// ************************************************  Approach1  ************************************************
-var generateParenthesisApproach1 = function(n) {
-  if(n === 0) 
-    return [];
-
-  var str = "(".repeat(n);
-    sol = [];
-  
-  genParAux(str, 0, 0, sol)
-  return sol;
-};
-
-var genParAux = function(str, position, leftParentheses, sol) {
-  if(position === str.length) {
-    var ret = str + ")".repeat(leftParentheses);
-    sol.push(ret);
-    return;
-  }
-
-  genParAux(str, position + 1, leftParentheses + 1, sol); // Don't insert anything
-  if(leftParentheses === 0) 
-    return;
-
-  for(var i = 1; i <= leftParentheses; i++) {
-    var parString = ")".repeat(i);
-    var partSol = str.slice(0, position) + parString + str.slice(position); // Insert i parentheses in the position
-    genParAux(partSol, position + i + 1, leftParentheses - i + 1, sol);
-  } 
-}
-
-// ************************************************  Approach2  ************************************************
-var generateParenthesisApproach2 = function(n) {
-  if(n === 0) 
-    return [];
-
-  var sol = [];
-  genParAuxApproach2("", 0, 0, 0, n * 2, sol)
-  return sol;
-}
-
-var genParAuxApproach2 = function(str, leftPar, rightPar, index, totalCharCount, sol) {
-  if(index === totalCharCount) {
-    if(rightPar === leftPar)
-      sol.push(str);
-    
-    return;
-  }
-
-  var strLeft = insertAt(str, index, "(");
-  genParAuxApproach2(strLeft, leftPar + 1, rightPar, index + 1, totalCharCount, sol);
-
-  if(rightPar === leftPar) 
-    return;
-  
-  var strRight = insertAt(str, index, ")");
-  genParAuxApproach2(strRight, leftPar, rightPar + 1, index + 1, totalCharCount, sol);
-}
-
-var insertAt = function(str, position, value) {
-  return str.slice(0, position) + value + str.slice(position);
-}
-
-function main() {
-  console.log("Approach 1");
-  [0, 1, 2, 3].forEach(function(elem) {
-    console.log(`${elem}: ${generateParenthesisApproach2(elem)}`);
-  })
-
-  console.log("-------------");
-
-  console.log("Approach 2");
-  [0, 1, 2, 3].forEach(function(elem) {
-    console.log(`${elem}: ${generateParenthesisApproach2(elem)}`);
-  })
+var test = function() {
+  // TODO
 }
 
-module.exports.main = main
+module.exports.test = test;

LeetcodeProblemsTests/Group_Anagrams_Test.js

@@ -1,62 +1,10 @@
-/*
-Group Anagrams
-https://leetcode.com/problems/group-anagrams/description/
-
-Given an array of strings, group anagrams together.
-
-Example:
-
-Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
-Output:
-[
-  ["ate","eat","tea"],
-  ["nat","tan"],
-  ["bat"]
-]
-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 = [];
-  var hashMap = {};
-  for(var i = 0; i < strs.length; i++) {
-    const elem = strs[i];
-    const elemSorted = sortString(strs[i]);
-    
-    if(hashMap[elemSorted]) {
-      hashMap[elemSorted].push(elem);
-    } else {
-      hashMap[elemSorted] = [elem];
-    }
-  }
-
-  for(key in hashMap)
-    ret.push(hashMap[key]);
-  
-
-  return ret;
-};
-
-var sortString = function(str) {
-  if(str.length === 0)
-    return str;
-  
-  return str.split("").sort().join("");
-}
-
-var main = function() {
-  test();
-}
-
 function test() {
   assert.deepEqual(
     groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]),
     [ [ 'eat', 'tea', 'ate' ], [ 'tan', 'nat' ], [ 'bat' ] ]
   )
 }
 
-module.exports.main = main;
+module.exports.test = test;