Oleg Z.’s Post

Day 75/90 Solved: Sum of Subarray Minimums At first glance, this problem looks complex, but it becomes manageable once you understand the core idea: → For each element, find how many subarrays it is the minimum of. Key learning: Used monotonic stack to compute left (strictly greater) and right (greater or equal) boundaries This helps count contribution of each element efficiently This was a good reminder that many “hard-looking” problems reduce to pattern recognition. #Consistency #DSA #LeetCode #Stack #MonotonicStack #ProblemSolving #Java #Algorithms

Day 105: Circular Arrays & Shortest Paths 🔄 Problem 2515: Shortest Distance to Target String in a Circular Array Today’s challenge involved finding the minimum steps to reach a target string in a circular array, allowing movement in both directions. The Strategy: • Bidirectional Search: Since the array is circular, the distance can be calculated in two ways: moving forward or moving backward. • Modular Arithmetic: I used (dist + n) % n to handle the wrap-around logic seamlessly, ensuring the index stays within bounds regardless of the direction. • Optimization: By iterating once through the array and comparing the distances for every occurrence of the target, I maintained an O(N) time complexity. Sometimes the most elegant way to handle a "circular" problem is simply embracing the symmetry of the path. 🚀 #LeetCode #Java #Algorithms #ProblemSolving #DailyCode

Day 9/ #100DaysOfCode Solved LeetCode 1848: Minimum Distance to the Target Element. Approach: The problem can be solved using a straightforward linear traversal. Iterate through the array and check for indices where the value equals the target. For each such index, compute the absolute difference between the current index and the given start index. Maintain a variable to track the minimum distance encountered during the traversal. Solution Insight: Initialize a variable with a large value (e.g., Integer.MAX_VALUE). Traverse the array once. Whenever the target element is found, update the minimum distance using Math.abs(i - start). Return the minimum value after the loop. Complexity: Time Complexity: O(n) Space Complexity: O(1) Result: 72/72 test cases passed with optimal runtime performance. This problem reinforces the importance of simple iteration and careful tracking of minimum values in array-based problems. #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #Algorithms

Another day of showing up, learning, and getting sharper 💻🔥 Solved Boundary Traversal of Binary Tree today and got it accepted with 100% accuracy (1111/1111 test cases passed) 💯✅ This was a really good problem for understanding how to break one tree traversal into multiple smaller traversals and combine them cleanly 🌳🧠 🔍 Problem Insight: The goal was to print the boundary nodes of a binary tree in anti-clockwise direction 🔄🌳 That means covering: 👉 Root node 👉 Left boundary (excluding leaf nodes) 👉 All leaf nodes (left to right) 🍃 👉 Right boundary (excluding leaf nodes, in reverse) 🧠 My Approach: Instead of forcing everything into one traversal, I split the problem into 3 clean helper functions ✨ 👉 Left Boundary Traversal Traversed the left side while skipping leaf nodes ⬅️🌿 👉 Leaf Node Traversal Collected all leaf nodes using DFS from left to right 🍃 👉 Right Boundary Traversal Traversed the right side and added nodes in reverse order to maintain anti-clockwise flow ➡️🔄 Then combined everything in sequence to build the final boundary traversal 🎯 ✨ Why this approach works well: ✔ Breaks a complex problem into manageable parts 🧩 ✔ Avoids duplicate leaf nodes 🚫🍃 ✔ Clean recursive design 🌳 ✔ Easy to debug and reason about 🧠 📊 Complexity: ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(h) recursion stack 💡 Key Takeaway: Tree problems often become much simpler when you stop thinking in terms of “one big traversal” and instead split them into smaller focused traversals 🎯 Decompose well → solve cleanly 🚀 One more tree problem down, many more to go 🌳💪🔥 #BinaryTree #Trees #TreeTraversal #Java #Recursion #DFS #DataStructures #DSA #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #Programming 💻🌳🚀

Today’s problem: Bitonic Point (Peak Element in Array) In a world where data rises and falls, finding the turning point is everything — just like in business and life. 💡 Learned how to efficiently identify the peak using Binary Search instead of brute force. ⚡ Optimized thinking > Hard work alone Every day, one problem. Every problem, one step closer to mastery. Consistency is the real algorithm. 🔁 #DataStructures #Algorithms #Java #CodingJourney #ProblemSolving #BinarySearch #TechGrowth #DeveloperLife #Consistency #LearningInPublic #CarpenterBullet #FutureEngineer

The High Cost of the Wrong Initial Choice I have seen complex computation logic for over a million records take hours to run simply because of inefficient, row-by-row processing that is offered by database stored procedures and traditional java/python code. It is slow, impossible to scale, and eventually kills your product's edge in the market. By moving to vectorized logic with tools like NumPy or Polars, you can turn those hours of computation into milliseconds. This is not just about using newer tools, it is about leveraging modern execution like #SIMD (Single Instruction Multiple Data) and #multithreading to gain a massive competitive advantage. If your backend is computation heavy and you're still stuck in legacy loops, you are leaving performance, market edge and money on the table. References: https://lnkd.in/g8j3A5Bn https://lnkd.in/gaPnFUQm https://lnkd.in/gWt9WHnp #DataEngineering #SystemDesign #NumPy #PerformanceOptimization #Scalability #PythonProgramming #TechStrategy #Vectorization #TechToolChoice

When tasked with a complex Java upgrade, one frontier model burned through 61 million tokens just trying to reconstruct an architecture that a well-written recipe already understood. At enterprise scale, forcing agents to "guess" your service boundaries and dependencies from raw files isn't just slow—it’s prohibitively expensive. Join our upcoming Moderne Prethink webinar: "Don’t blame the agent, blame the context." We’ll demonstrate how to shift AI from "probabilistic guesswork" to "reasoning from facts" by providing agents with pre-resolved, compiler-accurate knowledge. We’ll cover: 💻 Live Demo: See agents operating with pre-generated semantic context vs. raw files. 📉 Token Efficiency: How to stop burning budget on repeated context reconstruction. 🎯 Determinism at Scale: Using LST-accurate models to ensure agents align with architectural intent across thousands of repos. Stop blaming the models for enterprise complexity. Give them the context they need to actually finish the job. Register here: https://lnkd.in/eaG_4krc #OpenRewrite #AI #SoftwareEngineering #Java #DevX

🚀 Solved a neat Difference Array problem today! 💡 Problem: Given an array and a set of range queries, determine whether it’s possible to make the entire array zero using the allowed operations. 🧠 Approach: Instead of applying each query directly (which would be slow), I used: • Difference Array for efficient range updates • Prefix Sum to compute actual impact at each index ⚡ Key Idea: Each query contributes to a range. By marking where the effect starts and ends, we can efficiently calculate how many times each index can be reduced. Then, for every index: • Compare available operations with required value • If available < required → not possible 📈 Complexity: O(n + q) — efficient and scalable 🔥 Key Learning: Using a Difference Array avoids repeated work and helps optimize range-based problems significantly. #LeetCode #DSA #Java #Coding #ProblemSolving #Arrays #Algorithms

Consistency is starting to compound 💻🌱🔥 Solved another problem today—this time from Binary Trees 🌳🚀 Completed Root to Leaf Paths with 100% accuracy (1115/1115 test cases passed) 💯✅ 🔍 Problem Insight: The task was to return all possible paths from the root node to every leaf node in a binary tree 🌳➡️🍃 🧠 My Approach: 👉 Used DFS (Depth-First Search) with recursion 🔁 👉 Maintained a currentPath list to track nodes while traversing 🛤️ 👉 At each node, added the current value to the path ➕ 👉 If a leaf node was reached, stored a copy of the current path in the final answer 📌 👉 Used backtracking by removing the last node after returning from recursion 🔙 ✨ Why this approach works well: ✔ Natural fit for tree traversal 🌳 ✔ Explores every root-to-leaf path efficiently 🚀 ✔ Backtracking keeps memory controlled 🧠 ✔ Clean recursive structure and easy to follow 🧼 📊 Complexity: ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(h) recursion stack (plus output space for storing all paths) 📦 💡 Key Takeaway: Tree problems become much simpler when you think in terms of: 👉 traversal pattern 👉 path tracking 👉 backtracking DFS + recursion continues to be one of the cleanest ways to solve path-based tree problems 🎯🌳 One more problem solved, one more concept strengthened 💪📈🔥 #BinaryTree #Trees #Recursion #DFS #Java #DataStructures #DSA #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #Programming #TechGrowth 💻🌳🚀