LeetCode 2839: String Equality with Swap Operations

🚀 Day 79 of #100DaysOfCode Today, I solved LeetCode 32 – Longest Valid Parentheses, a challenging problem that focuses on stack-based logic and string processing. 💡 Problem Overview: Given a string containing only '(' and ')', the goal is to find the length of the longest valid (well-formed) parentheses substring. 🧠 Approach: ✔️ Used a stack-based approach to track indices ✔️ Initialized stack with -1 to handle edge cases ✔️ For every closing bracket, popped from stack ✔️ Calculated valid substring length using current index and stack top This approach efficiently tracks valid sequences and avoids reprocessing. ⚡ Key Takeaways: Stack is powerful for handling matching problems Index-based tracking simplifies substring calculations Handling edge cases (like invalid starting brackets) is crucial 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(n) Solving hard problems step by step and improving every day 🚀 #LeetCode #100DaysOfCode #DSA #Stack #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep #HardProblems

👉Day 159 of 160 – LeetCode Challenge Problem: Longest Common Subsequence 👉 Problem:we have given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0. 👉Key Concept: Memoization, recursion, overlapping subproblems, optimal substructure, base case, character match, branching choices, DP table, index shifting, string comparison logic.

LeetCode Progress 35/50 — Remove Duplicates from Sorted List II Today I worked on a problem focused on linked list manipulation and careful edge case handling 🧩 💡 The challenge was to remove all nodes that have duplicate values, leaving only distinct numbers from the sorted linked list. 🧠 Approach: Used pointer-based traversal with a dummy node to handle edge cases effectively. Identified duplicate sequences and skipped them while preserving only unique nodes in the final list. ⏱ Time Complexity: O(n) 💡 What I learned: This problem highlighted how using dummy nodes and careful pointer handling can simplify linked list problems involving deletions and edge cases. 📈 Strengthening understanding of linked list operations and improving confidence in solving pointer-based problems. #LeetCode #DSA #LinkedList #ProblemSolving #Cpp #CodingJourney #Consistency 🚀

Day 75/150 🚀 LeetCode 101: Symmetric Tree 🧠 Problem Given the root of a binary tree, check whether it is a mirror of itself. 📌 Example Input → root = [1,2,2,3,4,4,3] Output → true 💡 Approach • Use recursion • Compare left subtree with right subtree • Check mirror structure • Continue recursively ⏱ Time Complexity O(n) 📦 Space Complexity O(h) ✅ Result: Accepted ⚡ Runtime: 0 ms (Beats 100%) #Day75 #LeetCode #DSA #BinaryTree #Recursion #CodingJourney #ProblemSolving #SoftwareEngineering

🔥 Day 167 of My LeetCode Journey Problem 82: Remove Duplicates from Sorted List II 💡 Problem Insight: Today’s problem takes duplicate removal a step further instead of keeping one copy, you must remove all nodes that have duplicates, leaving only distinct values. That single change makes the problem trickier than it looks. 🧠 Concept Highlight: The solution relies on pointer control with careful skipping: Use a dummy node to handle edge cases (like duplicates at the head) Traverse the list and detect duplicate sequences Skip all nodes with duplicate values entirely This ensures only unique elements remain, in O(n) time. 💪 Key Takeaway: Sometimes the requirement isn’t to “clean” duplicates it’s to eliminate them completely. Understanding the exact requirement changes the entire approach. ✨ Daily Reflection: This problem reinforced how important edge cases are in linked lists. Without a dummy node, handling head duplicates becomes messy and error-prone. #Day167 #LeetCode #LinkedList #RemoveDuplicates #ProblemSolving #DSA #CodingJourney #Consistency

Day 63 / 100 – 100 Days of LeetCode Challenge 🚀 Problem: Repeated Substring Pattern (LeetCode #459) Today I solved the Repeated Substring Pattern problem. The task is to determine whether a given string can be constructed by repeating a substring multiple times. Approach Instead of checking every possible substring manually, I used a clever string manipulation trick. I concatenated the string with itself and then removed the first and last characters. If the original string exists inside this modified string, it means the string is formed by repeating a substring pattern. Steps followed: • Create a new string by concatenating the original string with itself • Remove the first and last characters from the new string • Check if the original string exists inside the modified string • If found → return true, otherwise return false This approach simplifies the logic and avoids unnecessary nested loops. Complexity Time Complexity: O(n) Space Complexity: O(n) Result ✔ Accepted ⚡ Efficient runtime 🧠 Smart string manipulation technique A good problem to strengthen understanding of string patterns and thinking beyond brute-force solutions. #100DaysOfCode #100DaysLeetCodeChallenge #LeetCode #DSA #CPlusPlus #ProblemSolving #Strings

🚀 Day 80 of #100DaysOfCode Today, I solved LeetCode 61 – Rotate List, a problem focused on linked list manipulation and efficient pointer handling. 💡 Problem Overview: Given the head of a linked list, the task is to rotate the list to the right by k places. 🧠 Approach: ✔️ Calculated the length of the linked list ✔️ Connected the tail to the head to form a circular list ✔️ Found the new tail position using k % length ✔️ Broke the cycle to get the rotated list This approach avoids unnecessary rotations and ensures optimal performance. ⚡ Key Takeaways: Linked list problems require strong pointer manipulation Converting problems into circular structures can simplify logic Modulo operation helps handle large values of k efficiently 📊 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 🎯 Day 80 Insight: Consistency over time builds confidence in solving even complex problems efficiently. On to Day 100 🚀 #LeetCode #100DaysOfCode #DSA #LinkedList #ProblemSolving #CodingJourney #SoftwareDevelopment #Consistency #InterviewPrep

🔥 Day 173 of My LeetCode Journey Problem 113: Path Sum II 💡 Problem Insight: Today’s problem extends Path Sum — instead of just checking existence, you must return all root-to-leaf paths whose sum equals the target. This shift from a Boolean list makes the problem more complex. 🧠 Concept Highlight: The solution uses DFS + backtracking: Traverse the tree while maintaining the current path Subtract node values from the target sum When a valid leaf is reached, store the path Backtrack to explore other possibilities Backtracking is essential to avoid mixing paths. 💪 Key Takeaway: Whenever a problem asks for all possible paths/combinations, backtracking is the go-to technique. Managing state correctly is more important than traversal itself. ✨ Daily Reflection: This problem reinforced the need for discipline when storing results. Without proper backtracking, solutions become incorrect quickly. #Day173 #LeetCode #BinaryTree #DFS #Backtracking #PathSum #ProblemSolving #DSA #CodingJourney #Consistency

Day 26/75 🚀 Solved Decode String (LeetCode 394) today! ✅ All 34/34 test cases passed ⚡ Runtime: 0 ms (Beats 100%) 💾 Memory: 8.22 MB (Beats ~99%) 🔍 Approach: Used a stack-based approach to decode the string. ✔️ Traverse the string character by character ✔️ If character is not ‘]’ → push into result ✔️ When ‘]’ is found: • Extract substring inside brackets • Get the number (repeat count) before '[' • Repeat the substring and append back This continues until the entire string is decoded. 💡 Key Learning: Whenever you see nested patterns (like brackets) → think of stack. It helps manage order and structure efficiently. Consistency + patience = clean solutions 💯 #LeetCode #CPP #DSA #ProblemSolving #CodingJourney #75DaysOfCode #Focused

🚀 Day 65/100 – LeetCode Challenge. 🔍 Problem: Remove All Adjacent Duplicates in String. At first glance, this problem looks like a simple string manipulation task… but the real magic lies in using the right approach! 💡 Approach Used: Stack (via string) 👉 Idea: Traverse the string If current character = last character of result → remove it Else → add it 🧠 Key Insight: We simulate a stack using a string. Last added character = top of stack → result.back() ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(n) 📌 Takeaway: Whenever you see adjacent duplicate removal / pair cancellation, think of stack pattern instantly! 💬 Example: Input: "abbaca" Output: "ca" #Day65 #100DaysOfCode #DSA #LeetCode #CodingJourney