Merge pull request Pradeepsingh61#586 from DeveloperViraj/docs/update-readme-schedule

feat(revision): add Day 01 - Two Pointers / Hashing + README plan update

Author: Karanjot786

CPP/revision/25-revision-questions/README.md

@@ -0,0 +1,53 @@
+# 25 Revision Questions — C++ (DSA patterns)
+
+Curated 25-day DSA revision set in C++ by `DeveloperViraj` (single-author).  
+Each folder contains short explanation + a runnable `.cpp` solution.
+
+**Structure**
+- `day-xx-.../` — three problems per day (problem.md + solution `.cpp`).
+- `Makefile` — quick compile helper.
+- `.github/workflows/ci-cpp.yml` — CI that compiles every `.cpp`.
+
+**Guidelines**
+- Maintainer: `DeveloperViraj`. This is a curated, single-author set.
+- Please **do not** modify existing day folders. To contribute, add your own revision folder (see below).
+- Use `g++ -std=c++17` to compile.
+
+**Goal**
+- One day = one pattern (3 problems). Short explanations + complexity notes.
+
+**Planned completion**
+- Target: finish Day 1 → Day 25 by **October 25, 2025** (one day per sheet).
+
+**Daily pattern plan (surface-level)**
+
+- Day 01 — Arrays / Two Pointers / Hashing  
+- Day 02 — Strings (sliding window, parsing)  
+- Day 03 — Dynamic Programming I (basic DP)  
+- Day 04 — Dynamic Programming II (advanced DP)  
+- Day 05 — Trees (binary tree basics)  
+- Day 06 — Binary Search Trees (BST operations)  
+- Day 07 — Backtracking (combinatorics)  
+- Day 08 — Linked Lists (singly/doubly)  
+- Day 09 — Stacks & Queues (monotonic stacks)  
+- Day 10 — Graphs I (BFS / DFS)  
+- Day 11 — Heaps / Priority Queues  
+- Day 12 — Greedy Algorithms  
+- Day 13 — Sliding Window & Two Pointers (advanced)  
+- Day 14 — Bit Manipulation  
+- Day 15 — Math & Number Theory  
+- Day 16 — Sorting & Binary Search patterns  
+- Day 17 — Two Heaps / Running Median  
+- Day 18 — Union-Find (Disjoint Set)  
+- Day 19 — Segment Tree / Fenwick Tree (range queries)  
+- Day 20 — Computational Geometry basics  
+- Day 21 — Tries / Prefix Trees  
+- Day 22 — Randomized Algorithms / Reservoir Sampling  
+- Day 23 — Advanced DP patterns (DP on trees, bitmask DP)  
+- Day 24 — Recursion & Divide and Conquer patterns  
+- Day 25 — Review day + mixed mock interview problems
+
+**Contributing (how-to)**
+- To contribute, create your own revision folder under the repo root (e.g. `yourname-revision-set/`) and submit a PR. Do not edit the main curated sheets directly; open an issue to propose changes.
+
+Enjoy — practice, learn, repeat.

CPP/revision/25-revision-questions/day-01-two-pointers-hashing/01_3sum.cpp

@@ -0,0 +1,119 @@
+// 01_3sum.cpp
+// Problem: 3Sum (Arrays / Two Pointers + Sorting)
+// LeetCode: https://leetcode.com/problems/3sum/
+// Author: DeveloperViraj (curated DSA set for Hacktoberfest 2025)
+// Compile: g++ -std=c++17 01_3sum.cpp -o 01_3sum
+// Run: ./01_3sum
+//
+// 🧩 Summary:
+// Given an integer array 'numbers', return all unique triplets (a, b, c)
+// such that a + b + c == 0. Each triplet should be printed one per line.
+//
+// 🧠 Approach (Two Pointers + Sorting):
+// 1. Sort the array.
+// 2. For each index i (value a), use two pointers (left, right) to find
+//    pairs (b, c) such that b + c == -a.
+// 3. Skip duplicate values for i, left, and right to ensure uniqueness.
+//
+// ✅ Correctness:
+// Sorting enables ordered traversal and duplicate skipping.
+// Two pointers ensure linear-time scanning per fixed element.
+//
+// ⏱️ Complexity:
+// Time:  O(n²)
+// Space: O(1) (ignoring output storage)
+//
+// 📘 LeetCode Link: https://leetcode.com/problems/3sum/
+// Try it yourself on LeetCode with various input cases.
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+vector<vector<int>> findThreeSumTriplets(vector<int> numbers) {
+    vector<vector<int>> result;
+    int n = numbers.size();
+    if (n < 3) return result;
+
+    sort(numbers.begin(), numbers.end());
+
+    for (int i = 0; i < n; ++i) {
+        // Skip duplicate 'a' values
+        if (i > 0 && numbers[i] == numbers[i - 1]) continue;
+
+        // No need to continue if current number > 0 (as array is sorted)
+        if (numbers[i] > 0) break;
+
+        int firstNumber = numbers[i];
+        int target = -firstNumber;
+        int left = i + 1, right = n - 1;
+
+        while (left < right) {
+            int sum = numbers[left] + numbers[right];
+
+            if (sum == target) {
+                result.push_back({firstNumber, numbers[left], numbers[right]});
+
+                // Skip duplicates for left and right
+                int leftValue = numbers[left], rightValue = numbers[right];
+                while (left < right && numbers[left] == leftValue) ++left;
+                while (left < right && numbers[right] == rightValue) --right;
+            }
+            else if (sum < target) {
+                ++left;
+            } else {
+                --right;
+            }
+        }
+    }
+    return result;
+}
+
+int main() {
+    cout << "🔹 3Sum Problem — Arrays / Two Pointers\n";
+    cout << "Input format:\n";
+    cout << "n\n";
+    cout << "a0 a1 a2 ... a(n-1)\n\n";
+    cout << "Enter n and array elements:\n";
+
+    int n;
+    if (!(cin >> n) || n <= 0) {
+        cerr << "❌ Invalid input. Exiting.\n";
+        return 0;
+    }
+
+    vector<int> numbers(n);
+    for (int i = 0; i < n; ++i) cin >> numbers[i];
+
+    auto triplets = findThreeSumTriplets(numbers);
+
+    if (triplets.empty()) {
+        cout << "No triplets found.\n";
+    } else {
+        cout << "\n✅ Unique Triplets (a + b + c = 0):\n";
+        for (auto &t : triplets) {
+            cout << t[0] << " " << t[1] << " " << t[2] << "\n";
+        }
+    }
+
+    return 0;
+}
+
+/*
+🔍 Example Input:
+6
+-1 0 1 2 -1 -4
+
+🧾 Expected Output:
+-1 -1 2
+-1 0 1
+
+📊 Edge Cases:
+1️⃣ n < 3 → "No triplets found"
+2️⃣ [0,0,0,0] → one triplet "0 0 0"
+3️⃣ All positives → "No triplets found"
+4️⃣ Large input → Works efficiently for up to 10^4 elements
+
+🔗 LeetCode: https://leetcode.com/problems/3sum/
+*/

CPP/revision/25-revision-questions/day-01-two-pointers-hashing/02_container_with_most_water.cpp

@@ -0,0 +1,106 @@
+// 02_container_with_most_water.cpp
+// Problem: Container With Most Water (Two Pointers / Greedy)
+// LeetCode: https://leetcode.com/problems/container-with-most-water/
+// Author: DeveloperViraj (curated DSA set for Hacktoberfest 2025)
+// Compile: g++ -std=c++17 02_container_with_most_water.cpp -o 02_container_with_most_water
+// Run: ./02_container_with_most_water
+//
+// 🧩 Problem Summary:
+// You are given n non-negative integers `height[i]` where each represents a vertical line
+// drawn at position i. Two lines form a container with the x-axis that can hold water.
+// Find two lines that together can contain the **maximum area of water**.
+// The container cannot be tilted.
+//
+// Example:
+// heights = [1,8,6,2,5,4,8,3,7]
+// Maximum water area = 49 (between lines with heights 8 and 7)
+//
+// 🧠 Approach (Two Pointers):
+// 1️⃣ Start with two pointers — left at 0 and right at n-1.
+// 2️⃣ Compute the area = (right - left) * min(height[left], height[right]).
+// 3️⃣ Move the pointer pointing to the *smaller height* inward —
+//     because only that move can possibly increase the area.
+// 4️⃣ Continue until left >= right.
+//
+// ✅ Why it works:
+// The height of water is limited by the shorter of the two lines.
+// Moving the taller line inward won’t help — it only reduces width
+// without increasing the limiting height.
+//
+// ⏱️ Complexity:
+// Time: O(n)
+// Space: O(1)
+//
+// 📘 LeetCode Link:
+// https://leetcode.com/problems/container-with-most-water/
+// Try it out on LeetCode to test the same logic.
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+// 🔹 Function to calculate the maximum water area
+int maxWaterContainer(vector<int>& heights) {
+    int left = 0, right = heights.size() - 1;
+    int maxArea = 0;
+
+    while (left < right) {
+        int width = right - left;
+        int height = min(heights[left], heights[right]);
+        int area = width * height;
+        maxArea = max(maxArea, area);
+
+        // Move pointer of smaller height inward
+        if (heights[left] < heights[right])
+            ++left;
+        else
+            --right;
+    }
+
+    return maxArea;
+}
+
+int main() {
+    cout << "🔹 Problem: Container With Most Water\n";
+    cout << "Input format:\n";
+    cout << "n\nh0 h1 h2 ... h(n-1)\n\n";
+    cout << "Enter n and the heights:\n";
+
+    int n;
+    if (!(cin >> n) || n <= 1) {
+        cerr << "❌ Invalid input. Need at least 2 heights.\n";
+        return 0;
+    }
+
+    vector<int> heights(n);
+    for (int i = 0; i < n; ++i)
+        cin >> heights[i];
+
+    int maxArea = maxWaterContainer(heights);
+    cout << "\n✅ Maximum water that can be contained: " << maxArea << "\n";
+
+    return 0;
+}
+
+/*
+🔍 Example Input:
+9
+1 8 6 2 5 4 8 3 7
+
+🧾 Expected Output:
+✅ Maximum water that can be contained: 49
+
+📊 Explanation:
+Pair chosen: heights[1] = 8, heights[8] = 7
+Width = 8 - 1 = 7
+Height = min(8, 7) = 7
+Area = 7 × 7 = 49
+
+📘 LeetCode Link:
+https://leetcode.com/problems/container-with-most-water/
+
+🧠 Key Insight:
+- The shorter height limits the water area.
+- Always move the smaller height inward to explore potential larger areas.
+*/

CPP/revision/25-revision-questions/day-01-two-pointers-hashing/03_longest_consecutive_sequence.cpp

@@ -0,0 +1,111 @@
+// 03_longest_consecutive_sequence.cpp
+// Problem: Longest Consecutive Sequence (Hashing / unordered_set)
+// LeetCode: https://leetcode.com/problems/longest-consecutive-sequence/
+// Author: DeveloperViraj (curated DSA set for Hacktoberfest 2025)
+// Compile: g++ -std=c++17 03_longest_consecutive_sequence.cpp -o 03_longest_consecutive_sequence
+// Run: ./03_longest_consecutive_sequence
+//
+// 🧩 Problem Summary:
+// Given an unsorted array of integers, return the length of the longest
+// consecutive elements sequence. The sequence elements can appear in any order.
+//
+// Example:
+// Input: [100, 4, 200, 1, 3, 2]
+// Output: 4  (sequence: 1, 2, 3, 4)
+//
+// 🧠 Approach (Hashing):
+// 1️⃣ Insert all numbers into an unordered_set for O(1) lookups.
+// 2️⃣ Iterate through each number. If (number - 1) doesn’t exist in the set,
+//     treat this number as the start of a new sequence.
+// 3️⃣ Count consecutive numbers (number + 1, number + 2, …) until the sequence breaks.
+// 4️⃣ Track the maximum sequence length found.
+//
+// ✅ Why it works:
+// - Each number is checked at most twice: once for start check, once while counting.
+// - By starting only at sequence beginnings, we avoid redundant checks.
+//
+// ⏱️ Complexity:
+// Time:  O(n) on average (unordered_set gives O(1) lookups)
+// Space: O(n) for storing elements in the set
+//
+// 📘 LeetCode Link:
+// https://leetcode.com/problems/longest-consecutive-sequence/
+// Try it yourself to test your implementation.
+
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+using namespace std;
+
+// 🔹 Function to find longest consecutive sequence length
+int longestConsecutiveSequence(const vector<int>& numbers) {
+    if (numbers.empty()) return 0;
+
+    unordered_set<int> values(numbers.begin(), numbers.end());
+    int bestLength = 0;
+
+    for (int num : numbers) {
+        // Only start if current number is the first in sequence
+        if (values.find(num - 1) == values.end()) {
+            int current = num;
+            int currentLength = 1;
+
+            // Walk forward for consecutive numbers
+            while (values.find(current + 1) != values.end()) {
+                ++current;
+                ++currentLength;
+            }
+
+            bestLength = max(bestLength, currentLength);
+        }
+    }
+
+    return bestLength;
+}
+
+int main() {
+    cout << "🔹 Problem: Longest Consecutive Sequence\n";
+    cout << "Input format:\n";
+    cout << "n\n";
+    cout << "a0 a1 a2 ... a(n-1)\n\n";
+    cout << "Enter n and the numbers:\n";
+
+    int n;
+    if (!(cin >> n) || n < 0) {
+        cerr << "❌ Invalid input. Exiting.\n";
+        return 0;
+    }
+
+    vector<int> numbers(n);
+    for (int i = 0; i < n; ++i) cin >> numbers[i];
+
+    int answer = longestConsecutiveSequence(numbers);
+    cout << "\n✅ Longest consecutive sequence length: " << answer << "\n";
+
+    return 0;
+}
+
+/*
+🔍 Example Input:
+6
+100 4 200 1 3 2
+
+🧾 Expected Output:
+✅ Longest consecutive sequence length: 4
+
+📊 Explanation:
+Consecutive numbers: 1, 2, 3, 4 (length = 4)
+
+📘 LeetCode:
+https://leetcode.com/problems/longest-consecutive-sequence/
+
+📌 Edge Cases:
+- Empty array → 0
+- All unique non-consecutive → 1
+- Handles negatives too (e.g., -2, -1, 0 → 3)
+- Duplicates are ignored automatically via unordered_set
+
+🧠 Key Insight:
+This avoids sorting (O(n log n)) and achieves O(n) average time
+by leveraging hash-based lookups to expand sequences efficiently.
+*/