Heaps for Efficient Problem Solving

🔥 Day 10 of my coding consistency journey. Today I solved LeetCode Problem 1018 – Binary Prefix Divisible By 5. The task is to check whether the binary number formed at each prefix is divisible by 5. 💡 My Approach: • Instead of forming large binary numbers, I kept track of the current value modulo 5. • For each bit, I updated the value using: num = (num * 2 + current_bit) % 5 • If the result becomes 0, it means the current prefix is divisible by 5. • I stored the result for each prefix in a boolean array. This approach avoids overflow and keeps the solution efficient. Problems like this highlight the importance of modular arithmetic in optimization. Consistency is slowly turning into strength 🚀 #LeetCode #DSA #Algorithms #CodingJourney #ProblemSolving

Pattern Recognition Mastery on Day 224 Today Today I focused on a very important skill in competitive programming which is pattern recognition. Understanding the keywords in a problem description can help you choose the right data structure immediately. When I see words like subarray or substring combined with a window I know it is a Sliding Window problem. If the question asks for the maximum or minimum value in that window I know I need to use a Deque to keep the solution efficient. I applied this logic to solve LeetCode 239 which is the Sliding Window Maximum problem. Instead of checking every window from scratch I used a monotonic decreasing deque. This allows me to keep track of the largest elements in linear time. The core idea is to remove indices from the back of the queue if the new number is larger than the old ones. This ensures that the largest value is always at the front of the queue. Once the window moves past an index I simply remove it from the front. Learning these rules helps me solve hard problems much faster. It is all about building a mental rule book for different types of array and string challenges. LeetCode question solved today: 215 Sliding Window Maximum #DSAinJavaScript #365daysOfCoding #JavaScriptLogic #LeetCode #SlidingWindow #Deque #PatternRecognition #AlgorithmDesign #ProblemSolving #DataStructures #LogicBuilding #CodingChallenge #SoftwareEngineering #ProgrammingDaily #WebDevelopment #TechLearning #JSAlgorithms #CleanCode #InterviewPrep #SoftwareDeveloper

Day 81 - LeetCode Journey 🚀 Solved LeetCode 2: Add Two Numbers (Medium) — a classic linked list problem that beautifully combines arithmetic with pointer manipulation. At first, it looks like simple addition. But the twist is that numbers are stored in reverse order as linked lists, and we must simulate digit-by-digit addition. 💡 Core Idea (Simulation + Carry Handling): Traverse both linked lists simultaneously Add corresponding digits along with carry Create a new node for each digit of the result Move forward until both lists and carry are exhausted A dummy node helps in building the result list smoothly. 🤯 Why it works? Because we mimic the exact process of manual addition, handling carry at each step, ensuring correctness even when lengths differ. ⚡ Key Learning Points: • Converting real-world logic into code (digit addition) • Handling carry efficiently • Traversing two linked lists together • Using dummy node for clean construction • Managing different list lengths gracefully • Achieving O(max(n, m)) time and O(1) extra space This problem strengthens both logical thinking and linked list handling. Also, this pattern connects with: Add Binary Multiply Strings Linked List arithmetic problems Big integer calculations ✅ Better understanding of simulation problems ✅ Stronger pointer + arithmetic combination ✅ Improved handling of edge cases (carry, unequal lengths) From simple addition to linked list manipulation — this is where logic meets implementation 🚀 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Hello Everyone! After a long time, Sat at LeetCode Biweekly contest 180. Today's contest felt quite easy and I solved first three problems within 20 minutes and attempted the fourth problem 1) Traffic Signal Color(easy): can be solved by writing if else condition, the problem is so much straight forward. 2) Count Digit Appearance(Medium): Used digit extraction for each number in array and stored the digits in map data structure and return the frequency of the given digit Input: nums = [12,54,32,22], digit = 2 map: [1 : 1, 2 : 4, 3 : 1, 4 : 1, 5 : 1] --> Output: 4 3) Minimum Operations to Transform Array into Alternating Prime(Medium): iterated the given nums array twice ,one for even indexes and other for odd indexes. (Odd index must have non prime numbers) In odd index iteration, checked whether a number is prime , if it is prime and the number is 2 , then count will be incremented by 2 or if the number is prime and not 2 , then count will be incremented by 1. (Even index must have prime numbers) In even index iteration, for each number the count will be incremented by 1 until the prime number is reached (used looping and each iteration checks for prime number) Hoping to stay consistent and solve more different and creative problems ☺️ #cpp #competitiveprogramming #leetcode #problemsolving

Day 70 of #100DaysOfCode Today I solved "Unique Binary Search Trees" on LeetCode using Recursion + Dynamic Programming (Memoization). Key Idea: For n nodes, we try every value as the root. If a value root is chosen: Left subtree can be formed using (root − 1) nodes Right subtree can be formed using (n − root) nodes The total number of BSTs for that root becomes: left_subtrees × right_subtrees By summing this for all possible roots, we get the total number of unique BSTs. To avoid recomputing the same subproblems, I used memoization. Concepts Used: • Recursion • Dynamic Programming • Memoization • Binary Search Tree properties Time Complexity: O(n²) Space Complexity: O(n) This problem is a classic example of the Catalan Number pattern in dynamic programming. Step by step, building stronger intuition for DP and tree-based problems. #100DaysOfCode #DSA #LeetCode #DynamicProgramming #BinaryTree #Cpp #CodingJourney

Day 78 - LeetCode Journey Solved LeetCode 142: Linked List Cycle II (Medium) today — a powerful extension of the cycle detection problem. Earlier, we learned how to detect if a cycle exists. Now the challenge is to find the exact node where the cycle begins. 💡 Core Idea (Floyd’s Algorithm Extended): 1) Use slow & fast pointers to detect a cycle 2) Once they meet, reset one pointer to the head 3) Move both pointers one step at a time 4) The point where they meet again = start of the cycle 🤯 Why it works? Because of the mathematical relationship between distances traveled inside the cycle — both pointers align perfectly at the cycle entry point. ⚡ Key Learning Points: • Advanced use of two-pointer technique • Understanding the mathematics behind cycle detection • Solving without modifying the list • Maintaining O(n) time and O(1) space This is not just coding — this is algorithmic thinking at a deeper level. Also, this pattern connects with: -> Find duplicate number (cycle in array) -> Happy Number problem -> Loop detection in graphs ✅ Stronger conceptual clarity ✅ Better problem-solving depth ✅ Confidence with tricky pointer problems From detecting a cycle to pinpointing its start — that’s real progress 🚀 #LeetCode #DSA #Java #LinkedList #TwoPointers #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

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 58 of #100DaysOfCode Today, I solved LeetCode 2840 – Check if Strings Can be Made Equal With Operations II, a problem that builds upon string manipulation and constraint-based transformations. 💡 Problem Overview: Given two strings, the objective is to determine whether they can be made equal using a defined set of swap operations. The challenge lies in understanding which positions can influence each other. 🧠 Approach: To efficiently solve this problem, I focused on: ✔️ Identifying independent index groups based on allowed operations ✔️ Separating characters into even and odd indexed groups ✔️ Comparing sorted/grouped characters from both strings This ensures correctness while maintaining optimal performance. ⚡ Key Takeaways: Identifying independent groups simplifies complex transformations Sorting/grouping techniques are effective for comparison problems Understanding constraints leads directly to optimal solutions 📊 Complexity Analysis: Time Complexity: O(n log n) Space Complexity: O(n) Small improvements every day lead to significant growth over time 🚀 #LeetCode #100DaysOfCode #DSA #Strings #ProblemSolving #CodingJourney #SoftwareDevelopment

🚀 DSA Day 47 – LeetCode Problem 300: Longest Increasing Subsequence (LIS) Today’s problem was a classic and super important one in Dynamic Programming 📈 🔍 Problem Insight: Given an array of integers, the goal is to find the length of the longest strictly increasing subsequence. 💡 Key Approaches: 1️⃣ Dynamic Programming (O(n²)) For each element, check all previous elements Build a dp[] array where dp[i] stores LIS ending at index i 2️⃣ Optimized Binary Search Approach (O(n log n)) Maintain a temporary list (tails) Use binary search to replace elements and keep the list sorted Length of this list = LIS length ⚡ Why optimization works? We don’t need the actual subsequence — just the length. So we maintain the smallest possible tail for increasing subsequences of each length. 🧠 What I Learned: Difference between brute DP and optimized approach Using binary search in unexpected ways Importance of LIS in many advanced problems 💻 Time Complexity: DP: O(n²) Optimized: O(n log n) 📦 Space Complexity: O(n) Slowly building strong fundamentals 💪 — consistency > intensity! #DSA #LeetCode #DynamicProgramming #BinarySearch #CodingJourney #100DaysOfCode #TechGrowth