More leetcode

theEmbeddedGeorge · theEmbeddedGeorge · commit 21f39ce13b5e · 2021-02-20T17:30:58.000-08:00
diff --git a/Data_Struct_Implementation/memoryMap/memory_map_io.md b/Data_Struct_Implementation/memoryMap/memory_map_io.md
@@ -72,4 +72,8 @@ typedef struct {
     _IO uint32_t BRR,
     _IO uint32_t ASCR,  
 } GPIO_REG;
-```
+```
+
+## Reference 
+
+[Yifeng zhu - Embedded Systems with ARM Cortex-M Microcontrollers in Assembly Language and C: Third Edition](https://www.youtube.com/watch?v=aT5XMOrid7Y&list=PLRJhV4hUhIymmp5CCeIFPyxbknsdcXCc8&index=5&ab_channel=EmbeddedSystemswithARMCortex-MMicrocontrollersinAssemblyLanguageandC)
diff --git a/Interview/Algorithm/Array.md b/Interview/Algorithm/Array.md
@@ -0,0 +1,202 @@
+## Problems
+
+1. Running Sum of 1d Array
+2. Continuous Subarray Sum
+3. Random Pick with Weight
+4. Friends Of Appropriate Ages
+
+
+## Implementation
+
+### **Running Sum of 1d Array**
+
+***Big O:*** O(n) speed, O(1) space
+```
+Tips: 
+
+Use the sum of previous item.
+```
+```c++
+class Solution {
+public:
+    vector<int> runningSum(vector<int>& nums) {
+        vector<int> running_sum(nums.size(), 0);
+        running_sum[0] = nums[0];
+        
+        for (int i = 1; i < nums.size(); i++) {
+            running_sum[i] = nums[i] + running_sum[i-1];
+        }
+        
+        return running_sum;
+    }
+};
+```
+
+### **Continuous Subarray Sum**
+
+***Big O:*** O(n) speed, O(n) space
+```
+Tips: 
+
+a%k = x
+b%k = x
+(a - b) %k = x -x = 0
+here a - b = the sum between i and j.
+```
+```c++
+class Solution {
+public:
+    bool checkSubarraySum(vector<int>& nums, int k) {
+        if(nums.size()<2)
+            return false;
+    
+        unordered_map<int, int> mp;
+    
+        // <0,-1> can allow it to return true when the runningSum%k=0,
+        mp[0]=-1;
+        
+        int runningSum=0;
+        for(int i=0;i<nums.size();i++) {
+            runningSum+=nums[i];
+            
+            if(k!=0) 
+                runningSum = runningSum%k;
+            
+            //check if the runningsum already exists in the hashmap
+            if(mp.find(runningSum)!=mp.end()) {
+                //if it exists, then the current location minus the previous location must be greater than1
+                if(i-mp[runningSum]>1)
+                    return true;
+            }
+            else
+                mp[runningSum]=i; 
+        }
+        return false;
+    }
+};
+```
+
+### **Random Pick with Weight**
+
+***Big O:*** O(log(n)) speed, O(n) space
+```
+Tips: 
+
+Prefix Sums with Binary Search.
+```
+```c++
+class Solution {
+    vector<int> sums;
+    
+public:
+    Solution(vector<int>& w) {
+        sums = vector<int>(w.size(), 0);
+        sums[0] = w[0];
+        
+        for (int i = 1; i < sums.size(); i++) {
+            sums[i] = w[i] + sums[i-1];
+        }
+    }
+    
+    int pickIndex() {
+        int w_index = rand()%(sums.back());
+        
+        int st = 0;
+        int end = sums.size() - 1;
+        int ret;
+        
+        while (st < end) {
+            int mid = st + (end-st)/2;
+            
+            if (sums[mid] <= w_index) {
+                st = mid + 1;
+            } else{
+                end = mid;
+            }
+        }
+        
+        return st;
+    }
+};
+
+```
+
+### **Friends Of Appropriate Ages**
+
+***Big O:*** O(nlog(n)) speed, O(n) space
+```
+Tips: 
+Approache 1:
+
+Calculate the target value and then do a binary search. For ages we already went through, simply add the number of requests for that age.
+
+Approach 2:
+
+Instead of processing all 20000 people, we can process pairs of (age, count) representing how many people are that age. Since there are only 120 possible ages, this is a much faster loop.
+```
+```c++
+// Approach 2
+class Solution {
+public:
+    int numFriendRequests(vector<int>& ages) {
+        int count[121] = {};
+        for (int age: ages) count[age]++;
+
+        int ans = 0;
+        for (int ageA = 0; ageA <= 120; ageA++) {
+            int countA = count[ageA];
+            for (int ageB = 0; ageB <= 120; ageB++) {
+                int countB = count[ageB];
+                if (ageA/2 + 7 >= ageB) continue;
+                if (ageA < ageB) continue;
+                if (ageA < 100 && 100 < ageB) continue;
+                ans += (countA * countB);
+                if (ageA == ageB) ans -= countA;
+            }
+        }
+
+        return ans;
+    }
+};
+
+// Approach 1
+class Solution {
+public:
+    unordered_map <int,int> map; // key: age, val: FriendRequestCount. 
+    
+    int findRequests (vector<int> & ages, int index) {
+        
+        if (map.find(ages[index]) != map.end()) {
+            return map[ages[index]];
+        }
+        
+        int left = 0;
+        int right = index-1;
+        double target = (double) (0.5*ages[index]) + 7; // find ages >= target.
+        
+        while (left <= right) {
+            int mid = left + (right-left)/2;
+            if (ages[mid] <= target) {
+                left = mid+1;
+            } else {
+                right = mid-1;
+            }
+        }
+        
+        map[ages[index]] = index-left;
+        return index-left; // len between index-1 and left. 
+    }
+    
+    int numFriendRequests(vector<int>& ages) {
+        
+        sort (ages.begin(), ages.end());
+        
+        int count = 0;
+        
+        for (int i = ages.size()-1; i >= 0 ; i--) {
+            count += findRequests (ages, i);
+        }
+        return count;
+    }
+};
+```
diff --git a/Interview/Algorithm/LeetCode_for_embedded_advanced.md b/Interview/Algorithm/LeetCode_for_embedded_advanced.md
@@ -64,6 +64,10 @@
 15. Find the Duplicate Number                  v
 16. Container With Most Water                  v
 17. Verifying an Alien Dictionary              v
+18. Running Sum of 1d Array                    v
+19. Continuous Subarray Sum                    v
+20. Random Pick with Weight                    v
+21. Friends Of Appropriate Ages                v
 
 ***Math:***
 1.  Add Binary                                 v
@@ -72,6 +76,9 @@
 4.  Fibonacci Number                           v
 5.  Pow(x, n)
 6.  Divide Two Integers                        v
+7.  Reverse Integer without long long          v
+8.  Palindrome Number                          v
+9.  Dot Product of Two Sparse Vectors          v
 
 ***Matirx:***
 1.  Give the center of a matrix and then draw circle
diff --git a/Interview/Algorithm/math.md b/Interview/Algorithm/math.md
@@ -0,0 +1,106 @@
+## Problems
+
+1. Reverse Integer without using long long
+2. Palindrome Number
+3. Dot Product of Two Sparse Vectors
+
+
+## Implementation
+### **Dot Product of Two Sparse Vectors**
+
+***Big O:*** O(k) speed - k is the size of the array with smaller length, O(n) space
+```
+Tips: 
+
+Use hashmap to store <index, value>. While performing the dot product, iterate through the hashmap of the more sparse array and do the sum.
+```
+```c++
+class SparseVector {
+public:
+    unordered_map<int, int> umap;
+    
+    SparseVector(vector<int> &nums) {
+        for (int i = 0; i < nums.size(); i++) {
+            if (nums[i] != 0)
+                umap[i] = nums[i];
+        }
+    }
+    
+    // Return the dotProduct of two sparse vectors
+    int dotProduct(SparseVector& vec) {
+        int sum = 0;
+        
+        if (vec.umap.size() < this->umap.size()) {
+            for (auto it : vec.umap) {
+                if (umap.find(it.first) != umap.end())
+                    sum += umap[it.first]*it.second;
+            }
+        } else {
+             for (auto it : umap) {
+                if (vec.umap.find(it.first) != vec.umap.end())
+                    sum += vec.umap[it.first]*it.second;
+            }
+        }
+        
+        return sum;
+    }
+};
+
+```
+
+### **Reverse Integer without using long long**
+
+***Big O:*** O(n) speed, O(1) space
+```
+Tips: 
+
+Check overflow by comparing with boundary value divided by 10. 
+
+Another approach could be first casting the integer to string and then do the comparison on strings.
+```
+```c++
+class Solution {
+public:
+    int reverse(int x) {
+        int y=0;
+        while(x){
+            if(y>INT_MAX/10 || y<INT_MIN/10){
+                return 0;
+            }else{
+                y=y*10 +x%10;
+                x=x/10;
+            }
+        }
+        return y;
+    }
+};
+```
+
+## **Palindrome Number**
+
+***Big O:*** O(n) speed, O(1) space
+```
+Tips: 
+
+Reverse integer and compare it with the original one. Return true if equal. Be careful with overflow. Use long long for the reversed number variable.
+```
+```c++
+class Solution {
+public:
+    bool isPalindrome(int x) {
+        if (x < 0)
+            return false;
+        
+        long long temp = x, dummy = 0;
+        
+        while (temp) {
+            dummy *= 10;
+            dummy += temp%10;
+            temp /= 10;
+        }
+        
+        return (long long) x == dummy;
+    }
+};
+
+```
diff --git a/Operating_System/Interrupt.md b/Operating_System/Interrupt.md
