What's wrong with this one-line function?

📅 Day 79 of 100 – #100DaysOfDSA 🧠 Problem Statement Given a collection of candidate numbers (candidates) that may contain duplicates, and a target number (target), find all unique combinations in candidates where the numbers sum to target. Each number in candidates may only be used once in the combination. 💡 Intuition This problem is a variation of the Combination Sum, solved using Backtracking, but with two crucial differences: Unique Combinations: The input array may contain duplicates, but the final combinations must be unique (e.g., if the input is [1, 1, 2], we don't want to list [1, 2] twice). Use Each Once: Each number in the combination must come from a unique index in the input array. Our approach: 1. Preprocessing: Sort the input candidates array. This groups duplicate numbers together. 2. Base Case: If target == 0, we found a valid unique combination, so we add a copy of the current combination (temp) to the result list (res) and return. 3. Loop and Pruning: We iterate from i = idx up to the end of the array. 4. Duplicate Skip: Crucial Step—If i > idx (not the first element in the current recursive call) AND candidates[i] == candidates[i - 1], we skip the current element. This prevents generating combinations that are identical to ones already generated using the previous duplicate number. 5. Value Pruning: If candidates[i] > target, we can stop the loop (break) because, due to sorting, all subsequent numbers will also be too large. 6. Recursive Step: Add candidates[i] to temp. Recurse with the next index (i + 1) and the reduced target: target - candidates[i]. Passing i + 1 enforces the rule that each number is used at most once. 7. Backtrack: Remove the element from temp. ✅ Complexity Analysis Time Complexity: O(2^n * n) Space Complexity: O(n) 🌟 The Journey Continues Day 79! We mastered the Combination Sum II problem. This solution highlights how sorting and a well-placed skip condition are essential modifications to the standard backtracking. If you're on a similar coding journey, let's connect and share our progress! 🚀 . . . #100DaysOfCode #Day79 #100DaysOfDSA #StriversA2ZDSA #Java #CodingJourney #DSA #ProblemSolving #DailyCode #CodeNewbie #LearningByDoing #CodingCommunity #Backtracking #CombinationSum #Recursion

📅 Day 78 of 100 – #100DaysOfDSA 🧠 Problem Statement Given a set of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target. The same repeated number may be chosen from candidates an unlimited number of times. 💡 Intuition This is another classic problem solved using Backtracking. The core idea is to explore all possible combinations by recursively trying to include a number and reduce the target. Our approach: The main logic is in the recursive helper function subSeqSum. It takes the candidates array, the remaining target, the current combination (temp), the current starting index (idx), and the result list (res). 1. Base Cases: i. If target == 0, we have found a valid combination, so we add a copy of temp to res and return. ii. If idx == candidates.length (we've run out of numbers) OR target < 0 (we've exceeded the target), we stop and return. 2. Recursive Choices at idx: Choice 1: Include the current element (candidates[idx]). i. Add candidates[idx] to temp. ii. Recurse with the same index (idx) but with the reduced target: target - candidates[idx]. This allows for repeated use of the same number. iii. Backtrack: Remove the element from temp. Choice 2: Exclude the current element (candidates[idx]). i. Recurse with the next index (idx + 1) and the same target. This ensures we move on to consider the next candidate number. ✅Time Complexity: O(2^t) where t = target / smallest candidate ✅Space Complexity: O(target) 🌟 The Journey Continues Day 78! We successfully solved the Combination Sum problem, which is a key variation of the backtracking pattern. If you're on a similar coding journey, let's connect and share our progress! 🚀 . . . #100DaysOfCode #Day78 #100DaysOfDSA #StriversA2ZDSA #Java #CodingJourney #DSA #ProblemSolving #DailyCode #CodeNewbie #LearningByDoing #CodingCommunity #Backtracking #CombinationSum #Recursion

🚀 𝗪𝗲𝗲𝗸 𝟱 - 𝗟𝗮𝗺𝗯𝗱𝗮 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 & 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜 This week I explored 𝗟𝗮𝗺𝗯𝗱𝗮 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻𝘀 and 𝗦𝘁𝗿𝗲𝗮𝗺 𝗔𝗣𝗜 in 𝗝𝗮𝘃𝗮 𝟴. 🔑𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: 1) Lambdas simplify method implementation and reduce boilerplate. 2) Streams process collections (List, Set, Array) in a functional, pipeline style. 3) Intermediate operations are lazy; terminal operations trigger execution. ⚡𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲: - Understanding how streams work behind the scenes and why intermediate operations don’t execute immediately. ✅𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: 1) Experimented with various collection operations to trace element flow through the pipeline. 2) Realized streams don’t modify the original collection and allow declarative, step-by-step data processing. 💡 Stream API is really interesting - I’ll be exploring it more! Any good resources are appreciated. For full details, check out my blog & GitHub repo. ✍️ 𝗥𝗲𝗮𝗱 𝗳𝘂𝗹𝗹 𝗯𝗹𝗼𝗴: https://lnkd.in/dxyVHHbz 💻 𝗖𝗼𝗱𝗲 𝗼𝗻 𝗚𝗶𝘁𝗛𝘂𝗯: https://lnkd.in/dmTbEWpe #Java #LambdaExpressions #StreamAPI #LearningJourney #Coding #JavaFullStack #WebDevelopment

🌟 Day 62 of LeetCode Challenge 🌟 📘 Problem: Next Greater Element II 💻 Language: Java 🏁 Platform: LeetCode 🧩 Concept: The problem focuses on finding the Next Greater Element (NGE) for each element in a circular array. For every element, we need to locate the first greater value by traversing the array cyclically. 🧠 Key Learning: Efficient traversal in circular arrays using modulo indexing (i + step) % n. Understanding of nested iteration logic to find the NGE. Learned how to initialize and update arrays for condition-based values. ⚙️ Approach: Iterate through each element of the array. For each element, look ahead (circularly) to find the next greater element. If found, assign it; otherwise, mark as -1. 🏆 Result: ✅ Accepted (223/223 test cases passed) ⏱ Runtime: 89 ms 💾 Memory: 46.47 MB 🏢 Companies: Google | Amazon | Microsoft | Infosys #LeetCode #Day62 #NextGreaterElement #Java #CodingChallenge #ProblemSolving #LearningJourney #Google #Amazon #Microsoft #Infosys

The 500 Error That Taught Me the Real Power of Logs You know those bugs that look tiny… until they hit you like a truck? 😅 A few days back, I was testing one of our microservices at TCS. Everything was running fine — no build errors, no warnings, no issues. I confidently hit the API… and boom 💣 — HTTP 500 Internal Server Error. No clue why. The service was up. The logic looked right. And the logs? They just went silent halfway through. After digging deeper, I realized the issue was simple — painfully simple: - I had fetched a value from the database that came as null. - I forgot to wrap that line in an if-else check. - The code hit a NullPointerException, and that’s where everything stopped. What helped me finally catch it? Logs. My logs showed that the code ran smoothly until a certain point — and then, nothing. That gap told me exactly where to look. That day, I learned something valuable: •  Logs aren’t just for production. They’re your map during debugging. So, I’ve made it a habit to: 🧩 Add meaningful log points at critical parts of my flow. ⚙️ Handle nulls and exceptions gracefully. 🪶 Write code that not only works — but also explains itself when it doesn’t. Now, when I debug, I don’t just ask “What failed?” I ask — “What story are my logs trying to tell me?” #SoftwareEngineering #Microservices #SpringBoot #Kafka #Flask #Observability #Logging #Monitoring #TechJourney #DevelopersLife 

🔥 Day 3 of #21DaysOfDSA 🔥 🎯 Goal (Problem I solved today): 👉Rotate Array on LeetCode Given an array, rotate it to the right by k steps, where k is non-negative. 💡𝗠𝘆 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 : I explored two different solutions: 1️⃣ Brute Force Approach: Rotated the array step by step, moving elements one by one. This works but is inefficient for large inputs. 2️⃣ Optimized Approach (using recursion): Instead of shifting elements individually, I applied a smarter rotation by reversing parts of the array strategically. This significantly reduced the time complexity and made the solution scalable. 📌 𝗞𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗮𝗻𝗱 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀: • Brute force helps you understand the problem, but optimization is where the real skill shows. • This problem highlights the importance of modulo operations and how they simplify rotations. • Tackling the same problem in multiple ways boosts confidence and builds deeper intuition. Day 3 done ✅ — feeling more consistent already. 🚀 #21DaysOfDSA #Java #ProblemSolving #CodingChallenge #LeetCode

🔥 Day 19 of #21DaysOfDSA 🔥 🎯 𝗚𝗼𝗮𝗹 (Problem I solved today): 4Sum – LeetCode 🧩 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗯𝗿𝗶𝗲𝗳: Given an array of integers and a target, find all unique quadruplets [a, b, c, d] such that a + b + c + d = target. The solution set must not contain duplicate quadruplets. 💡 𝗠𝘆 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵: • Started by sorting the array to simplify duplicate handling. • Used two nested loops for the first two numbers, then applied a two-pointer approach for the remaining two numbers. • Carefully skipped duplicates at every step to ensure uniqueness. • Achieved an efficient O(n³) solution — while not linear, it’s optimal for this problem size. 📌 𝗞𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 & 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀: • Sorting upfront makes duplicate avoidance much easier. • Multi-sum problems (2-sum, 3-sum, 4-sum) follow similar patterns — mastering one helps with others. • Patience and careful pointer management are key to avoid mistakes in complex iterations. Day 19 ✅ — complex problems are much more manageable when broken into smaller, familiar patterns. 🚀 #21DaysOfDSA #Java #ProblemSolving #CodingChallenge #LeetCode

🔥 Day 4 of #21DaysOfDSA 🔥 🎯 Goal (Problem I solved today): Search Insert Position – on LeetCode Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be inserted in order. 💡 𝗠𝘆 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 : I implemented a binary search-based solution. • Start with two pointers (left and right) and calculate the mid. • If the mid element equals the target → return the index. • If the target is smaller → search the left half, else search the right half. • If the element isn’t found, the left pointer gives the correct insertion position. This approach works in O(log n), which is much more efficient than a simple linear search. 📌 𝗞𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 & 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆𝘀 : • Problems become simpler when you leverage the property of a sorted array → binary search shines here. • Sometimes the “failure condition” (target not found) is as important as the “success condition.” • Efficiency matters: reducing time complexity from O(n) to O(log n) makes a big difference for large inputs. Day 4 ✅ — starting to enjoy the consistency of solving and sharing daily. 🚀 If you’ve solved this before, did you use binary search too, or go with a linear scan first? #21DaysOfDSA #Java #ProblemSolving #CodingChallenge #LeetCode

20% DSA problem-solving patterns that cover 80-90% of problems asked in every coding interview (From Infosys to Microsoft & every company in between) 1. Two Pointers 2. Sliding Window 3. Prefix Sums 4. Merge Intervals 5. Binary Search (and Variants) 6. Sorting-Based Patterns 7. Fast and Slow Pointers 8. Backtracking & Recursive Search 9. Divide and Conquer 10. Linked List Techniques (Dummy Node, In-place Reversal) 11. Stacks and Queues 12. Monotonic Stack / Queue 13. Expression Evaluation (Two Stacks) 14. String Manipulation & Regular Expressions 15. Hashmaps & Frequency Counting 16. Binary Trees & BSTs (Traversal, Construction, Properties) 17. Path Sum & Root-to-Leaf Techniques 18. Kth Largest/Smallest Elements (Heaps / QuickSelect) 19. Top K Frequent Elements 20. Merge K Sorted Lists 21. Dynamic Programming (Including Knapsack, Range DP, etc.) 22. Greedy & Interval Partitioning 23. Graph Traversals (BFS, DFS) 24. Graph Algorithms (DAGs, MSTs, Shortest Paths, etc.) 25. Design Problems (LRU Cache, Twitter, etc.) Most people struggle with DSA because they think they have weak logic. But mostly, it’s because their approach is completely wrong. If you want to solve problems fast and with solid accuracy, you need to think in patterns. Without patterns, you can solve every problem in an interview that you’ve seen once, but once you see a new problem, you will get stuck. And that’s exactly why I want to recommend my DSA pattern product, it completely changes the way you prepare. Link: https://lnkd.in/g94khGEh - help you track and learn the clues and triggers of different patterns - provide AI-based doubt solving + space to add your own notes - solve 250+ good problems with 5 problems each on 50 patterns - train you on every scenario, so you can solve unseen problems.

🌟 Day 40 of #100DaysOfCode Challenge 🌟 ✅ Platform: LeetCode 💻 Problem: Summary Ranges 📌 Task: Given a sorted array of unique integers, summarize consecutive sequences into range strings. Example: Input [0,1,2,4,5,7] → Output ["0->2","4->5","7"]. ✨ Key Learnings: Strengthened understanding of two-pointer traversal in arrays. Practiced detecting continuous ranges vs disjoint numbers. Improved handling of edge cases like empty arrays and single elements. Optimized implementation with O(n) time complexity and O(1) extra space (excluding result). 🚀 Core Concept: Use iteration to track the start of a sequence. When the current number breaks continuity, close the range and reset the start. Today’s solution helped sharpen my array processing and range grouping skills 🔥 #Day40 #100DaysOfCode #LeetCode #Java #ProblemSolving #DataStructures #Arrays #amazon #google #microsoft #infosys