Solved Combination Sum IV with Dynamic Programming on LeetCode

🚀 Day-74 of #100DaysOfCodeChallenge 💡 LeetCode Problem: 3370. Smallest Number With All Set Bits (Easy) 🧠 Concepts Practiced: Bit Manipulation, Binary Representation, Logical Thinking Today’s challenge was short but conceptually sharp — finding the smallest number ≥ n whose binary representation consists only of 1’s (all set bits). This problem tested understanding of bit patterns and how to efficiently generate numbers with consecutive set bits using bitwise logic. 🔹 Key Idea: Keep generating numbers of the form (1 << k) - 1 (which gives 111...1 in binary) until we find one greater than or equal to n. It’s a neat example of how mathematical patterns meet binary logic in programming! ⚙️ ⚙️ Language: Java ⚡ Runtime: 0 ms (Beats 100.00%) 💾 Memory: 40.59 MB (Beats 87.17%) ✅ Result: 608 / 608 test cases passed — Accepted 🎯 Every problem, no matter how simple, reinforces that clarity in logic is the foundation of clean code 💪 #100DaysOfCode #LeetCode #Java #CodingChallenge #BitManipulation #BinaryLogic #ProblemSolving #Programming #DeveloperJourney #LearningEveryday #TechMindset #CleanCode

🔹 Day 40 – LeetCode Practice Problem: Find Greatest Common Divisor of Array (LeetCode #1979) 📌 Problem Statement: Given an integer array nums, find the greatest common divisor (GCD) of the smallest and largest numbers in the array. ✅ My Approach (Java): 1. Find the minimum and maximum elements in the array. 2. Starting from the smaller number and going downwards, check for the highest integer that divides both min and max. 3. Return that integer as the GCD. 📊 Complexity: Time Complexity: O(n + min(a, b)) Space Complexity: O(1) ⚡ Submission Results: Accepted ✅ Runtime: 0 ms (Beats 100%) 🚀 Memory: 43.41 MB (Beats 41.55%) 💡 Reflection: This problem shows how basic math logic and loop optimization can lead to extremely efficient solutions. A simple and powerful way to practice number theory in coding! #LeetCode #ProblemSolving #Java #DSA #CodingPractice #Learning

🚀 Day-73 of #100DaysOfCodeChallenge 💡 LeetCode Problem: 3354. Make Array Elements Equal to Zero (Easy) 🧠 Concepts Practiced: Simulation, Array Manipulation, Direction Reversal Logic Today’s problem was all about simulating a dynamic process — starting from a zero element in an array, moving in a chosen direction, and adjusting movement logic as the array updates. It’s a great exercise in understanding flow control and direction-based simulation, where small logical errors can change the entire outcome. Patience and precision made all the difference here. 🔹 Approach: Simulated each possible starting point and direction, tracking movements and reversals until all elements became zero. Focus was on correctness and clear logic rather than over-optimization. ⚙️ Language: Java ⚡ Runtime: 100 ms (Beats 23.49%) 💾 Memory: 43.44 MB (Beats 13.25%) ✅ Result: 584 / 584 test cases passed — Accepted 🎯 Each solved problem reminds me how logic, structure, and consistency build stronger foundations for solving complex challenges ahead 💪 #100DaysOfCode #LeetCode #Java #CodingChallenge #ProblemSolving #Programming #DeveloperJourney #TechMindset #LearningEveryday #Consistency #Simulation

💡 LeetCode 3467 – Transform Array 💡 Today, I solved LeetCode Problem #3467: Transform Array, which focuses on array manipulation and the use of conditional logic in Java — a neat problem that strengthens core programming fundamentals. ⚙️ 🧩 Problem Overview: You’re given an integer array nums. Your task is to: Replace even numbers with 0 Replace odd numbers with 1 Then, sort the transformed array in ascending order. 👉 Example: Input → nums = [4, 7, 2, 9] Output → [0, 0, 1, 1] 💡 Approach: 1️⃣ Iterate through the array. 2️⃣ Use a ternary operator to transform each element (even → 0, odd → 1). 3️⃣ Sort the array to arrange all zeros before ones. ⚙️ Complexity Analysis: ✅ Time Complexity: O(n log n) — due to sorting. ✅ Space Complexity: O(1) — in-place transformation. ✨ Key Takeaways: Practiced logical thinking and ternary operations in Java. Strengthened understanding of array transformations and sorting. Reinforced the value of writing clean, concise, and efficient code. 🌱 Reflection: Even simple transformation problems like this one sharpen the habit of thinking algorithmically. Consistency in small challenges leads to big growth in problem-solving skills. 🚀 #LeetCode #3467 #Java #ArrayManipulation #LogicBuilding #ProblemSolving #CodingJourney #DSA #CleanCode #ConsistencyIsKey

💡 LeetCode 1929 – Concatenation of Array 💡 Today, I solved LeetCode Problem #1929: Concatenation of Array, a simple yet satisfying problem that tests your understanding of array manipulation and indexing in Java. ⚙️📊 🧩 Problem Overview: You’re given an integer array nums. Your task is to create a new array ans such that ans = nums + nums (i.e., concatenate the array with itself). 👉 Example: Input → nums = [1,2,1] Output → [1,2,1,1,2,1] 💡 Approach: 1️⃣ Find the length n of the given array. 2️⃣ Create a new array of size 2 * n. 3️⃣ Loop through nums once — place each element both at index i and index n + i. 4️⃣ Return the resulting array. ⚙️ Complexity Analysis: ✅ Time Complexity: O(n) — Single traversal of the array. ✅ Space Complexity: O(n) — For the concatenated array. ✨ Key Takeaways: Practiced index manipulation and array construction. Reinforced the importance of efficient iteration. A great warm-up problem that strengthens logical thinking and array fundamentals. 🌱 Reflection: Even the simplest problems build the foundation for solving more complex ones. Every bit of consistent practice helps in mastering problem-solving and clean coding habits. 🚀 #LeetCode #1929 #Java #ArrayManipulation #DSA #CodingJourney #CleanCode #ProblemSolving #AlgorithmicThinking #ConsistencyIsKey

Have you ever seen a programming challenge turn into a global benchmark? The One Billion Row Challenge (1BRC) did exactly that. It started as a fun idea by Gunnar Morling and became a major event in the Java community. The goal sounds simple: process a text file with one billion temperature records and calculate min, mean, and max for each station. But behind that simple description lies an extreme test of performance and efficiency. Developers pushed Java to its limits, experimenting with memory mapping, parallel processing, and low-level optimizations. Some solutions now process all one billion rows in less than two seconds. What began as a coding game evolved into a showcase of how far modern Java has come. It proved that Java, with the right optimizations, can stand among the fastest languages in data processing. Have you tried the challenge yet or followed the community results? #Java #Performance #Programming #SoftwareEngineering #DeveloperCommunity #Benchmark #HighPerformanceComputing

💻 Strengthening Problem-Solving Skills with LeetCode (Java) Recently explored a few interesting problems that focused on string manipulation, array traversal, and text formatting — each reinforcing clarity and precision in algorithmic thinking: 🔹 Text Justification Implemented a custom text alignment algorithm that evenly distributes spaces between words to fit a given line width. Approach: Greedy + StringBuilder Time Complexity: O(n) 🔹 Two Sum II – Input Array Is Sorted Solved using a two-pointer technique to efficiently find pairs that add up to a target value in a sorted array. Approach: Two Pointers Time Complexity: O(n) 🔹 Is Subsequence Checked whether one string is a subsequence of another using linear traversal and pointer comparison. Approach: Two Pointers Time Complexity: O(n) 🔹 Valid Palindrome Validated alphanumeric palindromes by filtering characters and comparing from both ends. Approach: String cleaning + two-pointer comparison Time Complexity: O(n) These problems helped sharpen my logic-building process and improved my confidence in designing efficient, readable solutions. #LeetCode #Java #ProblemSolving #DSA #Algorithms #Coding #SoftwareEngineering

💻 Enhancing Problem-Solving Skills with LeetCode (Java) Recently solved a couple of fundamental algorithmic problems that helped strengthen my understanding of two-pointer techniques, array manipulation, and writing efficient solutions. 🔹 Container With Most Water Implemented an optimised two-pointer approach to find the maximum water area between vertical lines. Instead of checking every pair (which would be O(n²)), the solution smartly moves the pointer at the shorter height inward to explore potentially larger areas. Approach: Two Pointers, Greedy Time Complexity: O(n) Space Complexity: O(1) 🔹 3Sum Solved the classic triplet-finding challenge by sorting the array and using two pointers to efficiently search for combinations that sum to zero. Also handled duplicates to avoid repeated triplets. Approach: Sorting + Two Pointers Time Complexity: O(n²) Space Complexity: O(1) (excluding output list) These problems helped sharpen my understanding of pointer movement, edge-case management, and designing clean, efficient solutions. #LeetCode #Java #Algorithms #DSA #Coding #ProblemSolving #SoftwareEngineering #LearningJourney

#Day 3 of the Coding Challenge: The Missing Number! Today, I cracked a classic array problem: Finding the Missing Number in an array containing n distinct numbers from the range [0, n] My final, optimized solution uses the elegant Gauss Summation method with a crucial twist to avoid a common pitfall! # The Problem & The Solution Input: An array nums of length n (e.g., [3, 0, 1]). The numbers are from 0 to n(e.g., 0, 1, 2, 3). Missing Number: 2. Logic: {Missing Number} = {Expected Sum of } 0 { to } n) - ({Actual Sum of Array Elements}) 👨💻 My Optimized Java Code Java class Solution { public int missingNumber(int[] nums) { int n = nums.length; // CRITICAL FIX: Use 'long' for the expected sum calculation // to prevent Integer Overflow for large 'n'. long expectedSum = (long)n * (n + 1) / 2; long actualSum = 0; for(int num : nums){ actualSum += num; } return (int) (expectedSum - actualSum); } } ? Why the long is Key to Optimization While the O(n) summation method is fast, the intermediate value of frac{n(n+1)}{2}can easily exceed Integer.MAX_VALUE if the array is large (around n=65,536). By casting to long, we make the solution robust and production-ready, eliminating the risk of a bug under large constraints! ❓ Quick Poll: Which O(n) method do you prefer for this problem? Gauss Summation (Like above - Math is power!) Bitwise XOR (The clever one that avoids all addition!) Let me know your vote and why in the comments! 👇 #Day3 #CodingChallenge #LeetCode #Java #Programming #Algorithm #DataStructures #TechJobs #SoftwareDevelopment

📌 Day 18/100 - Valid Palindrome (LeetCode 125) 🔹 Problem: Determine whether a string reads the same forward and backward, ignoring case and non-alphanumeric characters. 🔹 Approach: Implemented a two-pointer technique. Skipped all non-alphanumeric characters. Compared characters from both ends in lowercase. Returned true if all matched, otherwise false. 🔹 Key Learning: Two-pointer method keeps logic clean and efficient. Character handling is key when data isn’t uniform. Time complexity: O(n), Space complexity: O(1). Sometimes, solving elegantly is better than solving fast. ✨ #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney