More code

Author: theEmbeddedGeorge

Data_Struct_Implementation/BitsManipulation/countBitsLookUpTable.md

@@ -0,0 +1,51 @@
+## Count Set Bits with lookup table
+
+To have a lookup table is a very fast way to check values. This is extremely useful for questions like [***Program to count number of set bits in an (big) array***](https://www.geeksforgeeks.org/program-to-count-number-of-set-bits-in-an-big-array/).
+
+Basiclly we have an array of 256 entrys that record the number of set bits for 0 - 255 (Cover 8-bit representation). Then we could simply break 32-bit number into 4 parts and use the table to check for each 8 bit and sum it up.
+
+```c++
+#include <bits/stdc++.h>
+using namespace std;
+ 
+int BitsSetTable256[256];
+ 
+// Function to initialise the lookup table 
+void initialize() 
+{ 
+ 
+    // To initially generate the 
+    // table algorithmically 
+    BitsSetTable256[0] = 0; 
+    for (int i = 0; i < 256; i++)
+    { 
+        BitsSetTable256[i] = (i & 1) + 
+            BitsSetTable256[i / 2]; 
+    } 
+} 
+ 
+// Function to return the count 
+// of set bits in n 
+int countSetBits(int n) 
+{ 
+    unsigned char *num = (unsigned char *) &n;
+    return (BitsSetTable256[num[0]] + 
+            BitsSetTable256[num[1]] + 
+            BitsSetTable256[num[2]] + 
+            BitsSetTable256[num[3]]);
+
+    /*return (BitsSetTable256[n & 0xff] + 
+            BitsSetTable256[(n >> 8) & 0xff] + 
+            BitsSetTable256[(n >> 16) & 0xff] + 
+            BitsSetTable256[n >> 24]);*/
+} 
+ 
+// Driver code 
+int main() 
+{ 
+    // Initialise the lookup table 
+    initialize(); 
+    int n = 9; 
+    cout << countSetBits(n);
+} 
+```

Interview/Company/facebook/algorithm_prepare.md

@@ -46,12 +46,16 @@
 ## String
 1. Valid Anagram        Easy
 2. Integer to English Words     Hard
+3. Read 4 bytes         Easy
+4. Read 4 bytes II (call multiple times)    Hard
 
 ## Bits Manipulation
 1. Is Power of Four     Easy
+2. Bitwise AND of Numbers Range     Medium
 
-## Data Structure
-1. LRU cache
+## Data Structure   
+1. LRU cache    Hard
+2. Exclusive Time of Functions  Medium
 
 ## Implementation
 
@@ -1767,4 +1771,149 @@ public:
         return res;
     }
 };
-```
+```
+
+### **Candy**
+
+***Big O:*** O(1) speed, O(1) space
+```
+Tips:
+
+Only need to count the prefix part of n and m.
+```
+```c++
+class Solution {
+public:
+    int rangeBitwiseAnd(int m, int n) {
+        while (m < n) {
+            n &= n - 1;
+        }
+        
+        return m & n;
+    }
+};
+```
+
+### **Read N Characters Given Read4**
+
+***Big O:*** O(log(n)) speed, O(1) space
+```
+Tips:
+
+Use a temperary string to store read4 results. Be careful with situation where read4 returns with fewer than 4 bytes.
+```
+```c++
+class Solution {
+public:
+ 
+    int read(char *buf, int n) {
+        int read_bytes = 0, read4_bytes = 4;
+        char tmp_buf[4];
+        
+        while (read_bytes < n && read4_bytes == 4) {
+            read4_bytes = read4(tmp_buf);
+            
+            for (int i = 0; i < read4_bytes; i++) {
+                if (read_bytes >= n)
+                    return read_bytes;
+                *buf++ = tmp_buf[i];
+                read_bytes ++;
+            }
+        }
+        
+        return read_bytes;
+    }
+};
+```
+
+### **Read N Characters Given Read4 II (call multiple times)**
+
+***Big O:*** O(log(n)) speed, O(1) space
+```
+Tips:
+
+Use private data variables to keep track of the leftover position from last call.
+```
+```c++
+class Solution {
+    int pos = 0, read4_bytes = 0;
+    char tmp_buf[4];
+
+public:
+    int read(char *buf, int n) {
+        int read_bytes = 0;
+        
+        // if there is leftover
+        while (pos < read4_bytes && read_bytes < n) {
+            *buf++ = tmp_buf[pos++];
+            read_bytes ++;
+        }
+        
+        while (read_bytes < n) {
+            read4_bytes = read4(tmp_buf);
+
+            for (pos = 0; pos < read4_bytes;) {
+                if (read_bytes >= n)
+                    return read_bytes;
+
+                *buf++ = tmp_buf[pos++];
+                read_bytes ++;
+            }
+                
+            if (read4_bytes != 4)
+                break;
+        }
+        
+        return read_bytes;
+    }
+};
+```
+
+### **Exclusive Time of Functions**
+
+***Big O:*** O(n) speed, O(n) space
+```
+Tips:
+
+Use of stack. When you update the time, remember to deduce the duplicate time part of the top item in the stack.
+```
+```c++
+class Solution {
+    struct Log {
+        int id;
+        bool isStart;
+        int time;
+    };
+    
+    Log getLog(string& s) {
+        string id, isStart, time;
+        stringstream ss(s);
+        getline(ss, id, ':');
+        getline(ss, isStart, ':');
+        getline(ss, time, ':');
+
+        return {stoi(id), isStart == "start", stoi(time)};
+    }
+    
+public:
+    vector<int> exclusiveTime(int n, vector<string>& logs) {
+        vector<int> exclusive(n, 0);
+        stack<Log> s;
+        
+        for(auto& log: logs) {
+            Log l = getLog(log);
+            if(l.isStart)
+                s.push(l);
+            else {
+                int time = l.time - s.top().time + 1;
+                exclusive[l.id] += time;
+                
+                s.pop();
+                if(!s.empty())
+                    exclusive[s.top().id] -= time;
+            }
+        }
+        
+        return exclusive;
+    }
+};

Interview/Company/facebook/leetcodeOSflavor.md

@@ -0,0 +1,8 @@
+## Leetcode problems with OS flavor
+
+1. Read 4 bytes         Easy
+2. Read 4 bytes II (call multiple times)    Hard
+3. LRU cache    Hard
+4. LFU cache    Hard
+5. Exclusive Time of Functions  Medium
+6. Task Scheduler   Medium

README.md

@@ -90,17 +90,18 @@
 13. Bits Manipulation
     1.  [Reverse Bits](Data_Struct_Implementation/BitsManipulation/reverseBits.md)
     2.  Flip a monochrome bitmap
-    3.  [Length of the Longest Consecutive 1s in Binary Representation](https://www.geeksforgeeks.org/length-longest-consecutive-1s-binary-representation/)
-    4.  [Find most significant set bit of a number](https://www.geeksforgeeks.org/find-significant-set-bit-number/)
-    5.  [Swap two number without temporary varaible](https://www.geeksforgeeks.org/swap-two-numbers-without-using-temporary-variable/)
-    6.  [Number is a power of 2](https://www.geeksforgeeks.org/bits-manipulation-important-tactics/)
-    7.  [Swap all odd and even bits](Data_Struct_Implementation/BitsManipulation/swapOddEvenBIts.md)
-    8.  [Find position of the only set bit](Data_Struct_Implementation/BitsManipulation/positionOfSetBit.md)
-    9.  [Find the element that appears once and other elements appear 3 times](Data_Struct_Implementation/BitsManipulation/singleNumber.md)
-    10. [Signness Check for two integers](Data_Struct_Implementation/BitsManipulation/signessCheck.md)
-    11. [Turn off the rightmost set bit](Data_Struct_Implementation/BitsManipulation/turnoffRightmostBit.md)
-    12. [Rotate bits to left/rigtht](Data_Struct_Implementation/BitsManipulation/rotateLeftRight.md)
-    13. [Swap bits in a given number](Data_Struct_Implementation/BitsManipulation/SwapBitsInNumber.md)
+    3.  [Count bits with lookup table](Data_Struct_Implementation\BitsManipulation\countBitsLookUpTable.md)
+    4.  [Length of the Longest Consecutive 1s in Binary Representation](https://www.geeksforgeeks.org/length-longest-consecutive-1s-binary-representation/)
+    5.  [Find most significant set bit of a number](https://www.geeksforgeeks.org/find-significant-set-bit-number/)
+    6.  [Swap two number without temporary varaible](https://www.geeksforgeeks.org/swap-two-numbers-without-using-temporary-variable/)
+    7.  [Number is a power of 2](https://www.geeksforgeeks.org/bits-manipulation-important-tactics/)
+    8.  [Swap all odd and even bits](Data_Struct_Implementation/BitsManipulation/swapOddEvenBIts.md)
+    9.  [Find position of the only set bit](Data_Struct_Implementation/BitsManipulation/positionOfSetBit.md)
+    10. [Find the element that appears once and other elements appear 3 times](Data_Struct_Implementation/BitsManipulation/singleNumber.md)
+    11. [Signness Check for two integers](Data_Struct_Implementation/BitsManipulation/signessCheck.md)
+    12. [Turn off the rightmost set bit](Data_Struct_Implementation/BitsManipulation/turnoffRightmostBit.md)
+    13. [Rotate bits to left/rigtht](Data_Struct_Implementation/BitsManipulation/rotateLeftRight.md)
+    14. [Swap bits in a given number](Data_Struct_Implementation/BitsManipulation/SwapBitsInNumber.md)
 14. Concurrency 
     1.  Implement a Spinlock/Mutex/Semaphone
         1. [Test-and-set](https://en.wikipedia.org/wiki/Test-and-set)