21 Days of Code: Day 1 - Bit Manipulation Fundamentals

Today Morning,With the fresh morning, I solved the Reverse Integer problem on LeetCode. Instead of directly reversing the number, I focused first on handling edge cases — especially integer overflow. 🔍 Key Insight: Before pushing a digit into the reversed number, I checked whether the value would exceed the 32-bit integer range (Integer.MAX_VALUE / Integer.MIN_VALUE). This ensures correctness even for tricky inputs like 1534236469. 💡 What I learned: Always validate constraints before implementation Edge cases can make or break a solution Writing safe, overflow-aware code is crucial for real-world systems Consistently practicing DSA problems to sharpen logic and build strong fundamentals. On to the next challenge! 💪 Github link https://lnkd.in/gGUy_MKZ #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningEveryDay

Day 18 of my LeetCode Journey: Problem: Search in a 2D Matrix Approach: Started from the top-right corner of the matrix. At each step: If the value is greater than target → move left If smaller → move down If equal → found the target This works because rows and columns are both sorted, allowing us to eliminate one row or column at every step. Time Complexity: O(m + n) Space Complexity: O(1) Key insight: Using matrix properties smartly can avoid unnecessary binary searches. Using matrix properties smartly can avoid unnecessary binary searches. On to Day 19 💪 #LeetCode #DSA #Java #ProblemSolving #CodingJourney #Consistency #1001DaysOfCode

🔹 Day 91 – LeetCode Practice 📌 Problem: Three Consecutive Odds (LeetCode #1550) 📊 Difficulty: Easy 🧠 Problem Overview: Given an integer array, determine whether there are three consecutive odd numbers appearing next to each other. Return true if such a sequence exists; otherwise, return false. ✅ My Approach: Traversed the array while keeping track of consecutive odd numbers. Increased a counter whenever an odd number appeared and reset it when an even number was found. As soon as the counter reached three, the condition was satisfied. 📈 Complexity Analysis: Time Complexity: O(n) Space Complexity: O(1) 🚀 Submission Results: Status: Accepted ✅ Runtime: 0 ms (Beats 100%) 🚀 Memory: 44.18 MB (Beats 38.42%) 💡 Reflection: This problem highlights how a simple counter-based logic can efficiently solve pattern-detection tasks. Clean logic and early exits make solutions both fast and readable. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningJourney

🔹 Day 98 – LeetCode Practice 📌 Problem: Path Sum II (LeetCode #113) 📊 Difficulty: Medium 🧠 Problem Overview: Given the root of a binary tree and a target sum, the task is to find all root-to-leaf paths where the sum of node values equals the target. Each valid path should be returned as a list of values. ✅ Approach Used: Traversed the tree using depth-first search. Maintained the current path and cumulative sum while moving down the tree. When a leaf node was reached, checked if the sum matched the target. Used backtracking to explore all possible paths correctly. 📈 Submission Results: Status: Accepted ✅ Runtime: 2 ms Memory Usage: 45.54 MB 💡 Reflection: This problem is a great example of how recursion and backtracking work together in tree problems. Managing state carefully is key to collecting all valid paths without duplication. #LeetCode #BinaryTree #DFS #Backtracking #Java #DSA #CodingPractice

Day 6 | LeetCode Daily Challenge - 1161. Maximum Level Sum of a Binary Tree Problem in short: You're given a binary tree where the root is at level 1. For each level, compute the sum of node values and return the smallest level number that has the maximum sum. Key insight I learned: The problem becomes straightforward when approached level by level instead of node by node. Using Breadth-First Search (BFS) allows us to process the tree one level at a time and calculate the sum for each level independently. While traversing: • Maintain the current level • Compute the sum of all nodes at that level • Track the maximum sum seen so far and its corresponding level If multiple levels have the same maximum sum, returning the smallest level is handled naturally by updating the answer only when a strictly larger sum is found. A good reminder that choosing the right traversal technique can simplify tree problems significantly. On to the next challenge 🚀 #LeetCodeDaily #Day6 #DSA #ProblemSolving #Java #BinaryTree #Consistency #LearningByDoing

🚀 Day 47 of #100DaysOfCode Today’s problem was a clean and clever array-based challenge — 🔢 LeetCode: Single Number 📌 Problem Summary You’re given an array where every element appears twice except one. The task is to find that single unique number. 🧠 My Approach: Sorting + Pattern Check I followed a straightforward and intuitive approach: First, sort the array Traverse elements in steps of 2 If a pair doesn’t match, the unmatched value is the answer If all pairs match, the last element is the single number This works because sorting places duplicate numbers next to each other. ⚙️ Complexity Analysis ⏱ Time: O(n log n) (due to sorting) 💾 Space: O(1) (in-place logic) 💡 Note: This problem can also be optimized to O(n) time & O(1) space using XOR — exploring that next! 🔥 Key Learning Even simple problems can have multiple valid approaches Starting with a clear, readable solution builds strong intuition Optimization is powerful—but clarity comes first ✅ All test cases passed successfully ✔ Consistency > Speed — onward to Day 48 🚀 #100DaysOfCode #LeetCode #Java #Arrays #ProblemSolving #DSA #CodingJourney #Consistency

#200DaysOfCode – Day 106 Backtracking & Recursion | Combination Sum II Problem: Combination Sum II Task: Given an array of candidate numbers and a target, find all unique combinations where the numbers sum up to the target. Each number can be used only once, and duplicate combinations are not allowed. Example: Input: candidates = [10,1,2,7,6,1,5], target = 8 Output: [1,1,6], [1,2,5], [1,7], [2,6] My Approach: Sorted the array to handle duplicates efficiently. Used backtracking to explore all valid combinations. Skipped duplicate elements to avoid repeated combinations. Pruned recursion when the current value exceeded the target. Time Complexity: Exponential (Backtracking) Space Complexity: O(N) due to recursion stack Backtracking becomes much cleaner and more efficient when combined with sorting and smart pruning. Understanding when to skip elements is just as important as choosing them. #takeUforward #100DaysOfCode #Java #ProblemSolving #LeetCode #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie #Consistency

#200DaysOfCode – Day 107 Subsets with Duplicates Problem:- Subsets II (LeetCode 90) Task: Given an integer array nums that may contain duplicates, return all possible unique subsets (power set). Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] My Approach: Sorted the array to bring duplicate elements together. Used Backtracking to generate all subsets. Skipped duplicate elements at the same recursion level to avoid repeating subsets. Complexity Analysis: Time Complexity: O(2^N) Space Complexity: O(N) (recursion stack, excluding output) Handling duplicates becomes much easier when the input is sorted and recursion levels are controlled carefully. Backtracking problems look complex at first but the logic becomes clean once broken into steps. #takeUforward #100DaysOfCode #Java #LeetCode #ProblemSolving #Backtracking #Recursion #DSA #CodingJourney #CleanCode #DeveloperLife

Today, I worked on a problem that looks very straightforward, but really helps in understanding in-place array manipulation — LeetCode 283: Move Zeroes. 100 Days of LeetCode Challenge – Day 8 Problem Statement: Given an array containing both zero and non-zero elements, move all the zeroes to the end of the array while maintaining the relative order of non-zero elements. Approach (Two Pointers) Use one pointer to track the position of the next non-zero element Use a second pointer to traverse the array Whenever a non-zero element is found, swap it with the zero position and move the pointer forward This ensures all non-zero elements stay in order and zeroes naturally shift to the end. Complexity Time Complexity: O(n) Space Complexity: O(1) This problem strengthened my understanding of how two pointers can simplify array problems without using extra space. Day by day, getting more comfortable with DSA #LeetCode #100DaysOfCode #DSA #Arrays #TwoPointers #Java #ProblemSolving

🔹 Day 97 – LeetCode Practice 📌 Problem: Divide Array Into Equal Pairs (LeetCode #2206) 📊 Difficulty: Easy 🧠 Problem Overview: You’re given an integer array containing 2n elements. The goal is to check whether the array can be divided into n pairs such that: Every element is used exactly once Both elements in each pair are equal ✅ Approach Used: Sorted the array to bring identical elements together. Traversed the array while counting occurrences of each number. Verified that every number appears an even number of times, ensuring valid pairs. 📈 Submission Results: Status: Accepted ✅ Runtime: 8 ms Memory Usage: 46.94 MB 💡 Reflection: This problem is a great reminder that sorting can simplify pairing logic significantly. Once the array is ordered, validating pairs becomes straightforward and efficient. #LeetCode #ProblemSolving #Arrays #Java #DSA #CodingPractice #Consistency