Julien Sigüenza’s Post

Day 66 on LeetCode — Binary Search 🔍✅ Today’s problem focused on one of the most fundamental and powerful techniques in DSA — Binary Search. 🔹 Approach Used in My Solution The goal was to find the index of a target element in a sorted array. Key idea in the solution: • Maintain two pointers: low and high • Calculate mid = low + (high - low) / 2 to avoid overflow • Compare nums[mid] with target:   – If equal → return index   – If greater → search left half   – If smaller → search right half • Continue until the search space is exhausted This approach efficiently reduces the search space by half in every step. ⚡ Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) 💡 Key Takeaways: • Mastered the core concept of divide and conquer • Learned how to safely calculate mid to avoid overflow • Reinforced understanding of searching in sorted arrays efficiently 🔥 Binary Search is a must-know pattern for interviews and advanced problems! #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #Arrays #DivideAndConquer #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

𝗧𝗵𝗶𝘀 𝗧𝗿𝗲𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗟𝗼𝗼𝗸𝘀 𝗟𝗶𝗸𝗲 𝗗𝗙𝗦… 𝗨𝗻𝘁𝗶𝗹 𝗡𝘂𝗺𝗯𝗲𝗿 𝗧𝗵𝗲𝗼𝗿𝘆 𝗕𝗿𝗲𝗮𝗸𝘀 𝗜𝘁 𝗢𝗽𝗲𝗻 🌳 Today’s problem looked like a simple tree traversal - until a quiet condition appeared: Count ancestors where nums[i] * nums[ancestor] is 𝗮 𝗽𝗲𝗿𝗳𝗲𝗰𝘁 𝘀𝗾𝘂𝗮𝗿𝗲. Brute force (walking up ancestors for every node) is too slow. The real win comes from 𝗰𝗵𝗮𝗻𝗴𝗶𝗻𝗴 𝘁𝗵𝗲 𝗽𝗲𝗿𝘀𝗽𝗲𝗰𝘁𝗶𝘃𝗲. 💡 𝗧𝗵𝗲 𝗞𝗲𝘆 𝗜𝗻𝘀𝗶𝗴𝗵𝘁 A product is a perfect square iff every prime factor appears an even number of times. So reduce every number to its square-free form: keep only primes with odd exponent. Examples: 12 = 2^2 × 3 -> 3 18 = 2 × 3^2 -> 2 Now the condition becomes: Two numbers form a perfect square product iff their square-free forms are equal. 🚀 𝗪𝗵𝗮𝘁 𝘁𝗵𝗲 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 For each node, count how many ancestors have the same square-free value. That’s just DFS + frequency map on the path. 🛠️ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 1. Build adjacency list 2. Precompute square-free value for each node 3. DFS from root while maintaining a hashmap of frequencies 4. At each node, add map.get(k[node]) to answer 5. Backtrack (remove from map) No ancestor traversal. No pair checks. ✨ 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝘀 1. Perfect square checks → parity of prime exponents 2. Convert math conditions into hashable signatures 3. DFS + hashmap is powerful for ancestor path problems 4. Optimize by transforming the condition, not the traversal A beautiful mix of Trees + Number Theory + Hashing. #algorithms #datastructures #dfs #numbertheory #trees #hashmap #graph #primefactorization #coding #programming #leetcode #codinginterview #interviewprep #problemSolving #competitiveprogramming #developer #devlife #engineering #tech #learning #growth #100DaysOfCode #career #faangprep

Day 73 on LeetCode Find First and Last Position of Element in Sorted Array 🎯🔍✅ Today’s problem focused on a classic and very important Binary Search variation. 🔹 Approach Used in My Solution The goal was to find the first and last occurrence of a target in a sorted array. Key idea in the solution: • Use two separate binary searches 🔸 Find First Occurrence: • When nums[mid] >= target, move left • If nums[mid] == target, store index and continue searching left 🔸 Find Last Occurrence: • When nums[mid] <= target, move right • If nums[mid] == target, store index and continue searching right • Combine both results to get final answer This ensures we don’t just find a match, but the complete range of the target. ⚡ Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) 💡 Key Takeaways: • Learned how to modify binary search to find boundaries instead of single elements • Strengthened understanding of first/last occurrence patterns • Realized how small logic changes turn binary search into powerful variants 🔥 This pattern is extremely common in interview problems! #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

When I’m solving problems on LeetCode, I usually hit a wall—not because I don't understand the logic, but because I struggle to recall the exact template or pattern for specific categories. While Binary Search is straightforward, I found myself constantly falling short on Graphs, Backtracking, and Dynamic Programming. It gets even trickier when a problem requires layering multiple patterns to get that optimized solution. To help myself, I started documenting at-a-glance patterns and templates. I realized this could help others who are stuck in the same "grind" as me, so I put everything together into a central hub called AlgoSheet. Check it out here: https://lnkd.in/gCNPzDwj It’s currently a GitHub page where I’ve compiled the most frequent patterns. It's built by a dev, for devs. If you find it useful, feel free to use it for your interview prep. I’m also totally open to suggestions or PRs if you want to help expand the pattern library! #LeetCode #CodingInterview #SoftwareEngineering #DSA #AlgoSheet

𝐋𝐚𝐧𝐠𝐂𝐡𝐚𝐢𝐧. 𝐋𝐚𝐧𝐠𝐆𝐫𝐚𝐩𝐡. 𝐂𝐫𝐞𝐰𝐀𝐈. 𝐒𝐭𝐫𝐚𝐧𝐝𝐬. 𝐖𝐞 𝐥𝐨𝐨𝐤𝐞𝐝 𝐚𝐭 𝐚𝐥𝐥 𝐨𝐟 𝐭𝐡𝐞𝐦. 𝐓𝐡𝐞𝐧 𝐰𝐞 𝐛𝐮𝐢𝐥𝐭 𝐨𝐮𝐫 𝐨𝐰𝐧. 𝐇𝐞𝐫𝐞'𝐬 𝐰𝐡𝐚𝐭 𝐭𝐡𝐚𝐭 𝐝𝐞𝐜𝐢𝐬𝐢𝐨𝐧 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐜𝐨𝐬𝐭 𝐮𝐬. Frameworks are built around assumptions. Fixed graph structures. Predefined agent roles. Specific ways to handle tool calls, memory, routing. Those assumptions work. Until your requirements don't fit them. Then you're not building a system. You're working around someone else's decisions. We had specific requirements. Multi-tenant isolation enforced at the retrieval layer. Streaming and non-streaming from the same interface. Tools that short-circuit the loop when the result is already the answer. Internal parameters the LLM never sees but the system always injects. Every framework we looked at made at least one of these harder than it needed to be. Not impossible. Just harder. And in production, harder compounds. So we built our own orchestrator. Python. AsyncIO. We wrote it. We understand every line of it. When something breaks at 2am, we know exactly where to look. That's not something you get for free with a framework. The cost? Time upfront. A few weeks of building what the framework would have given us on day one. That's it. After that, every decision was ours. Every abstraction fit what we actually needed. No workarounds. No fighting the library. I'm not saying frameworks are wrong. If you're prototyping, they're fast. If your use case fits their model, they're fine. But the moment your requirements diverge from what the framework assumed, you pay a tax on every feature after that. We decided to pay the cost upfront instead. The question worth asking before you adopt any framework: What happens when I need something it didn't design for? If the answer involves workarounds, that's the real cost. Not the learning curve. Are you using a framework in production? What trade-off did you accept? #AIEngineering #LLM #AgenticAI #ProductionAI #SoftwareArchitecture #Python #LangChain #TechLeadership #Strands #CrewAi #LangGraph #SystemDesign

Day 71 on LeetCode Find Peak Element ⛰️✅ Today’s problem introduced a Binary Search approach, but I first solved it using a brute-force traversal to build intuition. 🔹 Approach Used in My Solution (Brute Force) The goal was to find an element that is greater than its neighbors. Key idea: • Traverse the array from index 1 to n-1 • Check if current element is greater than its neighbors • Handle edge cases like last element separately • Return the index once a peak is found This approach is simple and works reliably. 🔹 Optimized Approach (Binary Search Insight) • If nums[mid] < nums[mid+1] → peak lies on the right side • Else → peak lies on the left side (including mid) • Continue narrowing until left == right ⚡ Complexity: • Brute Force: O(n) • Binary Search: O(log n) 💡 Key Takeaways: • Building intuition with brute force helps understand the problem deeply • Learned how to transition from linear scan → binary search optimization • Reinforced that multiple approaches can lead to the same result, but efficiency matters 🔥 Step by step, moving from basic logic to optimized patterns! #LeetCode #DSA #Algorithms #DataStructures #BinarySearch #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

Day 55 of 100 Days of AI — 🔄 Another Revision Day Three revision days in a row. Life gets busy. Energy runs low. Some weeks are just like this. But 55 days straight without missing a single one — that's the actual challenge. Not the big build days. The small ones where you show up anyway. Went through everything again today. The newsletter pipeline, the agent architecture, the source strategy. Keeping the mental model sharp while life settles down. Building resumes tomorrow. #100DaysOfAI #BuildInPublic #AIEngineering #Newsletter #SideProject #LangChain #Python

There is a moment every author chases: the first time you hold your book in your hands.That moment arrived for me this week. I am proud to announce the publication of: "30 Agents Every AI Engineer Must Build" https://lnkd.in/erKtdJSx This book is for engineers who are ready to move beyond prototypes and build production-ready agentic systems using proven architectures and patterns, applied across real industry verticals. What makes it different: - 30 fully worked agents, each grounded in a real-world use case - Focus on verticals, not toy examples - A well-tested GitHub repository with clean, modular code you can build on immediately - Practical patterns for orchestration, tool use, memory, and evaluation I invested a significant amount of time in the companion GitHub repository to ensure the code is tested, structured, and genuinely useful, not just illustrative. https://lnkd.in/eM99ev3F If you are building with agents or planning to, I hope this becomes a resource you return to. Thank you to everyone who supported this journey. Writing a book while working full-time is no small undertaking, and your encouragement made all the difference. #AIAgents #AgenticAI #LLMs #MachineLearning #SoftwareEngineering #PacktPublishing #Python #AIEngineering

One of the most powerful algorithmic techniques in computer science is one most developers never explicitly study. This week I implemented a backtracking algorithm from scratch in TypeScript and I finally understood why it matters so much. Backtracking is the algorithm behind: → Sudoku solvers → Chess engines → Route planning → Constraint satisfaction problems → Any problem where you need to find every valid combination or arrangement The core idea is simple but powerful: Instead of trying to calculate the answer directly, you build it piece by piece. At every step you make a choice, check if it's valid, and keep going. If you hit a dead end you undo your last choice and try a different one. You keep doing this until you've explored every possible path. It's the difference between guessing randomly and searching systematically. The problem I solved: assign unique numbers from 1 to 7 to an array of strings, where the second string can only have even numbers. Find every valid combination. Without backtracking you'd generate invalid combinations and throw them away. With backtracking you never go down an invalid path in the first place you cut it off early and move on. That's what makes it efficient. And that's what makes it elegant. Studying algorithms like this doesn't just make you better at coding challenges. It changes how you approach problems breaking them into decisions, constraints, and paths. That's the kind of thinking that separates good engineers from great ones. Here is the link to the full implementation, https://lnkd.in/eznWVSB9 #SoftwareEngineering #ComputerScience #TypeScript #Algorithms #FullStack #LearningInPublic