100 LeetCode Problems: Mastering 15 Core Patterns

🚀 Day 58 of #100DaysOfCode Today, I solved LeetCode 2840 – Check if Strings Can be Made Equal With Operations II, a problem that builds upon string manipulation and constraint-based transformations. 💡 Problem Overview: Given two strings, the objective is to determine whether they can be made equal using a defined set of swap operations. The challenge lies in understanding which positions can influence each other. 🧠 Approach: To efficiently solve this problem, I focused on: ✔️ Identifying independent index groups based on allowed operations ✔️ Separating characters into even and odd indexed groups ✔️ Comparing sorted/grouped characters from both strings This ensures correctness while maintaining optimal performance. ⚡ Key Takeaways: Identifying independent groups simplifies complex transformations Sorting/grouping techniques are effective for comparison problems Understanding constraints leads directly to optimal solutions 📊 Complexity Analysis: Time Complexity: O(n log n) Space Complexity: O(n) Small improvements every day lead to significant growth over time 🚀 #LeetCode #100DaysOfCode #DSA #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment

🚀 Day 3 of 180 — Spiral Matrix III ✅ Yesterday I tried this problem. Today I solved it. Let's get into it. LeetCode 885 — Spiral Matrix III You start from a given cell (rStart, cStart) on a rows × cols grid and spiral outward. The goal is to collect all valid cells in the order you visit them. The catch — the spiral goes beyond the grid boundaries. You keep moving but only collect a cell if it actually exists inside the grid. My thought process: I used a direction array to handle movement cleanly: dir = 0 → East ( 0, +1) dir = 1 → South (+1, 0) dir = 2 → West ( 0, -1) dir = 3 → North (-1, 0) The most important pattern to notice in a spiral — step count increases after every 2 turns. East → 1 step South → 1 step West → 2 steps North → 2 steps East → 3 steps ... and so on So whenever direction is East or West, I increment the step count. At every cell — check if it's inside the grid. If yes, collect it. If no, just keep moving. The spiral never stops, we just skip invalid cells. Start → add (rStart, cStart) directly while(collected < rows * cols): if dir == East or West → step++ move 'step' times in current direction → inside grid? collect it turn clockwise → dir = (dir+1) % 4 One thing this problem taught me — sometimes the movement pattern is more important than the boundary logic. Once I saw the step pattern clearly, everything else followed. Day 3 done. 177 to go. 🔥 #180DaysDSA #Day3 #LeetCode #SpiralMatrix #Java #DSA #Arrays #Matrix #DSAJourney #CodingJourney #Programming #DataStructures #Algorithms #ProblemSolving #BuildInPublic #CodeNewbie #LearnToCode #100DaysOfCode #SoftwareDevelopment #Developer #StudentDeveloper #TechCommunity #LinkedInTech #CompetitiveProgramming

Day 78/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 141 – Linked List Cycle (Easy) 🧠 Approach: Use Floyd’s Cycle Detection (Tortoise & Hare). Move one pointer one step and another two steps. If they meet, a cycle exists. 💻 Solution: # Definition for singly-linked list. # class ListNode: #   def __init__(self, x): #     self.val = x #     self.next = None class Solution:   def hasCycle(self, head: Optional[ListNode]) -> bool:     slow = head     fast = head     while fast and fast.next:       slow = slow.next             fast = fast.next.next        if slow == fast:              return True     return False ⏱ Time | Space: O(n) | O(1) 📌 Key Takeaway: Using two pointers at different speeds is an efficient way to detect cycles without extra space. #leetcode #dsa #development #problemSolving #CodingChallenge

Claude ran the math and certified me as a top 0.1% Claude Code user. Mentioning it up front so it's not the point. The actual point: power users aren't people with more hours — they're people who stopped treating Claude Code as a chatbot and started treating it as infrastructure. That shift is available to anyone willing to make it. If you're using Claude Code mostly to answer questions, you're using about 5% of it. The other 95% is what happens when you: • Write skills instead of retyping prompts • Design subagents with roles — a debugger thinks differently than a planner • Use hooks to enforce your own discipline • Let it run headless — the real leverage shows up when you're not watching The ceiling is much higher than the default experience suggests. Go find yours. #ClaudeCode #Anthropic #PromptEngineering

Day 100: Consistency, Growth, and a Milestone 💯 Problem 3740: Minimum Distance Between Three Equal Elements I Today marks 100 days of continuous problem-solving. While the number is just a marker, the real value has been the daily discipline of opening the IDE and tackling whatever challenge LeetCode throws my way. The Strategy: • Frequency Grouping: I used a HashMap to store a list of indices for every unique number in the array. This allowed me to isolate potential triplets instantly. • Sliding Window Logic: For any number appearing three or more times, I looked at a sliding window of three consecutive indices (i,i+1,i+2). • The Formula: Through testing, I identified that the minimum distance between three equal elements can be derived from the span between the first and third occurrence: (index of 3rd - index of 1st) * 2. • Optimization: By iterating through the pre-grouped index lists, I kept the solution efficient and clean. Reflecting on these 100 days, I’ve moved from basic simulations to complex optimizations like Square Root Decomposition and 3D DP. The goal isn't to stop here—it's to keep building, keep optimizing, and keep growing. 🚀 #LeetCode #Java #Algorithms #DataStructures #100DaysOfCode #Consistency #ProblemSolving #DailyCode

🚀 Solved “Remove Element” on LeetCode today! A simple-looking problem, but a great exercise in in-place array manipulation. 💡 Key Insight   In many languages, you can’t change the length of an array — so the result must be placed in the first part of the same array. ⚡ My Approach   - Traversed the array once   - Maintained a pointer k for the next valid position   - Whenever an element ≠ target value, copied it to index k and incremented k  ⚡ Complexity   - Time: O(n) — single pass   - Space: O(1) — in-place, no extra memory  🔗 Problem + my A/C solution in comments 👇 Building fundamentals, one problem at a time 🔥  #LeetCode #DSA #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 7 of 100 Days LeetCode Challenge Problem: Minimum Number of Flips to Make the Binary String Alternating Today’s problem leveled up the difficulty with a mix of sliding window + string rotation + greedy logic. 💡 Key Insight: We can rotate the string (Type-1 operation), which means we should consider all possible rotations of the string. 👉 Trick: Double the string → s + s to simulate rotations Compare every window of size n with: "010101..." "101010..." 🔍 Approach: Use sliding window on the doubled string Count mismatches for both patterns Minimum flips across all windows = final answer 🔥 What I Learned Today: Rotation problems → think of string doubling Sliding window helps optimize repeated checks Combining multiple concepts = real DSA growth 📈 Challenge Progress: Day 7/100 ✅ One full week completed! LeetCode, Sliding Window, Strings, Greedy Algorithm, Pattern Matching, DSA Practice, Coding Challenge, Problem Solving, Optimization #100DaysOfCode #LeetCode #DSA #CodingChallenge #SlidingWindow #Strings #GreedyAlgorithm #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

Day 28 of #100DaysOfCode 💻 Today’s focus: Subsets II (LeetCode 90) Building on yesterday’s Subset Sum (Problem 1), today I explored how the same recursion pattern works when duplicates are involved. 📌 What I focused on: At each step → either pick the element or skip it (same as Subset 1) Sorting the array to handle duplicates Skipping repeated elements at the same recursion level 💡 Realization: Subset II is not a completely new problem—it’s an extension of Subset 1 with an extra constraint. Understanding the base pattern made it much easier to adapt and solve this one. Felt good to see how concepts connect step by step. Still getting more comfortable with recursion and backtracking 🚀 #LeetCode #DSA #Recursion #Backtracking #CodingJourney

🚀 Day 4 of 100 Days LeetCode Challenge. Problem: Special Positions in a Binary Matrix Today’s problem focused on matrix traversal + counting logic—simple concept, but requires careful observation. 💡 Key Insight: A position (i, j) is special if: mat[i][j] == 1 All other elements in the same row and column are 0 🔍 Efficient Approach: Count number of 1’s in each row Count number of 1’s in each column A position is special only if: Row count = 1 Column count = 1 👉 This avoids unnecessary repeated checks and improves efficiency. 🔥 What I Learned Today: Preprocessing (row & column counts) simplifies problems Avoid brute force → think in terms of frequency/counting Clean logic > complex code 📈 Challenge Progress: Day 4/100 ✅ Staying consistent! LeetCode, Matrix Problem, Arrays, Counting Technique, DSA Practice, Coding Challenge, Problem Solving, Algorithm Thinking, Optimization #100DaysOfCode #LeetCode #DSA #CodingChallenge #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

Day 20 of #30DaysOfLeetCode Solved LeetCode Problem #56 – Merge Intervals using C. Problem: Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals and return the non-overlapping intervals that cover all the intervals in the input. Approach I used: Sorting + Merging • First sorted the intervals based on the starting time • Compared each interval with the previous one • If they overlapped → merged them into a single interval • If not → stored it as a new interval • Repeated the process until all intervals were processed Performance: • Runtime: 3 ms • Memory: 18.84 MB What I learned today: • Better understanding of interval-based problems • How sorting helps simplify complex problems • Handling 2D arrays efficiently in C • Getting more confident with medium-level questions #LeetCode #DSA #Algorithms #Sorting #Intervals #CProgramming #ProblemSolving