Merge branch 'neetcode-gh:main' into main

Author: josuebrunel

169-Majority Element.cpp

@@ -0,0 +1,21 @@
+char * longestCommonPrefix(char ** strs, int strsSize){
+    int commonPrefixCount = 0;
+    int firstStrSize = strlen(strs[0]);
+
+    for(int i = 0; i < firstStrSize; i++)
+    {
+        for(int s = 1; s < strsSize; s++)
+        {
+            if(i == strlen(strs[s]) || strs[0][i] != strs[s][i])
+            {
+                // Add null terminator after the last common prefix char
+                strs[0][commonPrefixCount] = '\0';
+                return strs[0];
+            }
+        }
+
+        commonPrefixCount++;
+    }
+
+    return strs[0];
+}

554-Brick-Wall.py

@@ -0,0 +1,141 @@
+/*
+ * Problem: Generate Parentheses (Medium)
+ * Link: https://leetcode.com/problems/generate-parentheses/
+ *
+ * The solution uses a backtracking approach to find all well-formed parantheses
+ * pairs.
+ */
+
+#include <math.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*---------------------------------------------------*/
+// Things get easier to manage with this structure
+// It will essentially act a minimal version of `std::string`.
+// The length of the string is always fixed as we know what the length is going
+// to be.
+struct _Str
+{
+  char* buf;
+  int len;
+  int idx;
+} DefStr = { .idx = 0 };
+
+// Doesn't add anything to the code other than convenience of writing `Str ...`
+// over `struct _Str ...`
+typedef struct _Str Str;
+
+// Pushes a character to the back of the Str
+void
+push_back(Str* self, char chr)
+{
+  if (self->idx > self->len) {
+    // Length check
+    return;
+  }
+  self->buf[self->idx++] = chr;
+}
+
+// Pops last character from the Str. Add Nullchar at the end just to signify the
+// end of string.
+void
+pop_back(Str* self)
+{
+  if (self->idx == 0) {
+    return;
+  }
+  self->buf[self->idx--] = '\0';
+}
+
+/*---------------------------------------------------*/
+
+/*
+ * This problem can be reduced to a subsets problem, where we explore every
+ * possible parantheses combination and keep the valid ones.
+ *
+ * To do so, we will --
+ * 1. Generate a combination
+ * 2. Check if it is balanced
+ * 3. Backtrack
+ * 4. Repeat
+ */
+void
+backtrack(char** results,
+          int n,
+          int open,
+          int closed,
+          Str* curr,
+          int* returnSize)
+{
+  if (closed > open) {
+    // This is the case when we prune the exploration of not well-formed
+    // parentheses
+    return;
+  }
+  if (open + closed == 2 * n) {
+    // ^ checking lengths
+    // Create a copy of the qualifying buffer and save it in Results
+    // wf = well-formed
+    results[*returnSize] = (char*)calloc(2 * n + 1, sizeof(char));
+    memcpy(results[*returnSize], curr->buf, 2 * n);
+    *returnSize = *returnSize + 1;
+    return;
+  }
+
+  if (open < n) {
+    // If we do not have enough opening brackets, add one till we have `n`
+    push_back(curr, '(');
+    backtrack(results, n, open + 1, closed, curr, returnSize);
+
+    // Pop this so that we can explore the other combinations
+    pop_back(curr);
+  }
+
+  if (closed < n) {
+    // If we do not have enough closing brackets, add one till we have `n`
+    push_back(curr, ')');
+    backtrack(results, n, open, closed + 1, curr, returnSize);
+
+    // Pop this so that we can explore the other combinations
+    pop_back(curr);
+  }
+}
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+char**
+generateParenthesis(int n, int* returnSize)
+{
+  /*
+   * Allocate enough memory for maximum possible combinations
+   * The maximum would ideally be every possible combination (included invalid
+   * ones). This is 2^(len of combination) == 2^(2 * n)
+   *
+   * Ofc, we will need less memory than this, but its fine.
+   *
+   * In the worst case according to our constraints, n = 9.
+   * In this case, we will allocate 2^9 * 8 = 4096 bytes, which is 4KB. So we
+   * can be sure that this program won't hog **too** much memory.
+   */
+
+  char** results = (char**)malloc(pow(2, 2 * n) * sizeof(char*));
+
+  // Length is excluding null character, calloc includes null character
+  // Calloc because it zeroes out our memory, so we automatically get a null
+  // character.
+  Str current = { .len = 2 * n, .buf = (char*)calloc(2 * n + 1, sizeof(char)) };
+
+  // We backtrack.
+  *returnSize = 0;
+  backtrack(results, n, 0, 0, &current, returnSize);
+
+  // Free the Str buffer as we won't need it now.
+  free(current.buf);
+
+  // Return results
+  return results;
+}

README.md

@@ -0,0 +1,25 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize){
+    int* disappearedNumbers = (int*)malloc(numsSize * sizeof(int)); // Allocate space for the worst case
+    *returnSize = 0; // Points to the first empty index in the array 
+
+    // Mark available numbers as negative
+    for(int i = 0; i < numsSize; i++)
+    {
+        int index = abs(nums[i]);
+        nums[index - 1] = -1 * abs(nums[index - 1]); 
+    }
+
+    // Find unmarked numbers (disappeared numbers)
+    for(int i = 0; i < numsSize; i++)
+    {
+        if(nums[i] > 0)
+        {
+            disappearedNumbers[(*returnSize)++] = i + 1; 
+        }
+    }
+
+    return disappearedNumbers;
+}

c/0014-Longest-Common-Prefix.c

@@ -0,0 +1,49 @@
+const int OBSTACLE = -1, EMPTY = 0, START = 1, END = 2;
+int uniquePathsIII(int** grid, int gridSize, int* gridColSize){
+    int startRow, startCol, endRow, endCol,
+        toVisit = 0, visited = 0, R = gridSize, C = gridColSize[0];
+    for(int row = 0; row < R; row++)
+        for(int col = 0; col < C; col++) {
+            //dereference the value of the current cell
+            int cell = grid[row][col];
+            if(cell != OBSTACLE) {
+                //all non obstacle cells must be visited
+                toVisit++;
+                //remember start and end cells
+                if(cell == START) {
+                    startRow = row;
+                    startCol = col;
+                } else if(cell == END) {
+                    endRow = row;
+                    endCol = col;
+                }
+            } else
+                //obstacles can be considered visited cells
+                visited |= 1 << (row*C + col);
+        }
+    
+    //The starting state is an empty path which will visit the start cell next
+    return solve(R, C, endRow, endCol, visited, toVisit, startRow, startCol);
+}
+
+int solve(int R, int C, int endRow, int endCol, int visited, int toVisit, int row, int col){
+    toVisit--;
+    //base case, we are at the end cell.
+    if(row == endRow && col == endCol)
+        return !toVisit;
+    
+    //add current cell to visited set
+    visited |= 1 << (row*C + col);
+    
+    //count paths which go through all other valid neighbor cells.
+    int ret = 0;
+    if(row > 0 && !(visited & (1 << ((row - 1)*C + col))))
+        ret += solve(R, C, endRow, endCol, visited, toVisit, row - 1, col);
+    if(row + 1 < R && !(visited & (1 << ((row + 1)*C + col))))
+        ret += solve(R, C, endRow, endCol, visited, toVisit, row + 1, col);
+    if(col > 0 && !(visited & (1 << (row*C + col - 1))))
+        ret += solve(R, C, endRow, endCol, visited, toVisit, row, col - 1);
+    if(col + 1 < C && !(visited & (1 << (row*C + col + 1))))
+        ret += solve(R, C, endRow, endCol, visited, toVisit, row, col + 1);
+    return ret;
+}

c/0022-generate-parentheses.c

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int guessNumber(int n) {
+        int low = 1;
+        int high = n;
+        
+        while(true) {
+            int mid = low + (high - low)/2;
+            int myGuess = guess(mid);
+            if(myGuess == 1)
+                low = mid + 1;
+            else if(myGuess == -1)
+                high = mid - 1;
+            else
+                return mid;
+        }
+    }
+};

c/0448-Find-All-Numbers-Disappeared-in-an-Array.c

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
+        // O (n + m)
+        map<int, int> nums1Idx; {
+            int idx = 0;
+            for(int n: nums1)
+                nums1Idx[n] = idx++;
+        }
+        vector<int> res;
+        for(int i = 0; i < nums1.size(); i++)
+            res.push_back(-1);
+        
+        stack<int> stack;
+        for(int i = 0; i < nums2.size(); i++) {
+            int cur = nums2[i];
+            
+            // while stack has elements and current is greater than the top of the stack
+            while(stack.size() && cur > stack.top()) {
+                int val = stack.top(); // take top val
+                stack.pop();
+                int idx = nums1Idx[val];
+                res[idx] = cur;
+            }
+            
+            if(nums1Idx.count(cur))
+                stack.push(cur);
+        }
+        
+        return res;
+    }
+};

c/0980-unique-paths-iii.c

@@ -0,0 +1,21 @@
+class Solution {
+private:
+    map<string, string> encodeMap;
+    map<string, string> decodeMap;
+    string base = "http://tinyurl.com/";
+public:
+    // Encodes a URL to a shortened URL.
+    string encode(string longUrl) {
+        if(!encodeMap.count(longUrl)) {
+            string shortUrl = base + to_string(encodeMap.size() + 1);
+            encodeMap[longUrl] = shortUrl;
+            decodeMap[shortUrl] = longUrl;
+        }
+        return encodeMap[longUrl];
+    }
+
+    // Decodes a shortened URL to its original URL.
+    string decode(string shortUrl) {
+        return decodeMap[shortUrl];
+    }
+};

cpp/0374-guess-number-higher-or-lower.cpp

@@ -0,0 +1,24 @@
+class Solution {
+private:
+    bool validPalindromeUtil(string s, int i, int j) {
+        while(i < j)
+            if(s[i] == s[j]) {
+                i += 1;
+                j -= 1;
+            } else
+                return false;
+        return true;
+    }
+public:
+    bool validPalindrome(string s) {
+        int i = 0, j = s.length() - 1;
+        
+        while(i < j)
+            if(s[i] == s[j]) {
+                i += 1;
+                j -= 1;
+            } else
+                return validPalindromeUtil(s, i + 1, j) || validPalindromeUtil(s, i, j - 1);
+        return true;
+    }
+};

cpp/0496-next-greater-element.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int numUniqueEmails(vector<string>& emails) {
+        set<string> unique_emails;
+        for(string email: emails) {
+            string local_name = email.substr(0, email.find('@'));
+            local_name = local_name.substr(0, email.find('+'));
+            local_name = regex_replace(local_name, regex("\\."), "");
+            string domain_name = email.substr(email.find('@') + 1, email.length());
+            email = local_name + '@' + domain_name;
+            unique_emails.insert(email);
+        }
+        return unique_emails.size();
+    }
+};

cpp/0535-encode-and-decode-tinyurl.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int maxNumberOfBalloons(string text) {
+        map<char, int> countText;
+        map<char, int> balloon;
+        for(char c: text)
+            countText[c]++;
+        for(char c: std::string("balloon"))
+            balloon[c]++;
+        
+        int res = text.length();
+        for(const auto &[key, value]: balloon)
+            res = min(res, countText[key] / value);
+        return res;
+    }
+};