LeetCode Techniques for Beginners: Prefix Sum and More

🔹 Starting LeetCode Series? These Techniques You Must Know When solving problems on LeetCode, knowing the right technique can save a lot of time and effort. Some important techniques every beginner should know: • Two Pointer • Sliding Window • Prefix Sum • Binary Search Continuing this series, today I explored 👇 🔸 Sliding Window Technique 🔹 What is it? It is used to process a fixed or variable size window (subarray/substring) that slides over the data. 🔹 When to use it? Subarray or substring problems Fixed or variable window size Problems involving maximum/minimum sum or length 🔹 Why is it important? Instead of recalculating values again and again, it helps optimize the solution from O(n²) to O(n). 🔹 Key Learning Rather than checking all possible subarrays, maintaining a window and updating it dynamically makes the approach much more efficient. More techniques to explore next 🚀 #LeetCode #DSA #Coding #ProblemSolving #Learning

🔹 Starting LeetCode? These Techniques You Must Know When solving problems on LeetCode, choosing the right technique can make a huge difference. Some important techniques every beginner should know: • Two Pointer • Sliding Window • Prefix Sum • Binary Search Continuing this series, today I explored 👇 🔸 Binary Search Technique 🔹 What is it? Binary Search is an efficient algorithm used to find an element in a sorted array by repeatedly dividing the search space in half. 🔹 When to use it? Sorted arrays Searching for a specific value Finding boundaries (first/last occurrence) 🔹 Why is it important? It reduces time complexity from O(n) to O(log n), making it extremely fast for large datasets. 🔹 Key Learning Instead of checking every element, dividing the problem into halves makes the approach much more efficient. This was the last technique from this set—more advanced patterns coming next 🚀 #LeetCode #DSA #Coding #ProblemSolving #Learning

🔹 Starting LeetCode? These Techniques You Must Know When I started thinking about practicing problems on LeetCode, I realized that solving questions randomly isn’t enough. Understanding key problem-solving techniques is what actually makes a difference. Some important techniques every beginner should know: • Two Pointer • Sliding Window • Prefix Sum • Binary Search Today, I explored one of these techniques 👇 🔸 Two Pointer Technique It involves using two indices to traverse an array or string instead of nested loops. 🔸 When to use it? Sorted arrays Pair-related problems Removing duplicates or reversing 🔸 Why is it important? It helps reduce time complexity from O(n²) to O(n), making solutions more efficient. 🔸 Key Learning Instead of checking every pair, using two pointers makes the approach much smarter and optimized. This is just one technique—more to explore next 🚀 #Leetcode #DSA #CodingJourney #ProblemSolving

🔹 Starting LeetCode? Let’s Revise the Core Techniques So far, I’ve been exploring some important problem-solving techniques, and I realized something… Just learning them once isn’t enough — revision is where the real understanding happens. So here’s a quick recap of the core techniques 👇 🔸 Two Pointer Used when dealing with sorted arrays or pair problems by using two indices instead of nested loops. 🔸 Sliding Window Helps solve subarray/substring problems by maintaining a window and updating it dynamically. 🔸 Prefix Sum Precomputes cumulative sums to efficiently handle range sum and subarray problems. 🔸 Binary Search Searches efficiently in sorted arrays by dividing the search space in half. 🔹 Key Takeaway It’s not just about knowing these techniques, but recognizing when to use them that really matters. This is just the foundation — now time to go deeper into more advanced patterns 🚀 #LeetCode #DSA #Coding #ProblemSolving #LearningInPublic

🚀 Day 4 of My LeetCode Journey Solved today’s problem: Two Edit Words ✅ Really enjoyed working on this one! 🔹 Problem Statement: Return all words in the dictionary that are exactly two edits away from any of the given queries (edit = insert, delete, or replace a character). 🔹 Approach: • For each query, compared it with every word in the dictionary • Counted character differences • If differences == 2 → valid word • Optimized by breaking early if differences exceed 2 🔹 Complexity: • Time Complexity: O(Q × N × L) • Space Complexity: O(1) 🧠 Key Learning: Handling string problems efficiently by avoiding unnecessary comparisons can significantly improve performance. 📊 Today’s Stats: ✅ Runtime: 0 ms (Beats 100%) ✅ Memory: 12.44 MB Consistency is the real game changer 💪 #LeetCode #DSA #CodingJourney #ProblemSolving #Consistency

🚀 Day 14 of 100 Days LeetCode Challenge Problem: The K-th Lexicographical String of All Happy Strings of Length n Today’s problem is a perfect blend of Backtracking + Lexicographical Ordering 🔥 💡 Key Insight: A happy string: Uses only 'a', 'b', 'c' No two adjacent characters are the same 👉 Instead of generating all strings blindly, we: Build valid strings using backtracking Maintain lexicographical order naturally 🔍 Core Approach: 1️⃣ Backtracking (DFS) Start building string character by character At each step: Choose from 'a', 'b', 'c' Skip if same as previous character 2️⃣ Lexicographical Order Always try characters in order: 'a' → 'b' → 'c' 3️⃣ Stop Early Once we reach the k-th string, stop recursion 👉 If total strings < k → return "" 🔥 What I Learned Today: Backtracking is powerful for constraint-based generation Ordering decisions early helps avoid extra sorting Early stopping = major optimization 📈 Challenge Progress: Day 14/100 ✅ 2 weeks strong! LeetCode, Backtracking, Recursion, Lexicographical Order, Strings, DFS, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Backtracking #Recursion #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

💻 LeetCode Progress Update I’ve solved 48 problems on LeetCode so far and have been focusing on pattern-based learning. So far, I’ve worked on: • Two Pointers • Fast & Slow Pointers • Sliding Window Today’s problems: • Two Sum (#1) • Intersection of Two Arrays (#349) 🧠 Key takeaway: It’s not about solving more problems — it’s about understanding patterns deeply and applying them effectively. Focusing on improving problem-solving skills step by step 🚀 What DSA pattern helped you the most? #LeetCode #DSA #CodingJourney #LearningInPublic #SoftwareEngineering

Day 77 on LeetCode Find Smallest Letter Greater Than Target 🔤🔍✅ Continuing the streak with a clean Binary Search application — keeping things simple and consistent during mids 💯 🔹 Approach Used in My Solution The goal was to find the smallest character strictly greater than the target in a sorted array, with wrap-around behavior. Key idea: • Apply binary search on the sorted array • Whenever letters[mid] > target, store it as a potential answer • Move left to find an even smaller valid character • If no such character exists, return letters[0] (wrap-around case) This ensures we always get the next greatest letter efficiently. ⚡ Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) 💡 Key Takeaways: • Practiced binary search for “next greater element” problems • Learned how to handle wrap-around edge cases • Reinforced writing clean and optimized search logic 🔥 Small wins every day consistency is the real progress. #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #Consistency #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Learning from Upsolving a Hard Problem on LeetCode Recently, I upsolved a Hard problem from Biweekly Contest 179 on LeetCode, and it gave me a really valuable insight into Dynamic Programming (DP). Key Takeaway: Sometimes, Tabulation fails while Memoization works better. Here’s why 1. In Tabulation (Bottom-Up), we often compute all possible states of the DP table — even those that are never needed to reach the final answer. 2. This can lead to unnecessary computations and, in some cases, TLE (Time Limit Exceeded). 3. In contrast, Memoization (Top-Down) only computes the states that are actually required, thanks to recursion + caching. 4. This makes it more efficient in problems where the state space is large but only a subset is relevant. My Experience: I initially implemented a Tabulation approach, but it resulted in TLE due to redundant state computations. Switching to Memoization helped me compute only the necessary states — and the solution passed efficiently! Lesson Learned: 1. Don’t blindly choose Tabulation over Memoization. 2. Always analyze the state space and transitions. 3. If many states are irrelevant, Memoization might be the better choice. This was a great reminder that choosing the right approach matters just as much as solving the problem itself. #LeetCode #DynamicProgramming #Memoization #Tabulation #Coding #ProblemSolving #TechLearning #SoftwareEngineering #DSA #Upskilling

Day 80 on LeetCode Next Greater Element I 🔍📈✅ Not the optimal solution this time, but the focus remains the same consistency over perfection 💯 🔹 Approach Used in My Solution (Brute Force) The goal was to find the next greater element of each value in nums1 based on its position in nums2. Key idea: • For each element in nums1 → find its position in nums2 • From that index, scan to the right • The first element greater than current → that’s the answer • If none found → return -1 A straightforward approach that gets the job done. ⚡ Complexity: • Time Complexity: O(n * m) • Space Complexity: O(1) (excluding output) 🔹 Optimal Insight (For Next Time) • Use a monotonic decreasing stack on nums2 • Precompute next greater for all elements • Store results in a hash map for O(1) lookup 💡 Key Takeaways: • Even brute force builds understanding of the problem • Learned how nested traversal simulates next greater search • Not every day is about optimization — discipline matters more 🔥 Streak > Speed. Showing up daily is the real win. #LeetCode #DSA #Algorithms #DataStructures #Stack #MonotonicStack #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #Consistency #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney