Java Solution for Trionic Array Detection

Solved today’s LeetCode Daily Question using Java. Algorithm Traverse the array once to detect a strictly increasing sequence. Identify the peak element where the trend changes. Continue traversal while the sequence is strictly decreasing. Validate that there is exactly one peak and the traversal ends at the last index. Why this works A single-pass greedy scan ensures O(n) time complexity and constant space while rejecting invalid multiple-trend patterns early. Result • Runtime: 1 ms (beats 72.27%) • Memory: 44.62 MB (beats 64.71%) • 871/871 test cases passed #leetcode #algorithm #dsa #java #problemSolving #softwareengineering

📝 Day 16/30 – LeetCode #15 (3Sum) | Java This problem extends the two-sum pattern and introduces duplicate handling as the main challenge. A brute-force approach would require checking all triplets, resulting in O(n³) time complexity. By sorting the array and fixing one element, I applied a two-pointer approach on the remaining part of the array. Careful duplicate skipping ensured unique triplets while maintaining efficiency. This optimized the solution to O(n²) time. This problem reinforced how sorting combined with pointer logic can drastically reduce complexity. #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Consistency #LearningInPublic

🚀Java practice - Day 87 Completed! 👍 Problem: Sum of Squares of Special Elements Language: Java Today’s problem was about identifying special elements in a 1-indexed array. An element is considered special if its index divides the length of the array (n % i == 0). The task was to calculate the sum of the squares of such elements.✨ #Day87 #Java #LeetCode #Arrays #ProblemSolving #DailyCoding #Consistency #100DaysOfCode

Day 32 of #100DaysOfLeetCode 💻✅ Solved #144. Binary Tree Preorder Traversal on LeetCode using Java. Approach: • Used recursion to perform preorder traversal • Followed Root → Left → Right order strictly • Added node value before traversing subtrees • Traversed left subtree first, then right subtree • Stored values in a list during traversal Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 42.83 MB (Beats 96.77% submissions) Key Learning: ✓ Strengthened understanding of preorder traversal pattern ✓ Clearly differentiated preorder from inorder traversal ✓ Improved recursive tree traversal implementation skills Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

📝 Day 19/30 – LeetCode #33 (Search in Rotated Sorted Array) | Java This problem combines binary search with array rotation, making it more about logic than syntax. The main challenge was identifying which half of the array is sorted at every step and deciding whether the target lies within that range. By comparing boundary values and narrowing the search space accordingly, the problem can be solved efficiently in O(log n) time. This reinforced how adaptable binary search becomes when combined with careful condition checks. Another reminder that mastering patterns is far more important than memorizing solutions. #LeetCode #Java #DSA #BinarySearch #Arrays #ProblemSolving #LearningInPublic

❌ == is NOT the same as equals() in java They look similar, but they answer two different questions. 🔸== operator Checks reference equality ➡️ Do both variables point to the same object? 🔸equals() method Checks logical equality ➡️ Do both the objects have same value/content? ☘️ Example String a = new String("Java"); String b = new String("Java"); System.out.println(a == b); // false (different objects) System.out.println(a.equals(b)); // true (same content) Even though the text is the same, a and b are stored at different memory locations. 💡Thumb Rule 🔸Use == for primitive types (int, double, boolean) 🔸Use equals for objects (String, custom classes) Getting this wrong can cause subtle bugs, especially when comparing Strings. #Java #SoftwareEngineering #Cleancode #Programming

Day 3/50 | #50DaysOfCode 📍 Platform: LeetCode 💻 Language: Java ✅ 977. Squares of a Sorted Array (Easy) Today’s problem focused on array manipulation and sorting logic. It helped me understand how negative numbers affect order after squaring and how to maintain sorted order efficiently. 🔎 Approach: Traverse the array and calculate the square of each element Store the squared values in a new array Sort the new array in non-decreasing order Return the sorted squared array 📌 Example: Input: nums = [-4, -1, 0, 3, 10] Output: [0, 1, 9, 16, 100] This problem strengthened my understanding of arrays, sorting, and handling negative values in Java. #DSA #LeetCode #Java #CodingJourney #ProblemSolving #Consistency #LearningJourney #50DaysOfCode #LinkedIn

Day 31 of #100DaysOfLeetCode 💻✅ Solved #94. Binary Tree Inorder Traversal on LeetCode using Java. Approach: • Used recursion to perform inorder traversal • Followed Left → Root → Right order strictly • Traversed left subtree first before processing current node • Stored node values in a list during traversal • Returned the final list after complete traversal Performance: ✓ Runtime: 0 ms (Beats 100.00% submissions) ✓ Memory: 42.76 MB (Beats 98.30% submissions) Key Learning: ✓ Strengthened understanding of tree traversal patterns ✓ Improved clarity on recursion stack behavior ✓ Reinforced difference between preorder, inorder, and postorder traversal Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeTraversal #ProblemSolving #CodingJourney #100DaysOfCode

Day 36 of #100DaysOfLeetCode 💻✅ Solved #111. Minimum Depth of Binary Tree on LeetCode using Java. Approach: • Used recursive approach to calculate minimum depth • Returned 0 when root is null (base case) • If one subtree is null, avoided taking minimum of 0 (handled edge case carefully) • Returned 1 + minimum depth of valid subtree • Ensured correct handling of skewed trees Performance: ✓ Runtime: 6 ms ✓ Memory: 82.20 MB Key Learning: ✓ Understood difference between minimum depth and maximum depth logic ✓ Learned importance of handling null subtree cases correctly ✓ Improved confidence in solving binary tree recursion problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeProblems #ProblemSolving #CodingJourney #100DaysOfCode

𝐖𝐞𝐞𝐤 𝟐 | 𝐃𝐚𝐲-𝟏/𝟕 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦: Find Unique Subsets 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: Medium Today, I solved the classic “Subsets” problem (also known as Power Set) using recursion and backtracking in Java! Given an array of unique integers, the goal was to generate all possible subsets. ✨ Highlights of my solution: Clean recursive backtracking approach Explicit base case for recursion termination Explored both include and exclude choices for each element Passed all test cases with a fast runtime (1 ms) This problem is an excellent exercise to strengthen understanding of recursion, backtracking, and subset generation. #Day1Of #7DaysOfCode #LeetCodeChallenge #Java #Recursion #Backtracking #CodingJourney #ProblemSolving