Updated Project format

Author: AnasImloul

scripts/algorithms/0-9/01 Matrix/01 Matrix.cpp

@@ -0,0 +1,47 @@
+class Solution {
+   bool isValid(vector<vector<int>>& grid,int r,int c,int nr,int nc,int m,int n){
+        if(nr>=0 && nc>=0 && nr<m && nc<n && grid[nr][nc]==-1){
+            if(grid[r][c]==0)
+                grid[nr][nc]=1;
+            else
+                grid[nr][nc]=grid[r][c]+1;
+            return 1;
+        }
+        return 0;
+    }
+public:
+    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
+        queue<pair<int,int>>  q;
+        int m = mat.size();
+        int n = mat[0].size();
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(mat[i][j]==0)
+                    q.push({i,j});
+                else
+                    mat[i][j]=-1;
+            }
+        }
+        while(!q.empty()){
+            auto per = q.front();
+            int r = per.first;
+            int c = per.second;
+            // if()
+            q.pop();
+            if(isValid(mat,r,c,r-1,c,m,n)){
+                q.push({r-1,c});
+            }
+            if(isValid(mat,r,c,r+1,c,m,n)){
+                q.push({r+1,c});
+            }
+            if(isValid(mat,r,c,r,c-1,m,n)){
+                q.push({r,c-1});
+            }
+            if(isValid(mat,r,c,r,c+1,m,n)){
+                q.push({r,c+1});
+            }
+                    
+        }
+        return mat;
+    }
+};

scripts/algorithms/0-9/01 Matrix/01 Matrix.java

@@ -0,0 +1,56 @@
+class Solution {
+//  BFS
+// We add all 0 to the queue in the 0th level of the BFS. From there, every subsequent pair of indexes added would be 1 in the mat. THis way levels can represent the distance of a one from the closest 0 to it.
+    boolean visited[][];
+    
+    // Could also convert the indexes to a single number by mat[0].length * i + j.
+    class Pair{
+        int x;
+        int y;
+        Pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+    }
+    public int[][] updateMatrix(int[][] mat) {
+        int level = 0;
+        visited = new boolean[mat.length][mat[0].length];
+        Queue<Pair> q = new ArrayDeque<>();
+        // Addition of all pairs in mat that have 0.
+        for(int i = 0; i < mat.length; i++){
+            for(int j = 0; j < mat[0].length; j++){
+                if(mat[i][j] == 0){
+                    visited[i][j] = true;
+                    q.add(new Pair(i, j));
+                }
+            }
+        }
+        while(q.size()>0){
+            int size = q.size();
+            while(size-- > 0){
+                Pair p = q.remove();
+                mat[p.x][p.y] = level;
+                if(p.x > 0 && visited[p.x - 1][p.y] == false){
+                    visited[p.x-1][p.y] = true;
+                    q.add(new Pair(p.x-1, p.y));
+                }
+                if(p.x < mat.length - 1 && visited[p.x + 1][p.y] == false){
+                    visited[p.x+1][p.y] = true;
+                    q.add(new Pair(p.x+1, p.y));
+                    
+                }
+                if(p.y > 0 && visited[p.x][p.y-1] == false){
+                    visited[p.x][p.y-1] = true;
+                    q.add(new Pair(p.x, p.y-1));
+                    
+                }
+                if(p.y < mat[0].length-1 && visited[p.x][p.y + 1] == false){
+                    visited[p.x][p.y+1] = true;
+                    q.add(new Pair(p.x, p.y + 1));
+                }
+            }
+            level++;
+        }
+        return mat;
+    }
+}

scripts/algorithms/0-9/01 Matrix/01 Matrix.js

@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} mat
+ * @return {number[][]}
+ */
+var updateMatrix = function(mat) {
+  const rows = mat.length,
+        cols = mat[0].length;
+  
+  if (!rows) return mat;
+  
+  const queue = new Queue();
+  const dist = Array.from({length: rows}, () => new Array(cols).fill(Infinity));
+  
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (!mat[i][j]) {
+        dist[i][j] = 0;
+        queue.enqueue([i, j]);
+      }
+    }
+  }
+  
+  const dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]];
+  
+  while (!queue.isEmpty()) {
+    const [ row, col ] = queue.dequeue();
+    for (let i = 0; i < 4; i++) {
+      const nRow = row + dirs[i][0],
+            nCol = col + dirs[i][1];
+      
+      if (nRow < 0 || nCol < 0 || nRow >= rows || nCol >= cols) continue;
+      
+      if (dist[nRow][nCol] > dist[row][col] + 1) {
+        dist[nRow][nCol] = dist[row][col] + 1;
+        queue.enqueue([nRow, nCol]);
+      }
+    }
+  }
+  
+  return dist;
+};

scripts/algorithms/0-9/01 Matrix/01 Matrix.py

@@ -0,0 +1,21 @@
+class Solution:
+    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:
+        rows = len(mat)
+        cols = len(mat[0])
+        
+        for i in range(rows):
+            for j in range(cols):
+                if mat[i][j] != 0:
+                    top = mat[i-1][j] if i>0 else float('inf')
+                    left = mat[i][j-1] if j>0 else float('inf')
+                    mat[i][j] = 1 + min(top, left)
+        
+        for i in range(rows-1, -1, -1):
+            for j in range(cols-1, -1, -1):
+                if mat[i][j] != 0:
+                    right = mat[i][j+1] if j<cols-1 else float('inf')
+                    bottom = mat[i+1][j] if i<rows-1 else float('inf')
+                    mat[i][j] = min(min(right, bottom)+1, mat[i][j])
+                    
+        
+        return mat

scripts/algorithms/0-9/01 Matrix/info.json

@@ -0,0 +1,14 @@
+{
+    "id": "542",
+    "name": "01 Matrix",
+    "url": "https://leetcode.com/problems/01-matrix",
+    "difficulty": "medium",
+    "premium": false,
+    "topic": "algorithms",
+    "solution": {
+        "c++": true,
+        "python": true,
+        "java": true,
+        "javascript": true
+    }
+}

scripts/algorithms/0-9/1-bit and 2-bit Characters/1-bit and 2-bit Characters.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    bool isOneBitCharacter(vector<int>& bits) 
+    {
+        int n = bits.size();
+        if(n == 1)
+            return true;
+       
+        int i = 0;
+        while(i <= n - 2)
+        {
+            if(bits[i] == 0)
+                i++;
+            else 
+                i = i + 2;
+        }
+        if(i <= n-1)
+            return true;
+        else 
+            return false;
+        
+    }
+};

scripts/algorithms/0-9/1-bit and 2-bit Characters/1-bit and 2-bit Characters.java

@@ -0,0 +1,11 @@
+class Solution {
+    public boolean isOneBitCharacter(int[] bits) {
+        int ones = 0;
+        //Starting from one but last, as last one is always 0.
+        for (int i = bits.length - 2; i >= 0 && bits[i] != 0 ; i--) { 
+            ones++;
+        }
+        if (ones % 2 > 0) return false; 
+        return true;
+    }
+}

scripts/algorithms/0-9/1-bit and 2-bit Characters/1-bit and 2-bit Characters.js

@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} bits
+ * @return {boolean}
+ */
+var isOneBitCharacter = function(bits) {
+  let i = 0;
+  while (i < bits.length - 1) {
+    if (bits[i] === 1) i++;
+    i++;
+  }
+  return bits[i] === 0;
+};

scripts/algorithms/0-9/1-bit and 2-bit Characters/1-bit and 2-bit Characters.py

@@ -0,0 +1,30 @@
+# Dev: Chumicat
+# Date: 2019/11/30
+# Submission: https://leetcode.com/submissions/detail/282638543/
+# (Time, Space) Complexity : O(n), O(1)
+
+class Solution:
+    def isOneBitCharacter(self, bits: List[int]) -> bool:
+        """
+        :type bits: List[int]
+        :rtype: bool
+        """
+        # Important Rules:
+        # 1. If bit n is 0, bit n+1 must be a new char
+        # 2. If bits end with 1, last bit must be a two bit char
+        #    However, this case had been rejected by question
+        # 3. If 1s in row and end with 0, 
+        #    we can use count or 1s to check last char
+        #    If count is even, last char is "0"
+        #    If count is odd,  last char is "10"
+        # Strategy:
+        # 1. We don't care last element, since it must be 0.
+        # 2. We check from reversed, and count 1s in a row
+        # 3. Once 0 occur or list end, We stop counting
+        # 4. We use count to determin result
+        # 5. Since we will mod count by 2, we simplify it to bool
+        ret = True
+        for bit in bits[-2::-1]:
+            if bit: ret = not ret
+            else: break
+        return ret

scripts/algorithms/0-9/1-bit and 2-bit Characters/info.json

@@ -0,0 +1,14 @@
+{
+    "id": "717",
+    "name": "1-bit and 2-bit Characters",
+    "url": "https://leetcode.com/problems/1-bit-and-2-bit-characters",
+    "difficulty": "easy",
+    "premium": false,
+    "topic": "algorithms",
+    "solution": {
+        "c++": true,
+        "python": true,
+        "java": true,
+        "javascript": true
+    }
+}

scripts/algorithms/0-9/132 Pattern/132 Pattern.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    bool find132pattern(vector<int>& nums) {
+        // Initialise a empty stack "s"...
+        stack<int> s;
+        // To keep track of minimum element...
+        int min = INT_MIN;
+        // Run a Loop from last to first index...
+        for (int i = nums.size() - 1; i >= 0; i--) {
+            // If min is greater than nums[i], return true...
+            if (nums[i] < min)
+                return true;
+            // If stack is not empty &  nums[i] is greater than the top element of stack, then pop the element...
+            while (!s.empty() && nums[i] > s.top()) {
+                min = s.top();
+                s.pop();
+            }
+            // Otherwise, push nums[i] into stack...
+            s.push(nums[i]);
+        }
+        // If the condition is not satisfied, return false.
+        return false;
+    }
+};

scripts/algorithms/0-9/132 Pattern/132 Pattern.java

@@ -0,0 +1,19 @@
+class Solution {
+    public boolean find132pattern(int[] nums) {
+        int min = Integer.MIN_VALUE;
+        int peak = nums.length;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            // We find a "132" pattern if nums[i] < min, so return true...
+            if (nums[i] < min)
+                return true;
+            // If peak < nums.length & nums[i] is greater than the peak element...
+            while (peak < nums.length && nums[i] > nums[peak])
+                min = nums[peak++];
+            // Now we have nums[i] <= nums[peak]
+            // We push nums[i] to the "stack"            
+            peak--;
+            nums[peak] = nums[i];
+        }
+        return false;
+    }
+}

scripts/algorithms/0-9/132 Pattern/132 Pattern.js

@@ -0,0 +1,20 @@
+var find132pattern = function(nums) {
+    let m = -Infinity
+    // Initialise a empty stack...
+    const stack = []
+    // Run a Loop from last to first index...
+    for (let i = nums.length - 1; i >= 0; i--) {
+        // If nums[i] is greater than the top element of stack, then pop the element...
+        while (nums[i] > stack[stack.length - 1]) {
+            m = stack.pop()
+        }
+        // If m is greater than nums[i], return true...
+        if (nums[i] < m) {
+            return true
+        }
+        // Otherwise, push nums[i] into stack...
+        stack.push(nums[i])
+    }
+    // If the condition is not satisfied, return false.
+    return false
+};

scripts/algorithms/0-9/132 Pattern/132 Pattern.py

@@ -0,0 +1,21 @@
+class Solution(object):
+    def find132pattern(self, nums):
+        # Base Condition...
+        if len(nums) < 3:
+            return False
+        m = float('-inf')
+        # Initialise a empty stack...
+        stack = []
+        # Run a Loop from last to first index...
+        for i in range(len(nums)-1, -1, -1):
+            # If m is greater than nums[i], return true...
+            if nums[i] < m:
+                return True
+            # If stack is not empty &  nums[i] is greater than the top element of stack, then pop the element...
+            else:
+                while stack and stack[-1] < nums[i]:
+                    m = stack.pop()
+            # Otherwise, append nums[i] into stack...
+            stack.append(nums[i])
+        # If the condition is not satisfied, return false.
+        return False

scripts/algorithms/0-9/132 Pattern/info.json

@@ -0,0 +1,14 @@
+{
+    "id": "456",
+    "name": "132 Pattern",
+    "url": "https://leetcode.com/problems/132-pattern",
+    "difficulty": "medium",
+    "premium": false,
+    "topic": "algorithms",
+    "solution": {
+        "c++": true,
+        "python": true,
+        "java": true,
+        "javascript": true
+    }
+}

scripts/algorithms/0-9/2 Keys Keyboard/2 Keys Keyboard.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    int minSteps(int n) {
+        for (int j = n/2; j >= 1; j--) {
+            if (n % j == 0) {
+                return minSteps(j) + n/j;
+            }
+        }
+        return 0;
+    }
+};