Merge pull request #596 from DeveloperViraj/feat/day-02-strings

feat(revision): add Day 02 - Strings (Longest Substring, Minimum Window)

Author: Pradeepsingh61

…revision/25-revision-questions/README.md …revision/25-revision-questions/README.mdCPP/revision/25-revision-questions/README.md renamed to CPP/algorithms/revision/25-revision-questions/README.md CPP/revision/25-revision-questions/README.md renamed to CPP/algorithms/revision/25-revision-questions/README.md

@@ -0,0 +1,60 @@
+// 01_longest_substring_without_repeating_characters.cpp
+//
+// 🔍 Algorithm: Longest Substring Without Repeating Characters
+// Description:
+//   Finds the length of the longest substring in a given string 
+//   that contains no repeating characters.
+//   Uses the Sliding Window technique with a hash map to track 
+//   character indices and adjust window boundaries efficiently.
+//
+// Use Case:
+//   Commonly used to analyze substring patterns or find unique 
+//   character sequences in data streams.
+//
+// Time Complexity: O(n) — each character visited once.
+// Space Complexity: O(1) — constant size (at most 256 chars).
+//
+// LeetCode: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+#include <iostream>
+#include <string>
+#include <unordered_map>
+using namespace std;
+
+int lengthOfLongestUniqueSubstring(const string &s) {
+    unordered_map<char,int> lastSeen;
+    int maxLength = 0;
+    int windowStart = 0;
+
+    for (int windowEnd = 0; windowEnd < (int)s.size(); ++windowEnd) {
+        char currentChar = s[windowEnd];
+        if (lastSeen.find(currentChar) != lastSeen.end()) {
+            // If this character appeared inside current window, move start
+            if (lastSeen[currentChar] >= windowStart) {
+                windowStart = lastSeen[currentChar] + 1;
+            }
+        }
+        lastSeen[currentChar] = windowEnd;
+        int windowLength = windowEnd - windowStart + 1;
+        if (windowLength > maxLength) maxLength = windowLength;
+    }
+    return maxLength;
+}
+
+int main() {
+    cout << "Longest Substring Without Repeating Characters\n";
+    cout << "Enter a single-line string and press Enter:\n";
+    string input;
+    if (!getline(cin, input)) return 0;
+
+    int result = lengthOfLongestUniqueSubstring(input);
+    cout << "Length: " << result << "\n";
+    return 0;
+}
+
+/*
+Example:
+Input:
+abcabcbb
+Output:
+Length: 3  (substring "abc")
+*/

…/day-01-two-pointers-hashing/01_3sum.cpp …/day-01-two-pointers-hashing/01_3sum.cppCPP/revision/25-revision-questions/day-01-two-pointers-hashing/01_3sum.cpp renamed to CPP/algorithms/revision/25-revision-questions/day-01-two-pointers-hashing/01_3sum.cpp CPP/revision/25-revision-questions/day-01-two-pointers-hashing/01_3sum.cpp renamed to CPP/algorithms/revision/25-revision-questions/day-01-two-pointers-hashing/01_3sum.cpp

@@ -0,0 +1,93 @@
+// 02_minimum_window_substring.cpp
+//
+// 🔍 Algorithm: Minimum Window Substring
+// Description:
+//   Finds the smallest substring in `source` that contains all 
+//   characters of `target` (including duplicates).
+//   Uses a Sliding Window approach combined with frequency maps 
+//   to expand and contract the window optimally.
+//
+// Use Case:
+//   Useful in text search problems, DNA sequence matching, 
+//   or when finding minimal segments containing specific data.
+//
+// Time Complexity: O(|S| + |T|)
+// Space Complexity: O(|T|)
+//
+// LeetCode: https://leetcode.com/problems/minimum-window-substring/
+
+
+#include <iostream>
+#include <string>
+#include <unordered_map>
+#include <climits>
+using namespace std;
+
+string minWindow(const string &source, const string &target) {
+    if (target.empty() || source.empty() || source.size() < target.size()) return "";
+
+    unordered_map<char,int> need;
+    for (char c : target) need[c]++;
+
+    int required = need.size();       // distinct characters needed
+    int formed = 0;                   // how many distinct characters currently satisfy required count
+    unordered_map<char,int> windowCounts;
+
+    int left = 0, right = 0;
+    int bestLeft = 0;
+    int bestLen = INT_MAX;
+
+    while (right < (int)source.size()) {
+        char c = source[right];
+        windowCounts[c]++;
+
+        // If current char count matches the required count, we've satisfied one distinct char
+        if (need.count(c) && windowCounts[c] == need[c]) {
+            formed++;
+        }
+
+        // When all required chars are satisfied, try to shrink from the left
+        while (left <= right && formed == required) {
+            if (right - left + 1 < bestLen) {
+                bestLen = right - left + 1;
+                bestLeft = left;
+            }
+
+            char leftChar = source[left];
+            windowCounts[leftChar]--;
+            if (need.count(leftChar) && windowCounts[leftChar] < need[leftChar]) {
+                formed--;
+            }
+            left++;
+        }
+
+        right++;
+    }
+
+    if (bestLen == INT_MAX) return "";
+    return source.substr(bestLeft, bestLen);
+}
+
+int main() {
+    cout << "Minimum Window Substring\n";
+    cout << "Input format (two lines):\nS\nT\n\nEnter S (source string) and T (target string) each on a new line:\n";
+
+    string S, T;
+    if (!getline(cin, S)) return 0;
+    if (!getline(cin, T)) return 0;
+
+    string answer = minWindow(S, T);
+    if (answer.empty()) {
+        cout << "No valid window found\n";
+    } else {
+        cout << "Minimum window: " << answer << "\n";
+    }
+    return 0;
+}
+
+/*
+Example:
+S = "ADOBECODEBANC"
+T = "ABC"
+Output: "BANC"
+*/