Maximizing Trionic Array Sum with Java Optimization

Day 46/200 – LeetCode Challenge Multiply Strings Today’s focus was on implementing string-based multiplication without using built-in big integer libraries. The solution involved simulating manual multiplication using an integer array for positional sums. This approach ensured efficiency and accuracy even for very large inputs. Optimizing nested loops and handling digit positions carefully can significantly improve runtime in high-precision arithmetic problems. Continuing the 200-day journey with consistent progress #LeetCode #CodingChallenge #Java #ProblemSolving #200DaysOfCode #LearningEveryday

Day 56/100 – LeetCode Challenge ✅ Problem: #3005 Count Elements With Maximum Frequency Difficulty: Easy Language: Java Approach: HashMap Frequency Counting Time Complexity: O(n) Space Complexity: O(n) Key Insight: First pass: count frequency of each element. Second pass: find maximum frequency and count how many elements have it. Answer = max frequency × count of elements with that frequency. Solution Brief: Used HashMap to store element → frequency mapping. Iterated through frequencies to track: Current maximum frequency Number of elements achieving that frequency Returned product of max frequency and its occurrence count. #LeetCode #Day56 #100DaysOfCode #HashMap #Java #Algorithm #CodingChallenge #ProblemSolving #MaxFrequencyElements #EasyProblem #FrequencyCount #Array #DSA

Day 49/100 – LeetCode Challenge ✅ Problem: Maximum Sum Triconic Array Difficulty: Hard Language: Java Approach: Three-Pointer Expansion with Prefix/Suffix Optimization Time Complexity: O(n²) in worst case Space Complexity: O(n) Key Insight: Find trionic subarray with maximum sum: increasing → decreasing → increasing. For each middle peak a, expand left for decreasing segment and right for second increasing segment. Track maximum sum across all possible trionic subarrays. Solution Brief: Used nested loops to try each possible peak position. For each peak, expanded left while decreasing, right while increasing. Tracked maximum sum with proper handling of edge cases and large numbers (used long). Optimizing sum calculation for complex array patterns #LeetCode #Day49 #100DaysOfCode #Array #Java #Algorithm #CodingChallenge #ProblemSolving #MaxSumTriconicArray #HardProblem #ThreePointer #Subarray #Optimization #DSA

🚀 Day 78 of #100DaysOfCode Solved LeetCode Problem #3379 – Transformed Array ✅ A clean and elegant problem focused on index manipulation and modular arithmetic. The key was handling circular indexing correctly, especially with negative shifts—simple logic, but precision matters. Key Takeaways: -> Using modulo smartly to handle circular arrays -> Dealing with negative indices safely -> Writing concise and readable transformations -> Small problems still demand careful edge-case thinking Language: Java -> Runtime: 1 ms (Beats 98.72%) ⚡ -> Memory: 47.08 MB Consistency > Complexity. Keep moving forward. 💻🔥 #LeetCode #Java #Arrays #ModularArithmetic #ProblemSolving #100DaysOfCode

Day 7 of Daily DSA 🚀 Solved LeetCode 238: Product of Array Except Self ✅ 🔍 Approach: Built the solution using prefix and suffix products. First pass stores left-side products in the result array Second pass multiplies them with right-side products using a single variable No division used, and handled edge cases like zeros efficiently. ⏱ Complexity: • Time: O(n) • Space: O(1) extra space (output array excluded) 📊 LeetCode Stats: • Runtime: 2 ms (Beats 94.19%) • Memory: 72.23 MB This problem is a great example of how space optimization + traversal logic can turn a seemingly tricky problem into a clean, interview-ready solution. #DSA #LeetCode #Java #Arrays #PrefixSum #ProblemSolving #Consistency

Day 49: Keeping the rhythm with Binary! 🎶 Problem 693: Binary Number with Alternating Bits Today was a smooth one. The challenge: check if a number's binary representation has alternating 0s and 1s with no two adjacent bits being the same. My approach: 1. Converted the integer to a binary string. 2. Ran a linear scan to compare each bit with its neighbor. 3. If any match? Immediate false. It’s a clean O(logN) solution. While there are some "galaxy brain" bitwise tricks to solve this in one line, sometimes a clear string traversal is all you need to keep the streak alive. No nested nightmares today. 🚀 #LeetCode #Java #Binary #CodingChallenge #ProblemSolving #Algorithms

Day 57/100 – LeetCode Challenge ✅ Problem: Longest Balanced Substring I Difficulty: Medium Language: Java Approach: Brute Force with Frequency Array Time Complexity: O(n² × 26) ≈ O(n²) Space Complexity: O(26) → O(1) Key Insight: A balanced substring requires all occurring characters to have the same frequency. For each starting index, expand substring while tracking character counts. Check if all non-zero frequencies are equal. Solution Brief: Nested loops to generate all substrings. Used fixed-size frequency array (26) for lowercase letters. Helper function issamefreq() verifies all non-zero counts are identical. Tracked maximum valid substring length. #LeetCode #Day57 #100DaysOfCode #String #Java #Algorithm #CodingChallenge #ProblemSolving #LongestBalancedSubstring #MediumProblem #BruteForce #FrequencyArray #Substring #DSA

Day 44: Avoiding the O(n²) Trap 🔍 Problem 3714: Longest Balanced Substring II Today’s goal: find the longest substring where all present characters appear equally. Since we only had 'a', 'b', and 'c' to deal with, I split the logic into three cases (1, 2, or 3 unique characters). Pro tip: I almost nuked my runtime by using map.clear() inside a loop. Since clear() iterates over the map to nullify entries, it’s O(n). Switching to new HashMap<>() kept the complexity at a clean O(1) reset and a total O(n) pass. Don't let built-in methods turn your linear solution into a nested nightmare. Complexity matters. 🧗♂️ #LeetCode #Java #CodingChallenge #ProblemSolving

Day 47: Flipping bits and taking names! 🔄 Problem 190: Reverse Bits Today's challenge was to reverse the bits of a 32-bit unsigned integer. While there are elite bit-manipulation tricks for this, I decided to trust my own logic first. The Game Plan: 1. Convert the integer to a binary string. 2. Reverse the string using StringBuilder. 3. Manually pad the trailing zeros to ensure it stays a full 32-bit representation. 4. Parse it back to an integer. Is it the most optimal O(1) bitwise solution? Not yet. But implementing your own logic before peaking at the "perfect" solution is how you actually learn. I'm hitting the books now to master the bit-shift approach for the next round. 🧗♂️ #LeetCode #Java #BitManipulation #Algorithms #CodingChallenge #ProblemSolving

Day 51/100 – LeetCode Challenge ✅ Problem: #3634 Minimum Removals to Balance Array Difficulty: Medium Language: Java Approach: Sorting + Sliding Window Time Complexity: O(n log n) Space Complexity: O(1) Key Insight: After sorting, valid subarray must satisfy nums[j] ≤ nums[i] × k for all elements. Find longest valid subarray using sliding window, then minimum removals = n - maxLen. Solution Brief: Sorted array to bring comparable values together. Used two pointers: expand j, shrink i when condition fails. Tracked maximum window length where nums[j] ≤ nums[i] × k. Result = total elements - longest valid subarray length. #LeetCode #Day51 #100DaysOfCode #SlidingWindow #Sorting #Java #Algorithm #CodingChallenge #ProblemSolving #MinimumRemovals #MediumProblem #Array #TwoPointers #DSA