LeetCode Runtime Trick: 0 ms Optimisation

🚀 One Habit That Improved My Problem Solving: DRY RUN + PATTERN FINDING While solving DSA problems on LeetCode, I realized something simple but powerful 👇 👉 Don’t jump straight to code. 👉 First, dry run the problem manually. 🔍 Step 1: Dry Run Take a small example and simulate it step-by-step. What is happening at each step? What values are changing? Where is the decision being made? This builds clarity. 💡 Step 2: Find the Pattern Once you dry run 2–3 examples, patterns start appearing: Repeating calculations Overlapping subproblems Greedy choices or sequences 👉 That’s where optimization begins. 🔥 Real Learning Most of the time, the solution is not in writing more code… It’s in understanding the pattern behind the problem. 🎯 My Rule Now: “If I can’t dry run it, I don’t understand it.” 💬 Try this approach in your next problem and see the difference. Clarity → Pattern → Optimization 🚀 #DSA #Coding #ProblemSolving #LeetCode #Programming #Tech #Learning #InterviewPrep

🚀 Day 6 of 100 Days LeetCode Challenge Problem: Check if Binary String Has at Most One Segment of Ones Today’s problem is all about pattern observation in strings—simple, but easy to overthink. 💡 Key Insight: The string should contain only one continuous block of '1's. 👉 That means: Once a 0 appears after a 1, There should be no more '1's later 🔍 Simplest Trick: Just check if the pattern "01" appears more than once OR even better → check if "10" appears followed by another "1" 💡 Cleaner approach: Traverse the string Count transitions from 1 → 0 If you ever see 1 again after that → ❌ Invalid 🔥 What I Learned Today: Many problems are just pattern validation Clean logic beats complex conditions Always try to reduce the problem to a simple rule 📈 Challenge Progress: Day 6/100 ✅ Consistency building strong! LeetCode, Strings, Pattern Recognition, Greedy, DSA Practice, Coding Challenge, Problem Solving, Algorithm Thinking, Programming #100DaysOfCode #LeetCode #DSA #CodingChallenge #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 18/60 — LeetCode Discipline Problem Solved: Valid Parentheses (Revision) Difficulty: Easy Today’s session revisited one of the most classic stack-based problems — validating whether a sequence of brackets is correctly balanced. The key idea is simple yet powerful: whenever an opening bracket appears, it is pushed onto the stack, and when a closing bracket appears, it must correctly match the most recent opening bracket. Problems like this beautifully demonstrate how the stack data structure naturally models nested structures, making it ideal for tasks involving balanced expressions and ordered matching. 💡 Focus Areas: • Reinforced stack-based problem solving • Practiced bracket matching logic • Strengthened understanding of nested structures • Improved clean implementation of stack operations • Focused on writing simple and readable logic ⚡ Performance Highlight: Achieved ~87% runtime efficiency on submission. Even the most fundamental problems continue to sharpen the foundations of algorithmic thinking. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Stack #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

Day 47 on LeetCode — Partition Labels ✂️✅ Today’s problem was a great example of greedy strategy with smart indexing. 🔹 Approach Used in My Solution The goal was to split the string into maximum number of partitions such that each character appears in only one part. Key idea in the solution: • First, store the last occurrence of each character in an array • Traverse the string while maintaining a current partition range • Continuously update the end of the partition using the last index of characters encountered • When the current index reaches end, it means the partition is complete • Store the partition size and start a new one This greedy approach ensures each partition is as small as possible while still valid. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Learned how preprocessing (last occurrence tracking) simplifies problems • Practiced greedy partitioning techniques • Strengthened understanding of interval expansion logic #LeetCode #DSA #Algorithms #DataStructures #GreedyAlgorithm #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 2 of 100 Days LeetCode Challenge Problem: Minimum Swaps to Arrange a Binary Grid Today’s problem was a great mix of greedy thinking + pattern observation. 💡 Problem Insight: We need to make the grid valid such that all elements above the main diagonal are 0. The only allowed operation is swapping adjacent rows. 🔍 Core Idea: Count trailing zeros in each row For each row i, we need at least (n - i - 1) zeros at the end If a row doesn’t satisfy, find a row below that does Bring it up using swaps (like bubble sort) 👉 If no such row exists → return -1 🔥 What I Learned Today: o Greedy approach can minimize operations efficiently o Thinking in terms of requirements per position simplifies the problem o Sometimes problems are just rearrangement with constraints 📈 Challenge Progress: Day 2/100 ✅ Staying consistent! LeetCode, Greedy Algorithm, Arrays, Matrix, Coding Challenge, Problem Solving, DSA Practice, Algorithm Thinking, Optimization, Programming #100DaysOfCode #LeetCode #DSA #CodingChallenge #GreedyAlgorithm #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 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

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

🚀 Solved “Count Commas in Range II” on LeetCode! This problem looks simple but requires smart observation. Instead of iterating through every number, I used a mathematical approach by grouping numbers based on digit length. Numbers with ≥4 digits contribute commas, and each range adds predictable counts. By calculating contributions per range, I reduced the complexity to O(log n) instead of brute force. 💡 Key takeaway: Pattern recognition and range-based thinking can significantly optimize problems. Enjoyed this one! Have you tried it yet? #LeetCode #DSA #Coding #ProblemSolving #Tech #Learning

Day 79 | #100DaysOfCode | #100DaysOfLearning 🧿 Still diving deeper into the Binary Tree pattern ✅ Solved: Symmetric Tree (Leetcode 101) This problem checks whether a binary tree is a mirror of itself around its center. 💡 Key Idea: Instead of comparing nodes in the same direction, we compare them crosswise: Left subtree of node A ↔ Right subtree of node B Right subtree of node A ↔ Left subtree of node B If both sides match at every level → the tree is symmetric. Approach (Recursion): If both nodes are NULL → symmetric If one is NULL → not symmetric Values must match Recursively compare: left.left with right.right left.right with right.left 📌 This problem strengthened my understanding of: ✔️ Mirror recursion in trees ✔️ Comparing two structures simultaneously ✔️ Thinking about trees from two directions at once Consistency continues… 79 days of showing up and learning something new. #100DaysOfCode #DSA #BinaryTree #Leetcode #CodingJourney #ProblemSolving #SoftwareEngineering #TechCommunity #Programmers #Developers #LearnInPublic

𝗬𝗼𝘂𝗿 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗮 𝗺𝗶𝗿𝗿𝗼𝗿. It shows exactly how clearly you understood the problem. We blame syntax. We blame time pressure. We blame the legacy codebase. But most of the time, the real issue is simpler: We didn't fully understand the problem before we started solving it. And the code shows it - every time. Scattered structure. Vague variable names. Logic that works, but nobody can explain. These aren't signs of a lazy engineer. They're signs of unfinished thinking. Clean code is not about formatting rules or style guides. It's what naturally happens when your thinking is clear. So before you refactor, ask yourself: Are you solving the problem… or 𝗷𝘂𝘀𝘁 𝗿𝗲𝗮𝗿𝗿𝗮𝗻𝗴𝗶𝗻𝗴 𝗰𝗼𝗻𝗳𝘂𝘀𝗶𝗼𝗻? That's where the real fix begins. #SoftwareDevelopment #CleanCode #Programming #DeveloperMindset #Coding #Tech #ProblemSolving #LearningInPublic