Java Parallel Stream Reduce Explanation

Day 68/100 – LeetCode Challenge ✅ Problem: #169 Majority Element Difficulty: Easy Language: Java Approach: Boyer-Moore Voting Algorithm Time Complexity: O(n) Space Complexity: O(1) Key Insight: Majority element appears more than n/2 times. Pair each occurrence of candidate with a different element to cancel out. The surviving candidate after pairing is the majority element. Solution Brief: Phase 1: Find potential candidate: Initialize ele with first element, cnt=1 For each element: if same → increment count, else decrement When count reaches 0, pick new candidate Phase 2: Verify candidate actually appears > n/2 times #LeetCode #Day68 #100DaysOfCode #Array #Java #Algorithm #CodingChallenge #ProblemSolving #MajorityElement #EasyProblem #BoyerMoore #VotingAlgorithm #DSA

Day 69/100 – LeetCode Challenge ✅ Problem: #229 Majority Element II Difficulty: Medium Language: Java Approach: Extended Boyer-Moore Voting Algorithm Time Complexity: O(n) Space Complexity: O(1) Key Insight: At most two elements can appear more than ⌊n/3⌋ times. Track two candidates and their counts simultaneously. When a new element matches neither candidate, decrement both counts. Solution Brief: Phase 1: Find two potential candidates: Maintain two candidates and their counts Update based on matches or count resets Phase 2: Verify both candidates actually appear > n/3 times Add valid candidates to result list. #LeetCode #Day69 #100DaysOfCode #Array #Java #Algorithm #CodingChallenge #ProblemSolving #MajorityElementII #MediumProblem #BoyerMoore #VotingAlgorithm #DSA

𝗗𝗮𝘆 𝟳/𝟮𝟬 — 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲🎯 Solved Longest Valid Parentheses ➤ Problem: Given a string of ‘(’ and ‘)’, determine the length of the longest well-formed (valid) parentheses substring. ➤ Approach: Used a clean and structured stack-based technique to identify valid boundaries efficiently. • Initialize the stack with -1 as the base index. • Push every '(' index onto the stack. • On encountering ')', pop to attempt a match. • If the stack becomes empty, push the current index as the new starting point. • Otherwise, compute the valid substring length using currentIndex − stackTop. Continuously update the maximum length. This ensures each character is processed in a single pass, maintaining optimal efficiency. #LeetCode #Java #DSA #TwoPointers #ArrayManipulation #ProblemSolving #20DaysChallenge #Consistency

#200DaysOfCode – Day 116 Problem: Minimum Bit Flips to Convert Number Task: Given two integers start and goal, determine the minimum number of bit flips required to convert start into goal. Example: Input: start = 10, goal = 7 Output: 3 My Approach: Used XOR (^) to identify positions where bits differ. Counted the number of 1s in the XOR result, since each 1 represents a required bit flip. Implemented the solution using: Bitwise operations A fixed 32-bit loop (Java int size) Complexity: Time Complexity: O(1) Space Complexity: O(1) Bit manipulation problems often look tricky, but once you understand XOR and bit counting, the solution becomes elegant and efficient. Sometimes, knowing the fundamentals deeply beats overcomplicating the logic. #200DaysOfCode #Java #BitManipulation #XOR #LeetCode #ProblemSolving #DataStructures #Algorithms #CodeNewbie #TakeUForward #Consistency

🚀 Day 30 / 100 | First Missing Positive -Intuition: The smallest missing positive will always be in range 1 to n+1. Place each number at its correct index (1 at index 0, 2 at index 1 so on). First index where value ≠ index+1 gives the missing number. -Approach : O(n) Find length of array n Traverse array and place each element at correct position -> index = value − 1 Ignore negative numbers, zero, and numbers > n After placement, traverse array again If arr[i] ≠ i+1 -> return i+1 If all elements are correct -> return n+1 -Complexity: Time Complexity : O(n) Space Complexity : O(1) #100DaysOfCode #Java #DSA #Array #LeetCode

Design Intent behind Encapsulation Encapsulation is often explained as private fields + getters/setters. In real systems, that definition breaks down very quickly. Encapsulation is about who owns decisions, who protects invariants, and where change is allowed to happen. This document captures how I now think about Encapsulation — beyond syntax, and all the way to why SOLID breaks when it’s violated. #SoftwareDesign #OOP #BackendEngineering #CleanCode #Encapsulation #Java

What causes OutOfMemoryError vs StackOverflowError? Here’s the answer: Both are runtime errors, but they happen in different memory regions. OutOfMemoryError (OOME) Occurs when the JVM cannot allocate memory in the Heap. Common Causes: • Creating too many objects • Memory leaks (objects not released) • Very large collections (e.g., huge ArrayList) • Excessive class loading → Metaspace full Eg: List<int[]> list = new ArrayList<>(); while (true) { list.add(new int[1000000]); // keeps filling heap } Eventually, Heap memory is exhausted. StackOverflowError (SOE) Occurs when the Stack memory of a thread is full. Common Causes: • Infinite or deep recursion • Too many nested method calls Eg: void recurse() { recurse(); // no exit condition } Each method call adds a frame to the stack → stack limit exceeded. OutOfMemoryError happens when Heap memory is exhausted, usually due to too many objects or leaks, while StackOverflowError occurs when the thread’s stack memory is full, typically due to deep or infinite recursion. Follow Supriya Singh for more such interesting and helpful posts. #Java #Programming #InterviewPrep #JavaDeveloper

Implemented array rotation using the Reverse Algorithm, an efficient in-place approach that avoids extra memory and unnecessary shifts. The technique works by reversing the full array, then reversing segments to achieve the required rotation. Time Complexity: O(n) Space Complexity: O(1) Understanding and applying in-place algorithms like this improves problem-solving and helps build clean, optimized, interview-ready code. #Java #DSA #ProblemSolving #Coding #SoftwareEngineering #LeetCode #Developers

When performance drops, the JIT compiler can feel less like magic and more like mystery. 🪄 In this #Devnexus session, Doug Hawkins from Datadog breaks down the key concepts behind modern Java compilers—intrinsics, basic blocks, inlining, and static single assignment (SSA). Learn how the compiler really works and what you should focus on optimizing, so you can save time, avoid wasted effort, and tackle the bottlenecks that matter most. https://lnkd.in/dhJvg4md 🎟️ Get tickets: devnexus.com ✉️ Stay up to date with all conference info: https://atlj.ug/LICTA #Java #JVM #PerformanceEngineering #JustInTimeCompilation #HotSpot #Devnexus2026 #SoftwareEngineering #BackendDevelopment #CodingBestPractices #DeveloperCommunity

Day 7 of Daily DSA 🚀 Solved LeetCode 167: Two Sum II – Input Array Is Sorted Approach: Used the two-pointer technique leveraging the sorted nature of the array. Moved pointers inward based on the comparison with the target to find the answer in one pass. Complexity: • Time: O(n) • Space: O(1) (constant extra space) LeetCode Stats: • Runtime: 2 ms (Beats 96.10%) • Memory: 48.54 MB (Beats 38.87%) This problem highlights how understanding input constraints can turn a brute-force solution into an optimal one. #DSA #LeetCode #Java #TwoPointers #ProblemSolving #Consistency