Merge branch 'ByteByteGoHq:main' into main

Author: marttp

Contribute.md renamed to CONTRIBUTING.md

@@ -2,21 +2,21 @@
 
 We’re excited to have you contribute to this repository, and your efforts will be fully credited! Whether you want to add solutions in a new programming language or improve existing ones, here’s how you can get started:
 
-1. Let me know what you plan to contribute! The best way to do this is by joining our discord server (see page 2 of the book). Communication is important to prevent you labouring on a set of quesitons that someone's already working on.
+1. Let me know what you plan to contribute! The best way to do this is by joining our Discord server (see page 2 of the book). Communication is important to prevent you labouring on a set of quesitons that someone's already working on.
 
 2. Once you've been approved, **fork the repository** to start working on your own solutions locally.
 
 3. Take a close look at how the Python solutions are organized. Your contributions should align with this structure (e.g., folder organization, file naming). 
 
 4. Always **create a new branch** for your additions or changes. We recommend creating separate branches for each chapter you’re contributing. Example: `git checkout -b java-solutions-linked-lists`.
 
-5. Stay true to existing code comments and structure. Feel free to add additional comments for clarity, especially if any language-specific nuances are included.
+5. Stay true to existing variable/function naming, code comments and algorithm structure. Feel free to add additional comments for clarity, especially if any language-specific nuances are included.
 
 6. **Test your code**. Be sure your code runs. We're currently working on making all test cases public. In the mean time, please use your own set of diverse test cases.
 
 7. **Open a pull request** (PR) and clearly describe your work in the PR. Respond to comments and make necessary adjustments when requested. Once approved, your PR will be merged!
 
 ## Questions or Issues?
-If you encounter any issues or have questions about contributing, feel free to reach out via the discord, or email us at [email protected].
+If you encounter any issues or have questions about contributing, feel free to reach out via the Discord, or email us at [email protected].
 
 We greatly appreciate you helping us build this repository and making it accessible to more people. Thank you for contributing!

LICENSE.md

@@ -0,0 +1 @@
+This work is licensed under [CC BY-NC-ND 4.0](https://creativecommons.org/licenses/by-nc-nd/4.0/?ref=chooser-v1)

README.md

@@ -12,7 +12,7 @@ going to reinforce your learning, and better prepare you for high‐stakes codin
 https://bit.ly/run-code
 
 ## Contributing to the Repo
-We welcome contributions to the repository! Of course, your contributions will be credited. If you’d like to add solutions in a language of your choice, or amend an existing solution in any language, please read the instructions provided in [Contribute.md](Contribute.md).
+We welcome contributions to the repository! Of course, your contributions will be credited. If you’d like to add solutions in a language of your choice, or amend an existing solution in any language, please read the instructions provided in [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## 📙 About the Book
 

cpp/Hash Maps and Sets/geometric_sequence_triplets.cpp

@@ -0,0 +1,27 @@
+#include <vector>                  
+#include <unordered_map>           
+
+int geometricSequenceTriplets(std::vector<int>& nums, int r) {
+    // Use 'unordered_map' which initializes non-existent keys to 0
+    // for frequency counting. 
+    std::unordered_map<int, int> leftMap;   
+    std::unordered_map<int, int> rightMap;  
+    int count = 0;  
+    // Populate 'right_map' with the frequency of each element in the array.
+    for (const auto& x : nums) {
+        rightMap[x]++;
+    }
+    // Search for geometric triplets that have x as the center.
+    for (const auto& x : nums) {
+        // Decrement the frequency of x in 'right_map' since x is now being
+        // processed and is no longer to the right.
+        rightMap[x]--;
+        if (r != 0 && x % r == 0) {
+            count += leftMap[x / r] * rightMap[x * r];
+        }
+        // Increment the frequency of x in 'left_map' since it'll be a part of the
+        // left side of the array once we iterate to the next value of x.
+        leftMap[x]++;
+    }
+    return count;
+}

cpp/Hash Maps and Sets/longest_chain_of_consecutive_numbers.cpp

@@ -0,0 +1,26 @@
+#include <vector>        
+#include <unordered_set> 
+#include <algorithm>    
+
+int longestChainOfConsecutiveNumbers(std::vector<int>& nums) {
+    if (nums.empty()) {
+        return 0;
+    }
+    std::unordered_set<int> numSet(nums.begin(), nums.end());
+    int longestChain = 0;
+    for (int num : numSet) {
+        // If the current number is the smallest number in its chain, search for
+        // the length of its chain.
+        if (numSet.find(num - 1) == numSet.end()) {
+            int currentNum = num;    
+            int currentChain = 1;    
+            // Continue to find the next consecutive numbers in the chain.
+            while (numSet.find(currentNum + 1) != numSet.end()) {
+                currentNum += 1;    
+                currentChain += 1;   
+            }
+            longestChain = std::max(longestChain, currentChain);
+        }
+    }
+    return longestChain;
+}

cpp/Hash Maps and Sets/longest_chain_of_consecutive_numbers_brute_force.cpp

@@ -0,0 +1,21 @@
+#include <vector>        
+#include <algorithm>    
+
+int longestChainOfConsecutiveNumbersBruteForce(std::vector<int>& nums) {
+    if (nums.empty()) {
+        return 0;
+    }
+    int longestChain = 0;  
+    // Look for chains of consecutive numbers that start from each number.
+    for (int num : nums) {
+        int currentNum = num;         
+        int currentChain = 1;         
+        // Continue to find the next consecutive numbers in the chain.
+        while (std::find(nums.begin(), nums.end(), currentNum + 1) != nums.end()) {
+            currentNum += 1;
+            currentChain += 1;
+        }
+        longestChain = std::max(longestChain, currentChain);
+    }
+    return longestChain;
+}

cpp/Hash Maps and Sets/pair_sum_unsorted.cpp

@@ -0,0 +1,14 @@
+#include <vector>          
+#include <unordered_map>  
+
+std::vector<int> pairSumUnsorted(std::vector<int>& nums, int target) {
+    std::unordered_map<int, int> hashMap;
+    for (int i = 0; i < nums.size(); ++i) {
+        int complement = target - nums[i]; 
+        if (hashMap.find(complement) != hashMap.end()) {
+            return {hashMap[complement], i};
+        }
+        hashMap[nums[i]] = i;
+    }
+    return {};
+}

cpp/Hash Maps and Sets/pair_sum_unsorted_two_pass.cpp

@@ -0,0 +1,18 @@
+#include <vector>          
+#include <unordered_map>   
+
+std::vector<int> pairSumUnsortedTwoPass(std::vector<int>& nums, int target) {
+    std::unordered_map<int, int> numMap;
+    // First pass: Populate the hash map with each number and its index.
+    for (int i = 0; i < nums.size(); i++) {
+        numMap[nums[i]] = i; 
+    }
+    // Second pass: Check for each number's complement in the hash map. 
+    for (int i = 0; i < nums.size(); i++) {
+        int complement = target - nums[i]; 
+        if (numMap.find(complement) != numMap.end() && numMap[complement] != i) {
+            return {i, numMap[complement]};
+        }
+    }
+    return {};
+}

cpp/Hash Maps and Sets/verify_sudoku_board.cpp

@@ -0,0 +1,36 @@
+#include <vector>        
+#include <set>
+
+bool verifySudokuBoard(std::vector<std::vector<int>>& board) {
+    // Create hash sets for each row, column, and subgrid to keep 
+    // track of numbers previously seen on any given row, column, or
+    // subgrid.
+    std::vector<std::set<int>> rowSets(9);
+    std::vector<std::set<int>> columnSets(9);
+    std::vector<std::vector<std::set<int>>> subgridSets(3, std::vector<std::set<int>>(3));    
+    for (int r = 0; r < 9; r++) {          
+        for (int c = 0; c < 9; c++) {     
+            int num = board[r][c];        
+            if (num == 0) {
+                continue;
+            }
+            // Check if 'num' has been seen in the current row, 
+            // column, or subgrid.
+            if (rowSets[r].find(num) != rowSets[r].end()) {
+                return false;
+            }
+            if (columnSets[c].find(num) != columnSets[c].end()) {
+                return false;
+            }
+            if (subgridSets[r / 3][c / 3].find(num) != subgridSets[r / 3][c / 3].end()) {
+                return false;
+            }
+            // If we passed the above checks, mark this value as seen 
+            // by adding it to its corresponding hash sets.            
+            rowSets[r].insert(num);
+            columnSets[c].insert(num);
+            subgridSets[r / 3][c / 3].insert(num);
+        }
+    }
+    return true;
+}

cpp/Hash Maps and Sets/zero_striping.cpp

@@ -0,0 +1,60 @@
+#include <iostream>      
+#include <vector>       
+
+void zeroStriping(std::vector<std::vector<int>>& matrix) {
+    if (matrix.empty() || matrix[0].empty()) {
+        return;
+    }
+    int m = matrix.size();        
+    int n = matrix[0].size();
+    // Check if the first row initially contains a zero.
+    bool firstRowHasZero = false;
+    for (int c = 0; c < n; c++) {   
+        if (matrix[0][c] == 0) {
+            firstRowHasZero = true;
+            break;
+        }
+    }
+    // Check if the first column initially contains a zero.
+    bool firstColHasZero = false;
+    for (int r = 0; r < m; r++) {  
+        if (matrix[r][0] == 0) {
+            firstColHasZero = true;
+            break;
+        }
+    }
+    // Use the first row and column as markers. If an element in the 
+    // submatrix is zero, mark its corresponding row and column in the 
+    // first row and column as 0.
+    for (int r = 1; r < m; r++) {                
+        for (int c = 1; c < n; c++) {            
+            if (matrix[r][c] == 0) {
+                matrix[0][c] = 0;  
+                matrix[r][0] = 0;   
+            }
+        }
+    }
+    // Update the submatrix using the markers in the first row and 
+    // column.
+    for (int r = 1; r < m; r++) {
+        for (int c = 1; c < n; c++) {
+            if (matrix[0][c] == 0 || matrix[r][0] == 0) {
+                matrix[r][c] = 0;
+            }
+        }
+    }
+    // If the first row had a zero initially, set all elements in the 
+    // first row to zero.
+    if (firstRowHasZero) {
+        for (int c = 0; c < n; c++) {  
+            matrix[0][c] = 0;
+        }
+    }
+    // If the first column had a zero initially, set all elements in 
+    // the first column to zero.
+    if (firstColHasZero) {
+        for (int r = 0; r < m; r++) {  
+            matrix[r][0] = 0;
+        }
+    }
+}

cpp/Hash Maps and Sets/zero_striping_hash_sets.cpp

@@ -0,0 +1,32 @@
+#include <vector>        
+#include <unordered_set> 
+
+void zeroStripingHashSets(std::vector<std::vector<int>>& matrix) {
+    if (matrix.empty() || matrix[0].empty()) {
+        return;
+    }
+    int m = matrix.size();        
+    int n = matrix[0].size();     
+    std::unordered_set<int> zeroRows; 
+    std::unordered_set<int> zeroCols;
+    // # Pass 1: Traverse through the matrix to identify the rows and
+    // columns containing zeros and store their indexes in the 
+    // appropriate hash sets.
+    for (int r = 0; r < m; r++) {       
+        for (int c = 0; c < n; c++) {    
+            if (matrix[r][c] == 0) {
+                zeroRows.insert(r);     
+                zeroCols.insert(c);     
+            }
+        }
+    }
+    // Pass 2: Set any cell in the matrix to zero if its row index is 
+    // in 'zero_rows' or its column index is in 'zero_cols'.
+    for (int r = 0; r < m; r++) {        
+        for (int c = 0; c < n; c++) {    
+            if (zeroRows.find(r) != zeroRows.end() || zeroCols.find(c) != zeroCols.end()) {
+                matrix[r][c] = 0;
+            }
+        }
+    }
+}

cpp/Linked Lists/flatten_multi_level_list.cpp

@@ -0,0 +1,38 @@
+/**
+ * Definition of MultiLevelListNode:
+ * class MultiLevelListNode {
+ * public:
+ *     int val;
+ *     MultiLevelListNode* next;
+ *     MultiLevelListNode* child;
+ *     MultiLevelListNode(int val = 0, MultiLevelListNode* next = nullptr, MultiLevelListNode* child = nullptr)
+ *         : val(val), next(next), child(child) {}
+ * };
+ */
+
+MultiLevelListNode* flattenMultiLevelList(MultiLevelListNode* head) {
+    if (!head) {
+        return nullptr;
+    }
+    MultiLevelListNode* tail = head;
+    // Find the tail of the linked list at the first level.
+    while (tail->next) {
+        tail = tail->next;
+    }
+    MultiLevelListNode* curr = head;
+    // Process each node at the current level. If a node has a child linked list,
+    // append it to the tail and then update the tail to the end of the extended 
+    // linked list. Continue until all nodes at the current level are processed.
+    while (curr) {
+        if (curr->child) {
+            tail->next = curr->child;
+            // Disconnect the child linked list from the current node.
+            curr->child = nullptr;
+            while (tail->next) {
+                tail = tail->next;
+            }
+        }
+        curr = curr->next;
+    }
+    return head;
+}

cpp/Linked Lists/linked_list_intersection.cpp

@@ -0,0 +1,35 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListIntersection(ListNode* head_A, ListNode* head_B) {
+    ListNode* ptr_A = head_A;
+    ListNode* ptr_B = head_B;
+    // Traverse through list A with 'ptr_A' and list B with 'ptr_B' 
+    // until they meet.
+    while (ptr_A != ptr_B) {
+        // Traverse list A -> list B by first traversing 'ptr_A' and 
+        // then, upon reaching the end of list A, continue the 
+        // traversal from the head of list B.
+        if (ptr_A != nullptr) {
+            ptr_A = ptr_A->next;
+        } else {
+            ptr_A = head_B;
+        }
+        // Simultaneously, traverse list B -> list A.
+        if (ptr_B != nullptr) {
+            ptr_B = ptr_B->next;
+        } else {
+            ptr_B = head_A;
+        }
+    }
+    // At this point, 'ptr_A' and 'ptr_B' either point to the 
+    // intersection node or both are null if the lists do not 
+    // intersect. Return either pointer.
+    return ptr_A;  
+}

cpp/Linked Lists/linked_list_reversal.cpp

@@ -0,0 +1,24 @@
+/**
+ * Definition of ListNode:
+ * struct ListNode {
+ *     int val;
+ *     ListNode* next;
+ *     ListNode(int val = 0, ListNode* next = nullptr) : val(val), next(next) {}
+ * };
+ */
+
+ListNode* linkedListReversal(ListNode* head) {
+    ListNode* currNode = head;      
+    ListNode* prevNode = nullptr;   
+    // Reverse the direction of each node's pointer until 'currNode' 
+    // is null.
+    while (currNode != nullptr) {
+        ListNode* nextNode = currNode->next;  
+        currNode->next = prevNode;            
+        prevNode = currNode;                 
+        currNode = nextNode;                  
+    }
+    // 'prevNode' will be pointing at the head of the reversed linked 
+    // list.
+    return prevNode;
+}