LeetCode Challenge Day 14: K-th Lexicographical String

🚀 Day 29 of 100 Days LeetCode Challenge Problem: Check if Strings Can be Made Equal With Operations I Day 29 is a short but pattern + constraint observation problem 🔥 💡 Key Insight: We can only swap characters where: 👉 j - i = 2 For a string of length 4, possible swaps: Index 0 ↔ 2 Index 1 ↔ 3 👉 That means: Positions (0,2) form one group Positions (1,3) form another group 🔍 Core Approach: 1️⃣ Group Characters Extract characters from: Even indices → [0, 2] Odd indices → [1, 3] 2️⃣ Compare Groups Sort both groups for s1 and s2 If both corresponding groups match → ✅ true Else → ❌ false 💡 Why This Works: You can rearrange freely within each group But cannot mix between groups 🔥 What I Learned Today: Limited operations define independent groups Think in terms of index grouping Small problems still test logical clarity 📈 Challenge Progress: Day 29/100 ✅ One day to 30! LeetCode, Strings, Swapping, Greedy, Pattern Recognition, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 19 of 100 Days LeetCode Challenge Problem: Count Submatrices With Equal Frequency of X and Y Today’s problem was a solid combination of 2D Prefix Sum + Hashing concept 🔥 💡 Key Insight: We need submatrices that: Include the top-left cell (0,0) Have equal number of 'X' and 'Y' Contain at least one 'X' 👉 Trick: Convert the grid into values: 'X' → +1 'Y' → -1 '.' → 0 🔍 Core Approach: 1️⃣ 2D Prefix Sum Transformation Build prefix sum based on above conversion 2️⃣ Check Each Submatrix (0,0 → i,j) If sum == 0 → equal number of X and Y ✅ 3️⃣ Extra Condition: Ensure at least one 'X' exists 👉 Track X count separately using another prefix matrix 🔥 What I Learned Today: Transforming problems into numbers simplifies logic Prefix sums + condition checks = powerful combo Always handle extra constraints carefully 📈 Challenge Progress: Day 19/100 ✅ Almost hitting Day 20! LeetCode, Prefix Sum, Matrix, Hashing, Problem Transformation, Algorithms, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #PrefixSum #Matrix #Hashing #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

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

🚀 Day 32 of My Coding Journey — Mastering Binary Search Today I solved the classic Binary Search problem (LeetCode 704), and it reinforced one important concept: 👉 Divide and conquer can turn O(n) problems into O(log n). 💡 What I practiced today: Iterative Binary Search (most optimal & commonly used) Recursive Binary Search (clean logic, but uses stack space) 🔍 Key Learning: Instead of scanning the whole array, we eliminate half of the search space in every step. That’s why Binary Search is extremely powerful for sorted data. 📌 Approach (Recursive): Find mid index Compare with target If smaller → search right half If larger → search left half Stop when low > high ⚡ Time Complexity: O(log n) ⚡ Space Complexity: Iterative → O(1) Recursive → O(log n) (due to call stack) 💭 My Takeaway: Binary Search looks simple, but mastering edge cases (like overflow in mid, base conditions) is what actually matters in interviews. 📈 Slowly building strong fundamentals for problem solving and technical interviews. #Day32 #DSA #BinarySearch #CodingJourney #LeetCode #ProblemSolving #TechLearning

🔹 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

Day 68 on LeetCode Guess Number Higher or Lower 🎯✅ Today’s problem reinforced the power of Binary Search on an answer space. 🔹 Approach Used in My Solution The goal was to identify a hidden number using the provided guess() API. Key idea in the solution: • Apply binary search between 1 and n • Pick mid and call guess(mid) • Based on the response:   – 0 → correct number found   – -1 → guessed number is too high → move left   – 1 → guessed number is too low → move right • Continue narrowing the search space until the number is found This is a perfect example of searching efficiently using feedback. ⚡ Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) 💡 Key Takeaways: • Strengthened understanding of binary search with external APIs • Learned how to adjust search space based on feedback • Reinforced the concept of searching on answer space 🔥 Another solid step in mastering binary search patterns! #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #DivideAndConquer #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 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

I just completed 100 problems on LeetCode — but the real value is in how my thinking evolved. When I started, I struggled with basic syntax, debugging errors, and even simple problems felt overwhelming. Instead of rushing through questions, I focused on building a strong foundation step by step. Here’s how my journey progressed: 🔹 Data Structures I worked on: • Arrays • Strings • Linked Lists • Stack • HashMap 🔹 Problem-Solving Patterns I learned : • Brute Force → understanding the problem • Two Pointer technique • Sliding Window (fixed & variable) • Hashing / Frequency Maps • Prefix Sum • Slow & Fast Pointer • Stack-based problems • Monotonic Stack • Greedy Algorithms 🔹 Key Improvements: • Reduced silly mistakes (index errors, edge cases) • Better debugging and cleaner code • Shifted from “what to do” → “why it works” 📊 Stats: • 100 problems solved • 55 Easy | 41 Medium | 4 Hard • 70%+ acceptance rate 💡 Biggest realization: DSA is not about solving more problems — it’s about recognizing patterns and applying them efficiently. 🚀 Next Goals: • Solve more Medium & Hard problems • Improve speed and consistency • Prepare for real coding interviews If you're starting your DSA journey: Don’t focus on speed. Focus on understanding. Speed comes later. #leetcode #dsa #coding #programming #softwareengineering #learning

🔹 Starting LeetCode? These Techniques You Must Know When solving problems on LeetCode, understanding the right technique makes problem-solving much easier. Some important techniques every beginner should know: • Two Pointer • Sliding Window • Prefix Sum • Binary Search Continuing this series, today I explored 👇 🔸 Prefix Sum Technique 🔹 What is it? It is a technique where we precompute cumulative sums of an array to answer range sum queries efficiently. 🔹 When to use it? Range sum queries Subarray sum problems When repeated calculations are involved 🔹 Why is it important? Instead of calculating the sum again and again, Prefix Sum helps reduce time complexity and avoids redundant work. 🔹 Key Learning Precomputing results once and reusing them can significantly optimize performance. More techniques to explore next 🚀 #LeetCode #DSA #Coding #ProblemSolving #Learning

🔹 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