LeetCode 961: N-Repeated Element in Size 2N Array

🚀 LeetCode Milestone: Problem #1448 – Count Good Nodes in Binary Tree (Medium) Today I solved another interesting binary tree problem that sharpened my DFS (Depth-First Search) skills. 🔹 Problem Statement: A node in a binary tree is considered good if, along the path from the root to that node, there are no values greater than the node itself. The task is to count all such good nodes. 🔹 Key Insight: Use DFS traversal. Track the maximum value seen so far along the path. If the current node’s value is greater than or equal to this maximum, it’s a good node. Update the maximum as we go deeper. 🔹 Example: Input: [3,1,4,3,null,1,5] Output: 4 Explanation: Nodes (3, 4, 5, 3) are good. 🔹 Learning: This problem reinforced the importance of carrying state (like max-so-far) during recursion. It’s a neat example of how DFS can elegantly solve path-dependent conditions in trees. 💡 Every solved problem adds confidence and clarity to my coding journey. Looking forward to tackling more challenging problems and sharing my progress! #LeetCode #CodingInterview #Java #DSA #BinaryTree #ProblemSolving #BackendDeveloperJourney

Solved “3Sum Closest” (LeetCode – Medium) using the Two Pointer approach. Problem Solved: 3Sum Closest Approach: • Sorted the array to enable efficient pointer movement • Fixed one element and used left & right pointers to evaluate possible sums • Updated the closest sum based on minimum absolute difference from the target Key Learnings: • How sorting simplifies multi-pointer problems • Using absolute difference to track optimal results • Applying two-pointer logic beyond exact matches This problem helped me improve my understanding of: • Array-based problem solving • Two-pointer optimization techniques • Writing clean and readable logic Staying consistent with DSA practice to strengthen problem-solving fundamentals #DSA #TwoPointers #LeetCode #ProblemSolving #LearningByDoing #Java #CodingPractice

🚀 LeetCode 43 — Multiply Strings | DSA Learning Journey Today I worked on a problem that looks simple at first but actually dives deep into strings, arrays, and math logic. 🧩 Problem We’re given two non-negative integers as strings, and we must return their product also as a string. ⚠️ The twist: We cannot directly convert the strings into integers because the numbers can be extremely large. 💡 What this problem really tests This problem is basically about simulating the multiplication method we learned in school — but through code. Instead of relying on built-in big number operations, we: ✅ Multiply digits one by one ✅ Handle carries manually ✅ Store intermediate results in an array ✅ Build the final answer as a string 🛠 The Key Insight If the first number has length m and the second has length n, the result can have at most m + n digits. So the approach becomes: • Use an array of size m + n • Multiply digits from right to left • Carefully place each digit and carry in the correct positions That positioning logic is what makes the solution work. 📊 Time Complexity O(m × n) — because every digit of the first number multiplies with every digit of the second. #LeetCode #DSA #Java #ProblemSolving #CodingJourney #SoftwareEngineering #Algorithms

🚀 Binary Tree Maximum Path Sum 🌳🧠 Just completed LeetCode – Binary Tree Maximum Path Sum, one of the classic Hard problems that truly tests your understanding of tree DFS + recursion + dynamic programming concepts. 🔍 Key Learnings: A path can start and end at any node (not necessarily the root). At each node, we must consider three possibilities: Path passing through the node (left + node + right) Path extending from one side only (to be returned to parent) Path consisting of the node alone (important for negative values) Maintained a global maximum to track the best path sum seen so far. 🧠 Core Insight: The value returned to the parent must be a single-sided path The global answer may include both children, but cannot be extended upward ⚙️ Complexity: Time: O(n) — each node visited once Space: O(h) — recursion stack (h = tree height) This problem significantly strengthened my understanding of: DFS traversal patterns Handling negative values in trees Separating global answers from recursive return values #LeetCode #DSA #BinaryTree #DynamicProgramming #Recursion #Java #ProblemSolving #CodingJourney #SoftwareEngineering #LearningByDoing

BloodCode 3.0 | Ep-2 Problem 961 – N-Repeated Element in Size 2N Array No hype. No shortcuts. Just pure discipline. BloodCode 3.0 continues—and this time, the problem looks simple enough to trick you. That’s where most people fail. The Problem: You’re given an array of size 2N. One element repeats N times. Sounds obvious? It isn’t about finding it—it’s about how fast, how clean, and how efficiently you do it. Brute force is lazy. Overthinking is deadly. This problem tests pattern recognition, optimal logic, and your ability to see through noise. What this episode stands for: • Thinking before coding • Minimal logic, maximum impact • Training the brain to spot repetition instantly I failed BloodCode 2.0 because consistency cracked. BloodCode 3.0 exists to fix that mistake. 30 problems. 30 days. No mercy. This isn’t content. This is a public commitment. Stay sharp. Stay ruthless. #BloodCode #BloodCode3 #LeetCode #LeetCodeDaily #LeetCodeChallenge #DSA #DSAProblems #CodingDiscipline #CodeEveryday #30DaysOfCode #ProblemSolving #AlgorithmThinking #CodingMindset #DeveloperLife #SoftwareEngineer #TechGrind #CodingMotivation #NoExcuses #ConsistencyIsKey #Java #Python #Cplusplus #ArrayProblems #InterviewPrep

🎯 #LeetcodePotd | Problem Solved with 99%+ Runtime Performance Sometimes the smartest solution isn’t fancy — it’s structured thinking: Just solved LeetCode 1984 – Minimum Difference Between Highest and Lowest of K Scores ✅ And honestly? This is a perfect example of how sorting + sliding window = instant clarity. 🧠 Problem in Simple Words You’re given student scores. Pick k students such that the difference between the highest and lowest score is as small as possible. 👉 Goal: Minimize (max − min) among any group of size k. 💡 Key Insight (Beginner Friendly) If the array is sorted, then: Any group of k students will be contiguous The difference becomes: nums[i + k − 1] − nums[i] So instead of brute force chaos, we: Sort the array Slide a window of size k Track the minimum difference Clean. Efficient. Scalable. ⏱️ Complexity Analysis Time Complexity: O(n log n) (sorting dominates) Space Complexity: O(1) (ignoring sorting internals) 📊 Submission Stats ✔ Accepted: 118 / 118 test cases ⚡ Runtime: 7 ms 🔥 Beats 99.17% of submissions 💾 Memory: 47.15 MB 🧠 Takeaway Sort first. Think visually. Then optimize. On to the next one. Consistency > motivation. 💪 #LeetCode #DSA #Java #ProblemSolving #Algorithms #SlidingWindow #Sorting #CodingJourney #BeginnersInTech #100DaysOfCode #SoftwareEngineering #InterviewPrep

DSA Consistency – Problem 8 - Solved the “Sort Colors” problem on LeetCode using the Dutch National Flag algorithm. In this problem, the goal was to sort an array containing 0s, 1s, and 2s without using extra space. I used a three-pointer approach (low, mid, high) to solve it efficiently in a single pass. Key Learnings: - Improved understanding of pointer-based logic - Hands-on practice with in-place array manipulation - Focus on writing optimized and clean solutions Complexity: - Time: O(n) - Space: O(1) Currently strengthening my DSA fundamentals to enhance problem-solving skills and prepare for automation and product-based roles. #DSA #ProblemSolving #LeetCode #Java #Algorithms #CodingPractice #LearningJourney #SoftwareTesting #AspiringAutomationTester