Longest Substring Without Repeating Characters LeetCode Solution

🚀 50 Important Coding Questions – Question 36/50 🔹 Next Greater Element I | LeetCode A classic Monotonic Stack problem used frequently in coding interviews. 📌 Problem Statement You are given two arrays nums1 and nums2. For each element in nums1, find the next greater element in nums2. The next greater element of x is the first element to the right of x in nums2 that is greater than x. If it does not exist → return -1. Example: Input nums1 = [4,1,2] nums2 = [1,3,4,2] Output [-1,3,-1] 💡 Approach We use a Monotonic Decreasing Stack. Steps: 1️⃣ Traverse nums2 from right to left 2️⃣ Remove all elements from stack ≤ current element 3️⃣ The stack top becomes the next greater element 4️⃣ Store results in a map/array 5️⃣ Finally answer queries for nums1 This avoids checking every element repeatedly. ⏱ Time Complexity: O(n + m) 📦 Space Complexity: O(n) 📌 LeetCode Result: ✔ Accepted ⚡ Runtime: 0 ms 🧠 Concepts Strengthened ✔ Monotonic Stack ✔ Stack-based optimization ✔ Array traversal techniques ✔ Precomputation for faster queries 📍 Question 36 of 50 in my “50 Important Coding Questions” series. Every problem solved improves algorithmic thinking step by step 💯 👉 Question 37 coming next! #DSA #LeetCode #Stack #MonotonicStack #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

🚀 50 Important Coding Questions – Question 27/50 🔹 Sort List | LeetCode (Medium) A very important Linked List problem that teaches sorting using Merge Sort 📚 📌 Problem Statement Given the head of a linked list, sort it in ascending order. 💡 Optimal Approach – Merge Sort on Linked List Why Merge Sort? Because Linked Lists don’t support random access like arrays. 👉 Steps 1️⃣ Find middle of list using slow & fast pointers 2️⃣ Split list into two halves 3️⃣ Recursively sort both halves 4️⃣ Merge sorted lists 🧠 Why this problem is important? ✔ Teaches Merge Sort logic ✔ Important interview question ✔ Helps in advanced Linked List problems ✔ Improves recursion understanding ⏱ Time Complexity: O(n log n) 📦 Space Complexity: O(log n) (recursion stack) 👉 My approach used array conversion + sorting, but Merge Sort is the optimal in interviews. 📌 LeetCode Result: ✔ Accepted ⚡ Efficient solution 🔔 This is Question 27 of my “50 Important Coding Questions” series. Linked List concepts getting stronger 💪 👉 Question 28 coming soon… #DSA #LeetCode #LinkedList #MergeSort #CodingInterview #CPlusPlus #ProblemSolving #50ImportantQuestions

🚀 Day 526 of #750DaysOfCode 🚀 Today I solved LeetCode 3129 – Find All Possible Stable Binary Arrays I. 🔹 Problem Summary We are given three integers: zero, one, and limit. We need to count the number of binary arrays that: • Contain exactly zero number of 0s • Contain exactly one number of 1s • Do not allow more than limit consecutive identical elements In other words, every subarray longer than limit must contain both 0 and 1, preventing long runs of the same digit. 🔹 Approach I solved this using Dynamic Programming. Idea: Track how many zeros and ones are used. Maintain the last placed digit (0 or 1). Ensure the count of consecutive digits never exceeds the limit. Use DP states to count valid configurations and apply modulo (10^9 + 7) for large results. 🔹 Key Concepts Practiced Dynamic Programming State transitions Handling constraints with limit on consecutive elements Modular arithmetic 💡 Problems like this strengthen DP intuition and constraint handling, which are very common in coding interviews. Consistency continues… 🔥 #leetcode #dsa #dynamicprogramming #codingchallenge #softwareengineering #programming #developers #learninginpublic #techjourney #750daysofcode

🚀 **268 / 268 Test Cases Passed — But the Real Win Was Understanding the Pattern** Today I solved **Minimum Window Substring** on LeetCode using the **Sliding Window technique**. ✅ 268/268 test cases passed ⚡ Runtime: 9 ms 💾 Memory: 11.52 MB But the most important thing I learned wasn’t just the solution. It was the **pattern behind the problem.** Many coding interview questions that look completely different actually rely on the **same underlying idea** — the **Sliding Window pattern**. Problems like: • Longest Substring Without Repeating Characters • Minimum Window Substring • Find All Anagrams in a String • Maximum Sum Subarray All follow the same strategy: 👉 **Expand the window** to include new elements 👉 **Track frequency / conditions** 👉 **Shrink the window** when constraints break Once you recognize this pattern, problems that initially look **O(n²)** often become **O(n)** solutions. That realization completely changed how I approach **DSA problems and coding interviews**. So I decided to write a **detailed guide explaining Sliding Window from scratch**, including: ✔ The intuition behind the technique ✔ Fixed vs Variable window patterns ✔ The universal sliding window template ✔ Common interview questions ✔ How to master it step-by-step If you’re preparing for **coding interviews or practicing LeetCode**, mastering this technique alone can help you solve **dozens of problems more efficiently.** 📖 I explained everything here: 👉 https://lnkd.in/gigV7Fg3 Would love to know: **What was the first problem that made Sliding Window “click” for you?** #LeetCode #DSA #Algorithms #CodingInterview #Programming #SoftwareEngineering #ProblemSolving #LearningInPublic

🚀 50 Important Coding Questions – Question 42/50 🔹 Sliding Window Maximum | LeetCode A classic Sliding Window + Monotonic Deque problem widely asked in coding interviews. 📌 Problem Statement Given an array nums and a window size k, return the maximum element in every sliding window of size k. Example: Input nums = [1,3,-1,-3,5,3,6,7] k = 3 Output [3,3,5,5,6,7] Explanation: Each window of size 3 produces the maximum value: [1 3 -1] -> 3 [3 -1 -3] -> 3 [-1 -3 5] -> 5 [-3 5 3] -> 5 [5 3 6] -> 6 [3 6 7] -> 7 💡 Approach We use a Monotonic Deque (Double Ended Queue). Key idea: 1️⃣ Maintain indices in deque 2️⃣ Remove elements from back if they are smaller than current element 3️⃣ Remove elements from front if they are outside the window 4️⃣ The front of deque always holds the maximum element index This keeps the deque sorted in decreasing order. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(k) 📌 LeetCode Result ✔ Accepted ⚡ Efficient O(n) solution 🧠 Concepts Strengthened ✔ Sliding Window Technique ✔ Monotonic Deque ✔ Queue optimization ✔ Efficient window-based computation 📍 Question 42 of 50 in my “50 Important Coding Questions” series. Just 8 problems left to finish the challenge 💯 👉 Question 43 coming next! #DSA #LeetCode #SlidingWindow #Deque #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

🚀 50 Important Coding Questions – Question 21/50 🔹 Reverse Linked List | LeetCode (Easy) A core Linked List problem that every coding interview candidate must master 👇 📌 Problem Statement Given the head of a singly linked list, reverse the list and return the new head. 💡 Optimized Approach (Iterative – Three Pointers) Use three pointers: 👉 prev → previous node 👉 curr → current node 👉 next → next node Steps: 1️⃣ Store next node 2️⃣ Reverse current pointer 3️⃣ Move pointers forward ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) ✅ Why this problem is important? ✔ Foundation for all Linked List problems ✔ Tests pointer manipulation skills ✔ Frequently asked in interviews ✔ Needed for problems like Reverse in K-groups, Palindrome Linked List 📌 LeetCode Result: ✔ Accepted ⚡ Runtime: 0 ms (Beats 100%) 📊 Memory Efficient 🔔 This is Question 21 of my “50 Important Coding Questions” series. Linked Lists unlocked 🔓 Keep going 💪 👉 Question 22 coming soon… #DSA #LeetCode #ReverseLinkedList #LinkedList #Pointers #CPlusPlus #CodingInterview #ProblemSolving #50ImportantQuestions

Day 9 | Round 5 — 30 Days Coding Challenge 🚀 Today I solved the problem “Find K-th Bit in N-th Binary String.” 🔎 Problem (In Simple Words) We are given two numbers n and k. A binary string is built using this rule: S1 = "0" Si = S(i-1) + "1" + reverse(invert(S(i-1))) We need to find the k-th bit in the string Sn. 💡 Understanding the Pattern Each new string is built using three parts: Previous string The character "1" The reversed and inverted version of the previous string Invert means: Change 0 → 1 Change 1 → 0 So every level depends completely on the previous level. 🛠️ Approach I Used Start with base case: S1 = "0" For each level from 2 to n: Invert the previous string Reverse it Concatenate: previous + "1" + reversed inverted string Finally, return the (k-1) index from Sn This directly follows the pattern defined in the problem. ⚙️ Complexity Time Complexity: Exponential string growth (since length doubles each level) Space Complexity: Stores all generated strings This problem helped me understand: Recursive string construction patterns String manipulation (reverse + invert) How problems build on previously generated results Round 5 — Day 9 Completed ✅ Recognizing patterns in construction-based problems makes implementation much clearer. #30DaysOfCode #Round5 #Day9 #StringManipulation #RecursionPattern #DSA #ProblemSolving #LeetCode #CodingChallenge #CPlusPlus #DeveloperJourney #Consistency #CodeDaily #TechGrowth

🌱 Day 57/90 – Mastering Sliding Window & Pattern Thinking | #DSAPattern Today’s focus was on strengthening my understanding of string transformation problems and how recognizing the right pattern can simplify what initially looks like a complex problem. Instead of jumping straight into coding, I spent time understanding the behavior of the string under rotations and flips and identifying the optimal strategy. The goal? Train my brain to quickly recognize pattern-based optimizations during interviews. 🧠 Problem I Practiced Today 👇 ✔ 1888. Minimum Number of Flips to Make the Binary String Alternating This problem looks tricky at first because we can rotate the string any number of times and then perform flips. Key insight: Instead of checking every rotation separately, we can simulate rotations using a sliding window on a doubled string. Then we compare the window with the two possible alternating patterns: • 010101... • 101010... By counting mismatches efficiently while sliding the window, we can determine the minimum flips required in O(n) time. 💡 What I Focused On Today 👉 Understanding how string rotations can be simulated using concatenation 👉 Applying the Sliding Window pattern for optimal comparison 👉 Tracking mismatches against alternating patterns efficiently 👉 Strengthening intuition for string manipulation problems 👉 Writing clean and readable Java logic Every day of this journey reinforces one important idea: Pattern recognition > brute force solutions Thinking deeply > coding quickly ✅ Day 57 done – one step closer to stronger problem-solving skills 🚀💪 #Day57Done #90DaysOfDSA #DSAPattern #SlidingWindow #StringAlgorithms #LeetCode #Algorithms #DataStructures #CodingInterviewPrep #JavaDSA #Programming #CompetitiveProgramming #CodingJourney #ThinkInPatterns #PlacementPreparation

🚀 50 Important Coding Questions – Question 32/50 🔹 Palindrome Linked List | LeetCode A classic Linked List problem that checks whether the list reads the same forward and backward. 📌 Problem Statement Given the head of a singly linked list, return true if it is a palindrome, otherwise return false. Example: Input: 1 → 2 → 2 → 1 Output: true 💡 Approach Used 1️⃣ Traverse the linked list and store values in a vector 2️⃣ Use two pointers (left & right) to compare elements 3️⃣ If any mismatch occurs → return false 4️⃣ If all elements match → return true ✔ Simple implementation ✔ Easy to understand logic ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 📌 LeetCode Result: ✔ Accepted ⚡ Clean implementation using vector comparison 🧠 Concepts Strengthened ✔ Linked List traversal ✔ Two-pointer technique ✔ Array comparison logic ✔ Edge case handling 📍 Question 32 of 50 in my “50 Important Coding Questions” series. Small steps every day lead to big improvements in problem solving 💯 👉 Question 33 coming next! #DSA #LeetCode #LinkedList #CodingInterview #ProblemSolving #CPlusPlus #TechJourney