100DaysOfCode: LeetCode 2840 String Equality with Operations

🚀 Day 76 of #100DaysOfCode Today, I solved LeetCode 18 – 4Sum, a classic problem that extends the two-pointer technique to higher complexity. 💡 Problem Overview: Given an array, the task is to find all unique quadruplets that sum up to a target value. 🧠 Approach: ✔️ Sorted the array to simplify processing ✔️ Fixed two elements using nested loops ✔️ Applied the two-pointer technique for the remaining two elements ✔️ Carefully handled duplicates to ensure unique quadruplets This approach efficiently reduces unnecessary computations compared to brute force. ⚡ Key Takeaways: Sorting + Two Pointers is a powerful combination Avoiding duplicates is crucial in combination problems Breaking a complex problem into smaller parts simplifies logic 📊 Complexity Analysis: Time Complexity: O(n³) Space Complexity: O(1) (excluding output) Consistently pushing boundaries and solving more complex problems 🚀 #LeetCode #100DaysOfCode #DSA #TwoPointers #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

🚀 Day 78 of #100DaysOfCode Today, I solved LeetCode 154 – Find Minimum in Rotated Sorted Array II, a problem that focuses on binary search and handling edge cases with duplicates. 💡 Problem Overview: Given a rotated sorted array that may contain duplicates, the goal is to find the minimum element efficiently. 🧠 Approach: ✔️ Applied modified binary search ✔️ Compared mid element with the right boundary ✔️ Carefully handled duplicate values to avoid incorrect elimination of search space This approach ensures correctness even when duplicates are present. ⚡ Key Takeaways: Binary search can be adapted for complex scenarios Duplicates introduce edge cases that must be handled carefully Choosing the correct condition is key to narrowing the search space 📊 Complexity Analysis: Time Complexity: O(log n) (average), O(n) (worst case due to duplicates) Space Complexity: O(1) Strengthening problem-solving with optimized approaches 🚀 #LeetCode #100DaysOfCode #DSA #BinarySearch #ProblemSolving #CodingJourney #SoftwareDevelopment #InterviewPrep

🚀 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 45/100 – LeetCode Challenge 🔗 Problem: Linked List Components (LeetCode 817) 💡 Difficulty: Medium Today’s problem was all about understanding connected components in a linked list using a smart approach. 🧠 Key Insight: Instead of checking every possible combination, I used a HashSet for quick lookups. A component is counted only when a sequence ends, i.e., when the current node is in nums but the next node is not. ⚡ Approach: Convert nums into a set for O(1) lookup Traverse the linked list Count only when a component ends 📈 Time Complexity: O(n) 📦 Space Complexity: O(n) ✨ What I learned: Sometimes, solving problems efficiently is about identifying where something ends rather than where it starts. Consistency is key 🔥 Halfway through the journey — staying committed! #Day45 #100DaysOfCode #LeetCode #DataStructures #LinkedList #CodingJourney #ProblemSolving #SoftwareEngineering

Day 89/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 64 – Maximum Gap (Medium) 🧠 Approach: Sort the array and compute the maximum difference between consecutive elements. 💻 Solution: class Solution:   def maximumGap(self, nums: List[int]) -> int:     if len(nums) < 2:       return 0          nums.sort()     max_gap = 0          for i in range(1, len(nums)):       max_gap = max(max_gap, nums[i] - nums[i-1])           return max_gap ⏱ Time | Space: O(n log n) | O(1) 📌 Key Takeaway: Sorting helps identify the maximum gap by comparing adjacent elements, though linear-time bucket-based solutions can further optimize performance. #leetcode #dsa #development #problemSolving #CodingChallenge

🚀 Day 14/100 — LeetCode Challenge Solved Delete Node in a Linked List The twist? 👉 You are not given the head of the list At first, I thought deletion wouldn’t be possible without the previous node. But the trick is: 1) Copy the value of the next node 2) Point current node to next->next 3) Effectively “delete” the next node instead 💡 Key Insight: Instead of deleting the given node directly, we shift values and bypass the next node. 🧠 Time Complexity: O(1) 💾 Space Complexity: O(1) 💡 What I learned: Sometimes problems are not about applying a pattern, but about thinking differently with given constraints. Switching from patterns to concepts now. #LeetCode #DSA #100DaysOfCode #Cpp #LinkedList #CodingJourney

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/100 of my LeetCode Journey Back on track after a short break, and today’s problem was “Kth Smallest Element in a Sorted Matrix.” At first, I didn’t approach it correctly. I was thinking in terms of simple indexing, but this problem required a different perspective. I learned how a min heap can be used to efficiently track the smallest elements across multiple rows. Instead of checking the entire matrix, the idea is to always pick the smallest available element and move forward from there. What I noticed today is that my logic is improving, but I still need to be careful with implementation. Small syntax and indexing mistakes can break the whole solution even when the approach is right. Takeaway: Understanding the approach is important, but writing clean and correct code is equally important. Making steady progress, one problem at a time. Question: Do you also find implementation harder than understanding the logic? #Day4 #LeetCode #DSA #LearningInPublic #Consistency

Day 18 / 100 Days of Code Challenge 💻🔥 Solved LeetCode 155 — Min Stack 📊 🔍 Problem • Design a stack that supports standard operations: push, pop, top • Additionally, implement getMin() to return the minimum element • All operations must run in O(1) time ⚙️ Approach (Two Stack Technique) • Use one stack to store all elements • Use another stack to keep track of minimum values • While pushing, store the current minimum • While popping, update the minimum accordingly 💡 Key Learning • Maintaining extra information in data structures • Efficient tracking of minimum without traversal • Understanding how to achieve constant time operations ⏱ Complexity • Time: O(1) for all operations ⚡ • Space: O(n) 📦 Consistency continues 🚀 #100DaysOfCode #LeetCode #DSA #Stack #ProblemSolving #Consistency

Most people understand cycle detection… but get stuck when asked to find where the cycle starts. 🚀 Day 19/100 — LeetCode Challenge Solved Linked List Cycle II 💡 Step 1: Detect cycle -Use slow & fast pointers -If they meet → cycle exists 💡 Step 2: Find starting node -Move fast back to head -Move both one step at a time -Where they meet again → start of cycle 👉 This part is pure intuition + math 🧠 Time Complexity: O(n) 💾 Space Complexity: O(1) 💡 What I learned: Detecting a cycle is easy. Finding its starting point is where real understanding begins. This is one of those problems where you either memorize… or truly understand. Have you ever understood why this works? #LeetCode #DSA #100DaysOfCode #Cpp #LinkedList #TwoPointers #CodingJourney