Group folders for Algorithms and Databases

Author: ignacio chiazzo cardarello

LeetcodeProblems/.DS_Store

@@ -21,7 +21,7 @@ Explanation: 342 + 465 = 807.
  *     this.next = null;
  * }
  */
-var ListNode = require('../UtilsClasses/ListNode').ListNode;
+var ListNode = require('../../UtilsClasses/ListNode').ListNode;
 
 /**
  * @param {ListNode} l1

LeetcodeProblems/Algorithms/.DS_Store

@@ -27,7 +27,7 @@ Return the following binary tree:
  *     this.left = this.right = null;
  * }
  */
-var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
+var TreeNode = require('../../UtilsClasses/TreeNode').TreeNode;
 
 /**
  * @param {number[]} preorder

LeetcodeProblems/3Sum.js renamed to LeetcodeProblems/Algorithms/3Sum.js

@@ -10,7 +10,7 @@ Follow up:
 Can you solve it without using extra space?
 */
 
-var ListNode = require('../UtilsClasses/ListNode').ListNode;
+var ListNode = require('../../UtilsClasses/ListNode').ListNode;
 
 // Optimal solution
 /**

LeetcodeProblems/Add_Two_Numbers.js renamed to LeetcodeProblems/Algorithms/Add_Two_Numbers.js

@@ -35,7 +35,7 @@ p and q are different and both values will exist in the binary tree.
 */
 
 
-var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
+var TreeNode = require('../../UtilsClasses/TreeNode').TreeNode;
 
 // Solution 1
 var lowestCommonAncestor = function(root, p, q) {

LeetcodeProblems/Award_Budget_Cuts.js renamed to LeetcodeProblems/Algorithms/Award_Budget_Cuts.js

@@ -15,9 +15,9 @@ Input:
 Output: 1->1->2->3->4->4->5->6
 */
 
-const ListNodeTestHelper = require('../utilsClasses/ListNodeTestHelper');
+const ListNodeTestHelper = require('../../utilsClasses/ListNodeTestHelper');
 
-var ListNode = require('../UtilsClasses/ListNode').ListNode;
+var ListNode = require('../../utilsClasses/ListNode').ListNode;
 
 var mergeKLists = function(lists) {
   if(lists.length === 0)

LeetcodeProblems/Backspace_String_Compare.js renamed to LeetcodeProblems/Algorithms/Backspace_String_Compare.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const threeSum = require('../LeetcodeProblems/3Sum').threeSum;
+const threeSum = require('../../LeetcodeProblems/Algorithms/3Sum').threeSum;
 
 var test = function () {
   assert.deepEqual(threeSum([]), []);

LeetcodeProblems/Best_Time_To_Buy_And_Sell_Stock_II.js renamed to LeetcodeProblems/Algorithms/Best_Time_To_Buy_And_Sell_Stock_II.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
-const addTwoNumbers = require('../LeetcodeProblems/Add_Two_Numbers').addTwoNumbers;
-const ListNodeTestHelper = require('../utilsClasses/ListNodeTestHelper');
-var ListNode = require('../UtilsClasses/ListNode').ListNode;
+const addTwoNumbers = require('../../LeetcodeProblems/Algorithms/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]);

LeetcodeProblems/Binary_Gap.js renamed to LeetcodeProblems/Algorithms/Binary_Gap.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const cutAwardBadges = require('../LeetcodeProblems/Award_Budget_Cuts').cutAwardBadges;
+const cutAwardBadges = require('../../LeetcodeProblems/Algorithms/Award_Budget_Cuts').cutAwardBadges;
 
 function test() {
   assert.deepEqual(

LeetcodeProblems/Clone_Graph.js renamed to LeetcodeProblems/Algorithms/Clone_Graph.js

@@ -1,6 +1,6 @@
 const assert = require('assert');
-const backspaceCompare = require('../LeetcodeProblems/Backspace_String_Compare').backspaceCompare;
-const backspaceCompare2 = require('../LeetcodeProblems/Backspace_String_Compare').backspaceCompare2;
+const backspaceCompare = require('../../LeetcodeProblems/Algorithms/Backspace_String_Compare').backspaceCompare;
+const backspaceCompare2 = require('../../LeetcodeProblems/Algorithms/Backspace_String_Compare').backspaceCompare2;
 
 function test() {
   assert.equal(backspaceCompare("ab#c", "ad#c"), true); // true

LeetcodeProblems/Coin_Change.js renamed to LeetcodeProblems/Algorithms/Coin_Change.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const maxProfit = require('../LeetcodeProblems/Best_Time_To_Buy_And_Sell_Stock_II').maxProfit;
+const maxProfit = require('../../LeetcodeProblems/Algorithms/Best_Time_To_Buy_And_Sell_Stock_II').maxProfit;
 
 function test() {
   assert.equal(maxProfit([7,1,5,3,6,4]), 7);

LeetcodeProblems/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js renamed to LeetcodeProblems/Algorithms/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const binaryGap = require('../LeetcodeProblems/Binary_Gap').binaryGap;
+const binaryGap = require('../../LeetcodeProblems/Algorithms/Binary_Gap').binaryGap;
 
 function test() {
   assert.equal(binaryGap(22), 2); // 10110

LeetcodeProblems/Deletion_Distance.js renamed to LeetcodeProblems/Algorithms/Deletion_Distance.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const coinChange = require('../LeetcodeProblems/Coin_Change').coinChange;
+const coinChange = require('../../LeetcodeProblems/Algorithms/Coin_Change').coinChange;
 
 function test() {
   assert.equal(coinChange([], 3), -1);

LeetcodeProblems/Design_Circular_Deque.js renamed to LeetcodeProblems/Algorithms/Design_Circular_Deque.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-var buildTree = require('../LeetcodeProblems/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal').buildTree;
+var buildTree = require('../../LeetcodeProblems/Algorithms/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal').buildTree;
 
 function test() {
   // TODO

LeetcodeProblems/Edit_Distance.js renamed to LeetcodeProblems/Algorithms/Edit_Distance.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
-var deletionDistance = require('../LeetcodeProblems/Deletion_Distance').deletionDistance;
-var deletionDistance2 = require('../LeetcodeProblems/Deletion_Distance').deletionDistance2;
-var deletionDistanceDP = require('../LeetcodeProblems/Deletion_Distance').deletionDistanceDP;
+var deletionDistance = require('../../LeetcodeProblems/Algorithms/Deletion_Distance').deletionDistance;
+var deletionDistance2 = require('../../LeetcodeProblems/Algorithms/Deletion_Distance').deletionDistance2;
+var deletionDistanceDP = require('../../LeetcodeProblems/Algorithms/Deletion_Distance').deletionDistanceDP;
 
 function test() {
   assert.equal(deletionDistance("dog", "frog"), 3);

LeetcodeProblems/Escape_The_Ghosts.js renamed to LeetcodeProblems/Algorithms/Escape_The_Ghosts.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-var MyCircularDeque = require('../LeetcodeProblems/Design_Circular_Deque').MyCircularDeque;
+var MyCircularDeque = require('../../LeetcodeProblems/Algorithms/Design_Circular_Deque').MyCircularDeque;
 
 var test =  function() {
   const obj = new MyCircularDeque(3);

LeetcodeProblems/Flood_Fill.js renamed to LeetcodeProblems/Algorithms/Flood_Fill.js

@@ -1,6 +1,6 @@
 const assert = require('assert');
-var minDistance = require('../LeetcodeProblems/Edit_Distance').minDistance;
-var minDistance2 = require('../LeetcodeProblems/Edit_Distance').minDistance2;
+var minDistance = require('../../LeetcodeProblems/Algorithms/Edit_Distance').minDistance;
+var minDistance2 = require('../../LeetcodeProblems/Algorithms/Edit_Distance').minDistance2;
 
 function test() {
   assert.equal(minDistance("ros", "horse"), 3);

LeetcodeProblems/Generate_Parenthesis.js renamed to LeetcodeProblems/Algorithms/Generate_Parenthesis.js

@@ -1,6 +1,6 @@
 
 const assert = require('assert');
-var escapeGhosts = require('../LeetcodeProblems/Escape_The_Ghosts').escapeGhosts;
+var escapeGhosts = require('../../LeetcodeProblems/Algorithms/Escape_The_Ghosts').escapeGhosts;
 
 function test() {
   assert.equal(escapeGhosts([[1, 0], [0, 3]], [0, 1]), true);

LeetcodeProblems/Group_Anagrams.js renamed to LeetcodeProblems/Algorithms/Group_Anagrams.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const floodFill = require('../LeetcodeProblems/Flood_Fill').floodFill;
+const floodFill = require('../../LeetcodeProblems/Algorithms/Flood_Fill').floodFill;
 
 function test() {
   assert.deepEqual(

LeetcodeProblems/Implement_stack_using_queues.js renamed to LeetcodeProblems/Algorithms/Implement_stack_using_queues.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const groupAnagrams = require('../LeetcodeProblems/Group_Anagrams').groupAnagrams;
+const groupAnagrams = require('../../LeetcodeProblems/Algorithms/Group_Anagrams').groupAnagrams;
 
 function test() {
   assert.deepEqual(

LeetcodeProblems/Kth_Largest_Element_in_an_Array.js renamed to LeetcodeProblems/Algorithms/Kth_Largest_Element_in_an_Array.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const MyStack = require('../LeetcodeProblems/Implement_stack_using_queues').MyStack;
+const MyStack = require('../../LeetcodeProblems/Algorithms/Implement_stack_using_queues').MyStack;
 
 var test = function () {
   var myStack = new MyStack();

LeetcodeProblems/Linked_List_Cycle_II.js renamed to LeetcodeProblems/Algorithms/Linked_List_Cycle_II.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const findKthLargest = require('../LeetcodeProblems/Kth_Largest_Element_in_an_Array').findKthLargest;
+const findKthLargest = require('../../LeetcodeProblems/Algorithms/Kth_Largest_Element_in_an_Array').findKthLargest;
 
 function test() {
   assert.equal(findKthLargest([3,2,1,5,6,4], 2), 5);

LeetcodeProblems/Longest_Consecutive_Sequence.js renamed to LeetcodeProblems/Algorithms/Longest_Consecutive_Sequence.js

@@ -1,6 +1,6 @@
 const assert = require('assert');
-var ListNode = require('../UtilsClasses/ListNode').ListNode;
-const detectCycle = require('../LeetcodeProblems/Linked_List_Cycle_II').detectCycle;
+var ListNode = require('../../UtilsClasses/ListNode').ListNode;
+const detectCycle = require('../../LeetcodeProblems/Algorithms/Linked_List_Cycle_II').detectCycle;
 
 var test = function() {
   const cycle = buildCycle();

LeetcodeProblems/Longest_Palindromic_Substring.js renamed to LeetcodeProblems/Algorithms/Longest_Palindromic_Substring.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const longestConsecutive = require('../LeetcodeProblems/Longest_Consecutive_Sequence').longestConsecutive;
+const longestConsecutive = require('../../LeetcodeProblems/Algorithms/Longest_Consecutive_Sequence').longestConsecutive;
 
 function test() {
   assert.equal(longestConsecutive([100, 1, 200, 3, 2, 400, 201]), 3);

LeetcodeProblems/Lowest_Common_Ancestor_of_a_Binary_Tree.js renamed to LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const longestPalindrome = require('../LeetcodeProblems/Longest_Palindromic_Substring').longestPalindrome;
+const longestPalindrome = require('../../LeetcodeProblems/Algorithms/Longest_Palindromic_Substring').longestPalindrome;
 
 function test() {
   assert.equal(longestPalindrome("pabcdcbte"), "bcdcb");

LeetcodeProblems/Majority_Element.js renamed to LeetcodeProblems/Algorithms/Majority_Element.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
-var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
-const lowestCommonAncestor = require('../LeetcodeProblems/Lowest_Common_Ancestor_of_a_Binary_Tree').lowestCommonAncestor;
-const lowestCommonAncestor2 = require('../LeetcodeProblems/Lowest_Common_Ancestor_of_a_Binary_Tree').lowestCommonAncestor2;
+var TreeNode = require('../../UtilsClasses/TreeNode').TreeNode;
+const lowestCommonAncestor = require('../../LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree').lowestCommonAncestor;
+const lowestCommonAncestor2 = require('../../LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree').lowestCommonAncestor2;
 
 var test = function() {
   var root = new TreeNode(3);

LeetcodeProblems/Max_Area_Of_Island.js renamed to LeetcodeProblems/Algorithms/Max_Area_Of_Island.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const majorityElement = require('../LeetcodeProblems/Majority_Element').majorityElement;
+const majorityElement = require('../../LeetcodeProblems/Algorithms/Majority_Element').majorityElement;
 
 function test() {
   assert.equal(majorityElement([2,2,3]), 2);

LeetcodeProblems/Maximal_Square.js renamed to LeetcodeProblems/Algorithms/Maximal_Square.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const { maxAreaOfIsland } = require('../LeetcodeProblems/Max_Area_Of_Island');
+const { maxAreaOfIsland } = require('../../LeetcodeProblems/Algorithms/Max_Area_Of_Island');
 
 function test1() {
   var matrix = [

LeetcodeProblems/Maximun_Subarray.js renamed to LeetcodeProblems/Algorithms/Maximun_Subarray.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const maximalSquare = require('../LeetcodeProblems/Maximal_Square').maximalSquare;
+const maximalSquare = require('../../LeetcodeProblems/Algorithms/Maximal_Square').maximalSquare;
 
 function test() {
   assert.equal(maximalSquare([["1","0"]]), 1);

LeetcodeProblems/Min_Stack.js renamed to LeetcodeProblems/Algorithms/Min_Stack.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const maxSubArray = require('../LeetcodeProblems/Maximun_Subarray').maxSubArray;
+const maxSubArray = require('../../LeetcodeProblems/Algorithms/Maximun_Subarray').maxSubArray;
 
 function test() {
   assert.equal(maxSubArray([]), 0);

LeetcodeProblems/Minimum_Window_Substring.js renamed to LeetcodeProblems/Algorithms/Minimum_Window_Substring.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const MinStack = require('../LeetcodeProblems/Min_Stack').MinStack;
+const MinStack = require('../../LeetcodeProblems/Algorithms/Min_Stack').MinStack;
 
 function test() {
   var minStack = new MinStack();

LeetcodeProblems/NQueens.js renamed to LeetcodeProblems/Algorithms/NQueens.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const minWindow = require('../LeetcodeProblems/Minimum_Window_Substring').minWindow;
+const minWindow = require('../../LeetcodeProblems/Algorithms/Minimum_Window_Substring').minWindow;
 
 function test() {
   assert.equal(minWindow("ADOBECODEBANC", "ABC"), "BANC");

LeetcodeProblems/Number_of_Islands.js renamed to LeetcodeProblems/Algorithms/Number_of_Islands.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const solveNQueens = require('../LeetcodeProblems/NQueens').solveNQueens;
+const solveNQueens = require('../../LeetcodeProblems/Algorithms/NQueens').solveNQueens;
 
 // TODO: Add assertions
 

LeetcodeProblems/Number_of_Segments_in_a_String.js renamed to LeetcodeProblems/Algorithms/Number_of_Segments_in_a_String.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const numIslands = require('../LeetcodeProblems/Number_of_Islands').numIslands;
+const numIslands = require('../../LeetcodeProblems/Algorithms/Number_of_Islands').numIslands;
 
 function test() {
   assert.equal(numIslands([[1]]), 1);

LeetcodeProblems/Permutations.js renamed to LeetcodeProblems/Algorithms/Permutations.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const countSegments = require('../LeetcodeProblems/Number_of_Segments_in_a_String').countSegments;
+const countSegments = require('../../LeetcodeProblems/Algorithms/Number_of_Segments_in_a_String').countSegments;
 
 function test() {
   assert.equal(countSegments(" "), 0);

LeetcodeProblems/Permutations_II.js renamed to LeetcodeProblems/Algorithms/Permutations_II.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const permuteUnique = require('../LeetcodeProblems/Permutations_II').permuteUnique;
+const permuteUnique = require('../../LeetcodeProblems/Algorithms/Permutations_II').permuteUnique;
 
 function test() {
   assert.deepEqual(

LeetcodeProblems/Permutations_With_Duplicates.js renamed to LeetcodeProblems/Algorithms/Permutations_With_Duplicates.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const permute = require('../LeetcodeProblems/Permutations').permute;
+const permute = require('../../LeetcodeProblems/Algorithms/Permutations').permute;
 
 function test() {
   assert.deepEqual(permute([]), [ [] ]);

LeetcodeProblems/Permutations_Without_Duplicates.js renamed to LeetcodeProblems/Algorithms/Permutations_Without_Duplicates.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const subsetWithoutDuplicates = require('../LeetcodeProblems/Permutations_With_Duplicates').subsetWithoutDuplicates;
+const subsetWithoutDuplicates = require('../../LeetcodeProblems/Algorithms/Permutations_With_Duplicates').subsetWithoutDuplicates;
 
 var test = function() {
   assert.deepEqual(

LeetcodeProblems/Regular_Expression_Matching.js renamed to LeetcodeProblems/Algorithms/Regular_Expression_Matching.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const subsetWithoutDuplicates = require('../LeetcodeProblems/Permutations_Without_Duplicates').subsetWithoutDuplicates;
+const subsetWithoutDuplicates = require('../../LeetcodeProblems/Algorithms/Permutations_Without_Duplicates').subsetWithoutDuplicates;
 
 var test = function() {
   assert.deepEqual(

LeetcodeProblems/Remove_Invalid_Parentheses.js renamed to LeetcodeProblems/Algorithms/Remove_Invalid_Parentheses.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const isMatch = require('../LeetcodeProblems/Regular_Expression_Matching').isMatch;
+const isMatch = require('../../LeetcodeProblems/Algorithms/Regular_Expression_Matching').isMatch;
 
 var test = function() {
   assert.equal(isMatch("aa", "a"), false);

LeetcodeProblems/Restore_IP_Addresses.js renamed to LeetcodeProblems/Algorithms/Restore_IP_Addresses.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const removeInvalidParentheses = require('../LeetcodeProblems/Remove_Invalid_Parentheses').removeInvalidParentheses;
+const removeInvalidParentheses = require('../../LeetcodeProblems/Algorithms/Remove_Invalid_Parentheses').removeInvalidParentheses;
 
 var test = function() {
   assert.equal(removeInvalidParentheses("))))(()"), "()");

LeetcodeProblems/Reverse_String_II.js renamed to LeetcodeProblems/Algorithms/Reverse_String_II.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const restoreIpAddresses = require('../LeetcodeProblems/Restore_IP_Addresses').restoreIpAddresses;
+const restoreIpAddresses = require('../../LeetcodeProblems/Algorithms/Restore_IP_Addresses').restoreIpAddresses;
 
 var test = function() {
   assert.deepEqual(restoreIpAddresses("010010"), [ '0.10.0.10', '0.100.1.0']);

LeetcodeProblems/Same_Tree.js renamed to LeetcodeProblems/Algorithms/Same_Tree.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const reverseStr = require('../LeetcodeProblems/Reverse_String_II').reverseStr;
+const reverseStr = require('../../LeetcodeProblems/Algorithms/Reverse_String_II').reverseStr;
 
 var test = function() {
   assert.equal(reverseStr("abcdefg", 2), "bacdfeg");

LeetcodeProblems/SearchIng_Rotated_Sorted_Array.js renamed to LeetcodeProblems/Algorithms/SearchIng_Rotated_Sorted_Array.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const search = require('../LeetcodeProblems/SearchIng_Rotated_Sorted_Array').search;
+const search = require('../../LeetcodeProblems/Algorithms/SearchIng_Rotated_Sorted_Array').search;
 
 var test = function() {
   assert.equal(search([4,5,6,7,0,1,2], 5), 1);

LeetcodeProblems/Search_a_2D_Matrix.js renamed to LeetcodeProblems/Algorithms/Search_a_2D_Matrix.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const searchMatrix = require('../LeetcodeProblems/Search_a_2D_Matrix_II').searchMatrix;
+const searchMatrix = require('../../LeetcodeProblems/Algorithms/Search_a_2D_Matrix_II').searchMatrix;
 
 const matrix1 = [
   [1,4,7,    11,15],

LeetcodeProblems/Search_a_2D_Matrix_II.js renamed to LeetcodeProblems/Algorithms/Search_a_2D_Matrix_II.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const searchMatrix = require('../LeetcodeProblems/Search_a_2D_Matrix').searchMatrix;
+const searchMatrix = require('../../LeetcodeProblems/Algorithms/Search_a_2D_Matrix').searchMatrix;
 
 var test = function() {
   assert.equal(searchMatrix([], 0), false);

LeetcodeProblems/Set_Matrix_Zeroes.js renamed to LeetcodeProblems/Algorithms/Set_Matrix_Zeroes.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const setZeroes = require('../LeetcodeProblems/Set_Matrix_Zeroes').setZeroes;
+const setZeroes = require('../../LeetcodeProblems/Algorithms/Set_Matrix_Zeroes').setZeroes;
 
 var test = function() {
   assert.deepEqual(

LeetcodeProblems/Simplify_Path.js renamed to LeetcodeProblems/Algorithms/Simplify_Path.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const simplifyPath = require('../LeetcodeProblems/Simplify_Path').simplifyPath;
+const simplifyPath = require('../../LeetcodeProblems/Algorithms/Simplify_Path').simplifyPath;
 
 var test = function() { 
   assert.equal(simplifyPath("/../c"), "/c");

LeetcodeProblems/Spiral_Matrix.js renamed to LeetcodeProblems/Algorithms/Spiral_Matrix.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const spiralOrder = require('../LeetcodeProblems/Spiral_Matrix').spiralOrder;
+const spiralOrder = require('../../LeetcodeProblems/Algorithms/Spiral_Matrix').spiralOrder;
 
 var test = function() {
   const matrix = [

LeetcodeProblems/Subarray_Sum_Equals_K.js renamed to LeetcodeProblems/Algorithms/Subarray_Sum_Equals_K.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const subarraySum = require('../LeetcodeProblems/Subarray_Sum_Equals_K').subarraySum;
+const subarraySum = require('../../LeetcodeProblems/Algorithms/Subarray_Sum_Equals_K').subarraySum;
 
 var test  = function() {
   assert.strictEqual(subarraySum([1,1,1], 2), 2);

LeetcodeProblems/Subsets.js renamed to LeetcodeProblems/Algorithms/Subsets.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const subsets = require('../LeetcodeProblems/Subsets').subsets;
+const subsets = require('../../LeetcodeProblems/Algorithms/Subsets').subsets;
 
 function test() {
   assert.deepEqual(subsets([]), [[]]);

LeetcodeProblems/Sum_Of_Square_Numbers.js renamed to LeetcodeProblems/Algorithms/Sum_Of_Square_Numbers.js

@@ -1,5 +1,5 @@
 const assert = require('assert');
-const judgeSquareSum = require('../LeetcodeProblems/Sum_Of_Square_Numbers').judgeSquareSum;
+const judgeSquareSum = require('../../LeetcodeProblems/Algorithms/Sum_Of_Square_Numbers').judgeSquareSum;
 
 var test = function() {
   assert.strictEqual(judgeSquareSum(0), true);

LeetcodeProblems/Swap_Nodes_In_Pairs.js renamed to LeetcodeProblems/Algorithms/Swap_Nodes_In_Pairs.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
-const ListNode = require('../UtilsClasses/ListNode').ListNode;
-const ListNodeTestHelper = require('../utilsClasses/ListNodeTestHelper');
-const swapPairs = require('../LeetcodeProblems/Swap_Nodes_In_Pairs').swapPairs;
+const ListNode = require('../../UtilsClasses/ListNode').ListNode;
+const ListNodeTestHelper = require('../../UtilsClasses/ListNodeTestHelper');
+const swapPairs = require('../../LeetcodeProblems/Algorithms/Swap_Nodes_In_Pairs').swapPairs;
 
 var test = function () {
   ListNodeTestHelper.assertList(swapPairs(ListNode.linkenList([1,2,3,4])), [2,1,4,3]);