Rename file for correct name ordering

Author: alexwawl

solutions/1_TwoSum.js renamed to solutions/0001_TwoSum.js

@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} val
+ * @return {TreeNode}
+ */
+var searchBST = function(root, val) {
+    function helper(root,val){
+        if(root){
+            if(val < root.val){
+                return helper(root.left,val)
+            } else if (val> root.val){
+                return helper(root.right,val)
+            }
+            return root ;
+        }
+    }
+    let result = helper(root,val)
+    return result != undefined ? result : null
+};

solutions/1_TwoSum.py renamed to solutions/0001_TwoSum.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def floodFill(self, image, sr, sc, newColor):
+        """
+        :type image: List[List[int]]
+        :type sr: int
+        :type sc: int
+        :type newColor: int
+        :rtype: List[List[int]]
+        """
+        def helper(i,j, target, newColor):
+            if i< 0 or i >= len(image) or j < 0 or j >= len(image[0]):
+                return
+
+            if image[i][j] != target or image[i][j] == newColor:
+                return
+            else:
+                image[i][j] = newColor
+                helper(i+1,j,target,newColor)
+                helper(i-1,j,target,newColor)
+                helper(i,j+1,target,newColor)
+                helper(i,j-1,target,newColor)
+                
+        helper(sr,sc,image[sr][sc],newColor)
+        return image

solutions/2_AddTwoNumbers.js renamed to solutions/0002_AddTwoNumbers.js

@@ -0,0 +1,48 @@
+/**
+ * @param {string} S
+ * @return {string}
+ */
+//NOT OPTIMIZED SOLUTION
+var reorganizeString = function(S) {
+    let result = '';
+    let dict = {};
+    for(let i=0;i<S.length;i++){
+        if(dict[S[i]]){
+            dict[S[i]]++
+        } else{
+            dict[S[i]] = 1;
+        }
+    }
+    let sortable = [];
+    for(let key in dict){
+        sortable.push([key,dict[key]])
+    }
+    sortable = sortable.sort((a,b)=>{
+        return b[1]-a[1]
+    })
+    let index=0;
+    while(sortable.length > 0 ){
+        if(result[index-1]==sortable[0][0]){
+            //next after max
+            result = result + sortable[1][0]
+            sortable[1][1] = sortable[1][1] - 1;
+            if(sortable[1][1] < 1){
+                sortable.splice(1,1); //if char count <= 0 remove it from array
+            }
+        } else {
+            result = result + sortable[0][0]
+            sortable[0][1] = sortable[0][1] - 1;
+            if(sortable[0][1] < 1){
+                sortable.splice(0,1); //if char count <= 0 remove it from array
+            }
+        }
+        index++;
+        sortable = sortable.sort((a,b)=>{
+            return b[1]-a[1]
+        })
+        if(sortable.length == 1 && sortable[0][0] == result[index-1]){
+            return ''
+        }
+    }
+    return result;
+};

solutions/2_AddTwoNumbers.py renamed to solutions/0002_AddTwoNumbers.py

@@ -0,0 +1,18 @@
+/**
+ * @param {string} J
+ * @param {string} S
+ * @return {number}
+ */
+var numJewelsInStones = function(J, S) {
+    let jewels_dict = {};
+    let count = 0;
+    for(let i=0;i<J.length;i++){
+        jewels_dict[J[i]] = true;
+    }
+    for(let i=0;i<S.length;i++){
+        if(jewels_dict[S[i]]){
+            count = count+1;
+        }
+    }
+    return count
+};

solutions/3_LongestSubstringWithoutRepeatingCharacters.js renamed to solutions/0003_LongestSubstringWithoutRepeatingCharacters.js

@@ -0,0 +1,28 @@
+/**
+ * @param {number} N
+ * @param {number} K
+ * @return {number}
+ */
+var kthGrammar = function(N, K) {
+    function helper(n,k){
+        if(n===1){
+            if(k===1){
+                return 0;
+            } else {
+                return 1;
+            }
+        }
+        let half = Math.pow(2,n-1);
+        if(k<=half){
+            return helper(n-1,k)
+        } else {
+            let result = helper(n-1, k-half)
+            if(result == 0){
+                return 1
+            } else {
+                return 0
+            }
+        }
+    }
+    return helper(N,K)
+};

solutions/3_LongestSubstringWithoutRepeatingCharacters.py renamed to solutions/0003_LongestSubstringWithoutRepeatingCharacters.py

@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortArray = function(nums) {
+    function mergeSort(nums){
+        if(nums.length <=1){
+            return nums
+        }
+        let half = nums.length/2;
+        let left_side = mergeSort(nums.slice(0,half))
+        let right_side = mergeSort(nums.slice(half))
+        return merge(left_side, right_side)
+    }
+    
+    function merge(left,right){
+        let lPointer = 0;
+        let rPointer = 0;
+        let result = [];
+        while(lPointer < left.length && rPointer <right.length){
+            if(left[lPointer]<right[rPointer]){
+                result.push(left[lPointer])
+                lPointer++;
+            } else {
+                result.push(right[rPointer]);
+                rPointer++;
+            }
+        }
+        
+        return result.concat(left.slice(lPointer)).concat(right.slice(rPointer));
+    }
+    
+    return mergeSort(nums);
+};

solutions/7_ReverseInteger.js renamed to solutions/0007_ReverseInteger.js

@@ -0,0 +1,21 @@
+/**
+ * @param {string} S
+ * @return {number}
+ */
+var minAddToMakeValid = function(S) {
+    var balance = 0;
+    var result = 0;
+    for(let i = 0;i<S.length;i++){
+        if(S[i] === '('){
+            balance = balance + 1;
+        } else {
+            balance = balance - 1;
+        }
+        // if we should add 
+        if(balance == -1){
+            result = result + 1;
+            balance = balance + 1;
+        }
+    }
+    return result+balance
+};

solutions/9_PalindromeNumber.py renamed to solutions/0009_PalindromeNumber.py

@@ -0,0 +1,79 @@
+/**
+ * @param {number[][]} A
+ * @return {number}
+ */
+var shortestBridge = function(A) {
+    let queue = []
+    function dfs(board, i, j){
+        if(i<0 || i>=board.length || j < 0 || j >= board[0].length || board[i][j]!=1){
+            return;
+        }
+        //mark 1 island as visited
+        board[i][j]="#";
+        // add each point of current island for future searching.
+        queue.push([i,j])
+        dfs(board,i+1,j);
+        dfs(board,i-1,j);
+        dfs(board,i,j+1);
+        dfs(board,i,j-1);
+    }
+    
+    let found = false;
+    for(let i=0;i<A.length;i++){
+        if(found){
+            break;
+        }
+        for(let j=0;j<A[0].length;j++){
+            if(A[i][j]==1){
+                dfs(A,i,j)
+                found = true;
+                break;
+            }
+        }
+    }
+    let bridge_count = 0;
+    let rows = A.length;
+    let cols = A[0].length;
+    while(queue.length != 0){
+        let size = queue.length;
+        // from each point of first island try to find shortest path to another island
+        for(let i = 0; i<size; i++){
+            let current = queue.shift();
+            let curr_i = current[0];
+            let curr_j = current[1];
+            
+            //if we find bounderies for second island  -> return bridge count;
+            if(curr_i > 0 && A[curr_i-1][curr_j] == 1 ||
+              curr_i < rows-1 && A[curr_i+1][curr_j] == 1 ||
+              curr_j > 0 && A[curr_i][curr_j-1] == 1 ||
+              curr_j < cols-1 && A[curr_i][curr_j+1] == 1){
+                return bridge_count;
+            }
+            
+            // else mark all zeros as visited
+            if(curr_i > 0 && A[curr_i-1][curr_j]==0){
+                // Mark as visited and try to find from this coordinate on the next step;
+                queue.push([curr_i-1,curr_j])
+                A[curr_i-1][curr_j] = "#"
+            }
+            if(curr_i < rows-1 && A[curr_i+1][curr_j]==0){
+                // Mark as visited and try to find from this coordinate on the next step;
+                queue.push([curr_i+1,curr_j])
+                A[curr_i+1][curr_j] = "#"
+            }
+            if(curr_j > 0 && A[curr_i][curr_j-1]==0){
+                // Mark as visited and try to find from this coordinate on the next step;
+                queue.push([curr_i,curr_j-1])
+                A[curr_i][curr_j-1] = '#'
+            }
+            if(curr_j < cols-1 && A[curr_i][curr_j+1]==0){
+                // Mark as visited and try to find from this coordinate on the next step;
+                queue.push([curr_i,curr_j+1])
+                A[curr_i][curr_j+1] = '#'
+            }
+        }
+        //if we can't find another island, built 1 bridge and continue
+        bridge_count++;
+    } 
+    return bridge_count
+};

solutions/11_ContainerWithMostWater.js renamed to solutions/0011_ContainerWithMostWater.js

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} L
+ * @param {number} R
+ * @return {number}
+ */
+var rangeSumBST = function(root, L, R) {
+    function dfs(root, L, R){
+        if(!root){
+            return 0
+        } else if(!root.left && !root.right){
+            if(root.val >= L && root.val<=R){
+                return root.val
+            } else {
+                return 0
+            }
+        } else {
+            if(root.val >= L && root.val <= R){
+                return root.val + dfs(root.left, L, R) + dfs(root.right, L, R)
+            } else {
+                return 0 + dfs(root.left, L, R) + dfs(root.right, L, R)
+            }
+            
+        }
+    }
+    return dfs(root, L, R)
+};

solutions/11_ContainerWithMostWater.py renamed to solutions/0011_ContainerWithMostWater.py

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isUnivalTree = function(root) {
+    let dict = {};
+    
+    function helper(root){
+        if(Object.keys(dict).length > 1){
+            return false
+        }
+        if(root){
+            if(!dict[root.val]){
+                dict[root.val] = true;
+            }
+            return helper(root.left) && helper(root.right);
+        }
+        return true
+    }
+    
+    return helper(root)
+};

solutions/13_RomanToInteger.py renamed to solutions/0013_RomanToInteger.py

@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} points
+ * @param {number} K
+ * @return {number[][]}
+ */
+var kClosest = function(points, K) {
+    //calc distance
+    function distance(a){
+        //assume that b is 0;
+        return Math.sqrt(Math.pow(a[0],2) + Math.pow(a[1],2));
+    }
+    let result =  [];
+    points.forEach(point => {
+       let obj = {key: point, distance: distance(point)}
+       result.push(obj)
+    })
+   result = result.sort((a,b)=>{
+       return a.distance - b.distance
+   }).map((a)=>{
+       return a.key;
+   })
+    return result.slice(0,K)
+};