Solving LeetCode #1526 with Greedy Algorithm

💻 2011: Final Value of Variable After Performing Operations Today’s challenge was a simple yet interesting warm up problem that tests how efficiently we can track changes in a variable through a series of operations. 🧠 Concept: We start with X = 0, and perform operations like ++X, X++, --X, and X--. Each increment or decrement modifies X by 1, the task is to return the final value after performing all operations. ⚙️ Approach: - A straightforward solution: - Iterate through all operations. - Increment count by 1 for ++ or X++. - Decrement count by 1 for -- or X--. - Return the final count. Even though it’s an easy problem, it’s a great reminder that clarity and precision matter, small details in logic can make a big difference. #LeetCode #Python #CodingPractice #ProblemSolving #100DaysOfCode

💻 Day 1 of Week 2 #Learning_Of_DSA 🚀 Today’s #LeetCode_Problem_2149 – Rearrange Array Elements by Sign. At first glance, it looked straightforward… but the real test was in maintaining order and structure, just like writing clean backend routes 🧠 Approach: ✅ Separate the +ve and -ve value and arrange in resultant array. Complexity: 🕒 Time – O(n) 💾 Space – O(n) Takeaway: Sometimes, the solution isn’t about “big algorithms” — it’s about organized logic. #LeetCode #ProblemSolving #Python #LearnInPublic #SoftwareEngineering #CodingJourney #CareerGrowth #100DaysOfCode #Motivation #MERNStack #DSA

#94day of #100DaysOfCode 💻 LeetCode 945: Minimum Increment to Make Array Unique Today’s problem was all about making every element in an array unique with minimum increments. 🧠 Approach: Sort the array. For each number, ensure it’s greater than the previous one. Increment it if needed and count the total moves. 📈 Complexity: Time: O(n log n) (due to sorting) Space: O(1)💬 Learning: Greedy + Sorting can simplify tricky increment problems. Every move builds toward a more structured, unique result — just like personal growth 🚀 #LeetCode #CodingChallenge #Python #DSA #ProblemSolving #GreedyAlgorithm #LeetCodeDaily #100DaysOfCode

#96day of #100DaysOfCode 🌱 LeetCode 109: Convert Sorted List to Binary Search Tree Today’s challenge was about building balance — literally! Given a sorted linked list, we need to convert it into a height-balanced BST 🌳 🧠 Key Idea: The middle element of the list becomes the root. Left half forms the left subtree, right half forms the right subtree. Use slow–fast pointers to find the middle efficiently. 📈 Complexity: Time: O(n log n) Space: O(log n) (recursion stack) 💬 Learning: Balance matters — in trees, in code, and in life 🌿 Sometimes, the middle point creates the strongest foundation. #LeetCode #DSA #BinarySearchTree #LinkedList #CodingChallenge #Python #Algorithm #LeetCodeDaily #100DaysOfCode

#Day254 of Solving #DSA ✅ LeetCode Daily Progress Today I solved Question 240 – Search a 2D Matrix II 💻 This problem was quite interesting as it required optimizing search within a sorted 2D matrix. Instead of checking every element, I used a binary search–like logic — starting from the top-right corner, and moving left if the current element was greater than the target or down if it was smaller. This approach reduced the complexity to O(m + n), making it much more efficient than a brute-force search. ⚡ 🧠 Key takeaway: Smart traversal techniques can often replace heavy loops — understanding patterns in data helps you find optimal paths! #LeetCode #Coding #DSA #BinarySearch #ProblemSolving #Python #CodingJourney

🚀 Solved the 4Sum problem (LeetCode #18)! An interesting extension of the 2Sum and 3Sum problems — it really tests how well you can use the two-pointer technique and handle duplicates efficiently. 🧩 Problem: Find all unique quadruplets [a, b, c, d] in an array that sum up to a given target. ⚙️ Approach: Sort the array Fix two numbers using nested loops Use two pointers for the remaining two numbers Skip duplicates to ensure unique results 🧠 Key Takeaways: Extension of 3Sum → 4Sum Practiced sorting + two-pointer technique Strengthened understanding of duplicate handling and O(n³) complexity Every problem solved is one step closer to mastering DSA 💪 #LeetCode #DSA #Python #Coding #ProblemSolving #TwoPointers #LearningJourney

𝗗𝗮𝘆 𝟯𝟵 𝗼𝗳 #𝟭𝟴𝟬𝗗𝗮𝘆𝘀𝗢𝗳𝗖𝗼𝗱𝗲 Today, I built on the first/last occurrence solution to 𝗰𝗼𝘂𝗻𝘁 𝗼𝗰𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝗲𝘀 𝗼𝗳 𝗮 𝘁𝗮𝗿𝗴𝗲𝘁 𝗶𝗻 𝗮 𝘀𝗼𝗿𝘁𝗲𝗱 𝗮𝗿𝗿𝗮𝘆 𝘄𝗶𝘁𝗵 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲𝘀. Using the same lower_bound and upper_bound helpers: Lower bound → first index where element ≥ target Upper bound → first index where element > target The count is simply: count = upper_bound - lower_bound This gives an O(log n) solution — much faster than scanning the entire array, especially with many duplicates. It’s a great example of how breaking a problem into reusable pieces leads to clean and efficient code. Perfect for analytics, frequency analysis, and search optimizations! 📊 #Python #Algorithms #BinarySearch #FrequencyCount #Coding #ProblemSolving

🚀 Day 74 of #100DaysOfDSA 🚀 Solved LeetCode 1901 — Find a Peak Element II 🔹 Problem: Find a peak element in a 2D grid — a cell strictly greater than its four neighbors. 🔹 Approach: Binary Search on Columns Perform binary search on the columns. For each middle column, find the maximum element in that column. Compare it with its left and right neighbors: If it's greater than both → it's a peak. Else, move toward the side with the larger neighbor. ✨ Key Insight: Even in 2D grids, binary search can efficiently locate a peak using greedy direction decisions per column. #LeetCode #DSA #BinarySearch #Matrix #Python #ProblemSolving #100DaysOfCode #CodingJourney 🚀

LeetCode 90-Day Challenge – Day 74 Problem: Evaluate Reverse Polish Notation Difficulty: Medium Problem: We’re given an array of strings tokens that represent an arithmetic expression in Reverse Polish Notation (RPN). Our goal is to evaluate this expression and return the result as an integer. In RPN, the operator appears after its operands, for example, instead of writing (2 + 1) * 3, we write 2 1 + 3 *. Solution approach: I solved this using a stack-based approach. Each time we encounter a number, we push it to the stack. When we encounter an operator, we pop the top two numbers, perform the operation, and push the result back. In the end, the stack will contain a single number, the final evaluated result. This approach runs in O(n) time and ensures integer division truncates toward zero, as required by the problem. #LeetCode #90DaysOfCode #Python #LinkedInChallenge #CodingJourney #ProblemSolving #LeetCodeChallenge