Behind the Scenes of Project Development

🚀 Day 87 – Mistakes I Made While Building My Project Today, instead of sharing achievements, I want to share something more real — the mistakes I made while building my project. Because honestly, that’s where most of the learning happened. 🔹 Mistakes I made • Jumped into coding without fully understanding the problem • Spent hours debugging issues caused by small mistakes • Didn’t plan the project structure properly in the beginning • Ignored optimization until things started slowing down • Tried to do everything at once instead of step-by-step 🔹 What I learned Mistakes are not failures — they are feedback. Each error taught me: ✔ How to think better ✔ How to debug faster ✔ How to write cleaner code ✔ How to approach problems logically 🔹 Key realization The difference between a beginner and a developer is not avoiding mistakes — it’s learning from them quickly. 📌 Day 87 — learning from mistakes and becoming better every day. #90DaysOfPython #LearningInPublic #DeveloperJourney #MistakesToLessons #GrowthMindset

Started with “I’ll solve a few problems”… ended up in a full-blown battle with logic, edge cases, and my own brain 😅 Here’s how the journey to 400 LeetCode problems actually looked: while (problemsSolved < 400) { try { solveProblem(); } catch (WrongAnswerException e) { debug(); questionLifeChoices(); } catch (TimeLimitExceededException e) { optimize(); cryInCorner(); } finally { drinkCoffee(); } } if (problemsSolved == 400) { System.out.println("🎉 Achievement Unlocked: 400 LeetCode Problems!"); confidence++; bugsAlso++; } // Reality Check if (newProblem == "Dynamic Programming") { brain.shutdown(); openYouTubeTutorial(); } return "Road to 500 🚀"; This journey taught me more than just coding — patience, consistency, and how to stay calm when your code works perfectly… but still gets “Wrong Answer” 😭 From celebrating small wins to fighting hidden test cases, every step was worth it. Next stop: 500 problems… and maybe one day, truly understanding Dynamic Programming 😄 #LeetCode #CodingLife #ProgrammerHumor #DSA #KeepGrinding

🚀 A Realization While Practicing LeetCode — It’s All About Patterns While working through coding problems, I’ve started noticing something interesting: Most problems on LeetCode are not random — they follow repeatable patterns. Once you start recognizing them, things become much clearer. 🧠 Common Patterns I’m Seeing • Brute Force (starting point for understanding) • Hashing / Arrays • Two Pointers • Sliding Window • Stack • Linked List techniques • Binary Search And then comes the more challenging layer 👇 ⚡ Current Challenge Areas (for me) • Recursion & Backtracking • Greedy approaches • Dynamic Programming (DP) • Graph problems • BFS & DFS concepts I understand the basics, but applying them in coding is still a bit challenging — and that’s exactly where real learning is happening. 💡 Key Insight Every complex problem is usually just a combination of: 👉 A known pattern 👉 A small twist The goal isn’t to memorize solutions, but to: • Identify patterns • Understand approaches • Build strong fundamentals 🎯 My Current Focus • Strengthening core patterns • Practicing consistently • Revisiting fundamentals when stuck • Learning by breaking down problems Step by step, things are starting to connect. Not perfect yet — but progressing 🚀 #LeetCode #CodingPractice #ProblemSolving #SoftwareEngineering #LearningInPublic #BuildInPublic

🚀 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

🚀 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 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 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

Today I learned that not all loops are the same and it actually blew my mind.I'm not going to lie. I thought a loop was just a loop.Turns out, there's a whole world in there. Here's what I uncovered today: 🔹 for loop → when you already know how many times you need to repeat something. Clean, predictable, in control. 🔹 while loop → when you don't know how many times, you just keep going until a condition is met. A little unpredictable just like real life. 🔹 while True → runs forever until YOU decide to stop it. At first it scared me. Then I realized how powerful that actually is. 🔹 Nested loops → a loop inside a loop. Each one exists for a reason. Choosing the right loop isn't just about making code work it's about making it make sense. That's the part nobody tells you when you start coding. It's not just logic. It's judgment. Still a beginner. Still figuring it out. But days like today remind me why I started. #Python #Loops #LearningToCode #CodingJourney #PythonProgramming #GrowthMindset #TechCommunity

🚀 Day 23 of 100 Days LeetCode Challenge Problem: Maximum Non-Negative Product in a Matrix Today’s problem was a deep dive into Dynamic Programming with edge cases (negative values) 🔥 💡 Key Insight: Since the grid contains negative numbers, the product can flip sign. 👉 So at each cell, we must track: Maximum product so far Minimum product so far Because: Negative × Negative = Positive 💥 🔍 Core Approach (DP): 1️⃣ DP State: For each cell (i, j) maintain: maxProduct[i][j] minProduct[i][j] 2️⃣ Transition: From top (i-1, j) and left (i, j-1): Multiply current value with both max & min Take: max → for maxProduct min → for minProduct 3️⃣ Final Answer: If final max ≥ 0 → return max % (10⁹ + 7) Else → return -1 🔥 What I Learned Today: Negative values require tracking both extremes DP is not always just “max”—sometimes it’s min + max together Edge cases define the real difficulty of a problem 📈 Challenge Progress: Day 23/100 ✅ Getting stronger with DP! LeetCode, Dynamic Programming, Matrix, Optimization, Negative Numbers, Algorithms, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #DynamicProgramming #Matrix #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 340+ LeetCode Problems Solved What started as random problem solving has now become a consistent habit. I’ve crossed 340+ problems on LeetCode, and more importantly, improved how I approach problems. Breakdown: • Easy: 144 • Medium: 182 • Hard: 14 Key lessons from this journey: • Consistency beats intensity — even 2–3 problems daily compounds over time • Struggling is part of the process — the real learning happens when you don’t get it immediately • Patterns matter more than problems — recognizing approaches (DP, Graphs, Sliding Window) is key • Revisiting problems is underrated — solving once is not enough • Clean thinking > fast coding — clarity leads to optimal solutions This journey has helped me build: • Strong problem-solving skills • Better debugging and analytical thinking • Confidence in tackling interview-level questions Next target: 500+ problems 💯 Let’s keep building 🚀 #LeetCode #DSA #CodingJourney #SoftwareEngineering #Placements2026