🚀 Day 53 of LeetCode Problem Solving Journey — 100 Days LeetCode Challenge Today, I solved LeetCode #1047 — Remove All Adjacent Duplicates in String using C++, under the guidance of Trainer NEKAL SINGH SALARIA Singh at REGex Software Services. 🔍 Approach Used: I used a stack-based approach to simulate duplicate removal: Traverse each character in the string If stack is empty → push character If current character matches stack top → pop (remove duplicate pair) Otherwise → push character At the end, I rebuilt the result string from the stack and reversed it to restore correct order. 🧠 Key Learnings of the Day: ✔ Stack is perfect for problems involving undo/removal operations ✔ Adjacent duplicate problems often map to LIFO logic ✔ Step-by-step simulation can simplify complex transformations ✔ Reconstructing output correctly is as important as processing ⏱️ Complexity Analysis: • Time Complexity: O(n) • Space Complexity: O(n) 💡 Stack problems often look tricky but become simple once you visualize the process step by step. #Day53 #100DaysLeetCodeChallenge #LeetCode #RegexSoftwareServices #NekalSingh #ProblemSolving #DSA #CPlusPlus #CodingChallenge #ProgrammingJourney #Stack #Strings #KeepGrowing

🧩 LeetCode Challenge – Day 30 ✅ Today’s problem was a step up in complexity, combining grouping logic with dependency resolution — definitely one that forces you to think before you code. 🔗 LeetCode 1203 – Sort Items by Groups Respecting Dependencies This problem showed how layered topological sorting works: first resolving dependencies between groups, and then ordering items within each group. Missing either level breaks the solution. 💡 Key Takeaways: • Complex problems often require multiple graphs, not just one • Topological sort becomes powerful when applied hierarchically • Proper problem decomposition matters more than brute-force coding #Day30 #LeetCodeChallenge #365DaysOfCode #DSA #CodingJourney #ProblemSolving #Graph #TopologicalSort

🚀 Day 4/100 – #100DaysOfDSA Consistency is getting stronger. 💪 Day 4 done. No zero days. Today’s problem: Merge In Between Linked Lists (LeetCode 1669 – Medium) At first, it looked simple. But Linked Lists always test one thing seriously — 👉 Pointer control. 🧠 What This Problem Required: Finding the node just before position a Finding the node just after position b Carefully reconnecting pointers Traversing list2 till the end Attaching everything without breaking the chain One small mistake in pointer movement = runtime error. 💥 💡 What I Learned: ✔ Think step-by-step before coding ✔ Dry run pointer problems on paper ✔ Linked List problems improve logical clarity ✔ Clean reconnection > complicated logic This journey is not about solving problems. It’s about becoming better at thinking. 4 Days. 4 Problems. 0 Excuses. Day 5 loading… 🚀 #100DaysOfDSA #LeetCode #LinkedList #ProblemSolving #CodingJourney #Consistency #BTech

🧩 LeetCode Challenge – Day 47 ✅ Today’s problem was a clean bit manipulation exercise — simple on the surface, but it tests how well you understand binary representation. 🔗 LeetCode 190 – Reverse Bits The key was iterating through each bit, extracting it, and rebuilding the reversed number carefully without losing information. 💡 Key Takeaways: • Bit-by-bit processing builds strong low-level understanding • Shifting and masking are fundamental bit manipulation tools • Small problems sharpen precision and attention to detail #Day47 #LeetCodeChallenge #365DaysOfCode #DSA #CodingJourney #ProblemSolving #BitManipulation

🔥 Day 147 of My LeetCode Journey — Problem 387: First Unique Character in a String 💡 Problem Insight: Today’s problem was to find the first non-repeating character in a string. Simple requirement — but only if you resist the urge to rescan the string repeatedly. 🧠 Concept Highlight: The clean approach is frequency counting + single scan: First pass → count character occurrences Second pass → return the first character with frequency 1 This guarantees O(n) time and avoids unnecessary nested checks. The real lesson: separate counting from decision-making. 💪 Key Takeaway: When a problem asks for “first” + “unique,” you almost always need two passes or a data structure that remembers order. Trying to do it in one naive loop leads to fragile logic. ✨ Daily Reflection: This problem reinforces that clarity beats cleverness. Clean state tracking makes string problems predictable and easy to reason about. #Day147 #LeetCode #Strings #HashMap #ProblemSolving #DSA #CodingJourney #ThinkClearly

🧩 LeetCode Challenge – Day 37 ✅ Today’s problem was more about careful observation and validation than heavy algorithms. One of those where the logic is straightforward, but missing a condition can flip the answer. 🔗 LeetCode 3634 The key was translating the problem statement precisely into checks and handling edge cases correctly during traversal instead of overcomplicating the solution. 💡 Key Takeaways: • Clear interpretation of constraints is half the solution • Simple logic fails if edge cases are ignored • Slowing down often leads to cleaner and correct code #Day37 #LeetCodeChallenge #365DaysOfCode #DSA #CodingJourney #ProblemSolving #Arrays

#100DaysOfLeetCodeChallenge Day 31/100 3065-MINIMUM OPERATIONS TO EXCEED THRESHOLD VALUE. 🔢 Minimum Operations Problem 🔹 Task: Given an array nums and an integer k, find the minimum number of operations needed based on the condition. 💡 My Approach I used a simple and clean logic: 1)Traverse the array 2)Check if nums[i] < k 3)Increment counter 4)Return final count 5)No extra space, no complex logic — just clear iteration. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) #LeetCode #DSA #Cpp #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 54 of LeetCode Problem Solving Journey — 100 Days LeetCode Challenge Today, I solved LeetCode #2390 — Removing Stars From a String using C++, under the guidance of Trainer NEKAL SINGH SALARIA Singh at REGex Software Services. 🔍 Problem Summary: You’re given a string containing letters and * characters. Each * removes: itself, and the closest non-star character to its left. The goal is to return the final string after all stars are processed. 🧠 Approach Idea: This problem maps perfectly to a stack simulation: Traverse characters one by one If character ≠ * → push to stack If character = * → pop last character from stack At the end, rebuild the result from the stack. 🧠 Key Learnings of the Day: ✔ Stack is ideal for “remove last element” operations ✔ Problems involving undo/backspace logic often use stack ✔ Simulation problems reward step-by-step thinking ✔ Pattern recognition helps solve similar problems faster ⏱️ Complexity Analysis: • Time Complexity: O(n) • Space Complexity: O(n) 💡 Many string problems are actually disguised stack problems — recognizing that pattern is a big win. #Day54 #100DaysLeetCodeChallenge #LeetCode #RegexSoftwareServices #NekalSingh #ProblemSolving #DSA #CPlusPlus #CodingChallenge #ProgrammingJourney #Stack #Strings #KeepGrowing

#100DaysOfLeetCodeChallenge Day 29/100-LeetCode Challenge 24. Swap Nodes in Pairs. 🔹 Problem: Given a linked list, swap every two adjacent nodes and return its head. ❗ Important: You must swap nodes, not just values. 💡 My Approach (Iterative – No Recursion) Instead of recursion, I used: ✅ A dummy node ✅ Two pointers ✅ Careful pointer adjustment This makes the solution: ✔ Efficient ✔ Easy to debug ✔ No extra recursive stack space 🔎 Key Idea If we have: 1 → 2 → 3 → 4 After swapping: 2 → 1 → 4 → 3 We move two nodes at a time and adjust pointers carefully. ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(1) Consistency > Motivation 💪 One problem at a time. #LeetCode #DSA #LinkedList #CodingJourney #ProblemSolving #100DaysOfCode

#100DaysOfLeetCodeChallenge Day 28/100-LeetCode Challenge 2095-DELETE THE MIDDLE NODE OF A LINKED LIST. Given the head of a singly linked list, delete the middle node and return the modified head. If the list has: a)Only one node → return NULL b)Multiple nodes → remove the middle one 💡 Approach Used . Instead of counting nodes, I used the efficient O(n) two-pointer method: ✔ slow moves 1 step ✔ fast moves 2 steps ✔ prev keeps track of the node before slow When fast reaches the end, 👉 slow will be at the middle node 🎯 🔎 Why This Approach? ✅ No need to calculate length ✅ Single traversal ✅ Constant space usage ✅ Clean and optimized logic ⏱ Complexity Time Complexity: O(n) Space Complexity: O(1) Consistent DSA practice is improving problem-solving confidence day by day 📈 #LeetCode #LinkedList #DSA #ProblemSolving #CodingJourney #100DaysOfCode