Sebastián Ramírez Montaño’s Post

I used to stare at Binary Tree problems and just... freeze. So I stopped trying to memorize solutions and started learning patterns instead. Here's what clicked for me across 5 LeetCode problems: → BFS is your go-to when you need the shortest path (Min Depth of Binary Tree) → DFS shines when you're building or exploring full paths (Path Sum) → Backtracking = DFS + undo — critical when you need ALL valid paths, not just one → One sneaky bug to watch: always store path[:] not path during backtracking, or all your saved results get mutated 🫠 These aren't just tricks — once you see the pattern, a whole category of problems opens up. Wrote up the full breakdown with each problem's approach on my blog 👇 https://lnkd.in/gVGgx-tk #LeetCode #DSA #BinaryTrees #CodingJourney #LearningInPublic

I built a grep clone in Rust. The fun part was building the regex engine from scratch: pattern -> tokens -> postfix -> Thompson-style NFA -> state-machine execution The matcher currently explores: (state, input_position) That works well for regular regex features like concat, alternation, `*`, `+`, `?`, anchors, and character classes. The next interesting step is backreferences. A pattern like: ^([a-z]+)-\1$ requires the engine to remember what group 1 captured and match that exact text again. So the runtime model becomes: (state, input_position, captures) That is where the engine stops being a pure NFA matcher and starts looking more like a backtracking VM. I like this because it mirrors what happens in many compilers and interpreters. The first version can often feel like a clean single-pass pipeline. But as the language grows, you start needing more context: captured values, symbol tables, type information, semantic checks, and multiple lowering passes. Complexity does not just add more syntax. It adds memory. Blog: https://lnkd.in/gm2y5bnc GitHub: https://lnkd.in/gmeFiy2z #Rust #SystemsProgramming #Regex #Compilers #StateMachines #OpenSource

Configuration formats have quietly become an important part of developer experience. And one format that continues to gain adoption is TOML. Why? Because it strikes a balance between: • Readability • Structure • Simplicity Consider a typical configuration stored as JSON. While JSON is excellent for APIs and data exchange, it can become difficult to maintain as configuration files grow. 👉 TOML was designed specifically for configuration. It provides: • Clear key-value syntax • Structured sections • Better human readability • Easier manual editing That's why TOML appears in many modern ecosystems, including Rust, Python tooling, package managers, and build systems. Converting JSON → TOML allows teams to move machine-oriented data into a format that's often easier for humans to manage. A practical conversion for anyone working with modern development and configuration workflows. 💡 Full guide here: 🔗 https://lnkd.in/deP8uyZm

There's a Rust attribute that's been stable since version 1.46 that almost nobody outside library authors actually uses. It should be more common. Say you're writing a function that panics on bad input. Without anything special, the panic message points inside your own crate, deep in some registry path the caller never wrote. They see an error pointing at your library's internals, not at the line in their own code that actually caused the problem. Add #[track_caller] above the function and that changes completely. The panic now reports the exact file and line in the caller's code where the bad call happened. Same panic message, completely different location, and the fix is one line above the function signature. The mechanism is how std::option::Option::unwrap and Result::expect already give you useful panic locations instead of pointing into core. You're just borrowing the same trick for your own code. One real caveat worth knowing before you reach for this: the attribute has to sit on every function in the call chain between the panic and your public API. Skip a layer and the location resets right there. It also doesn't work on closures, though it does work on async functions now. Best part is the cost. It's resolved entirely at compile time, so there's zero runtime overhead in an optimized build. Have you used track_caller before, or is this the first time you're hearing about it? #Rust #SystemsProgramming #DeveloperTips #Debugging

Learning Rust — References and Borrowing. The rule that clicked: you can lend a value with `&s` without giving up ownership. Many immutable borrows are fine simultaneously. One mutable borrow is fine. Both at the same time? The compiler blocks it — that's a data race eliminated before the code ever runs. Also built a first_word() function that returns an index into a string. It compiles, it runs — but the moment you clear the string, the index is meaningless. Rust's answer is string slices, which tie the reference to the data's lifetime. The bug simply can't ship. No garbage collector. No manual memory management. Just a compiler that forces you to think it through first. #Rust #LearningInPublic #SystemsProgramming #DaysOfCode

🎯Day 61 of #150DaysOfCode 🚀 👨💻 Platform: #LeetCode 🧠 Today’s Problem: ⚡ 61. Number of 1 Bits Given a positive integer n, write a function that returns the number of set bits in its binary representation (also known as the Hamming weight).   Example 1: Input: n = 11 Output: 3 Explanation: The input binary string 1011 has a total of three set bits. Example 2: Input: n = 128 Output: 1 Explanation: The input binary string 10000000 has a total of one set bit. Example 3: Input: n = 2147483645 Output: 30 Explanation: The input binary string 1111111111111111111111111111101 has a total of thirty set bits.   Constraints: 1 <= n <= 231 - 1

Day 64:  Create Binary Tree From Descriptions The time complexity is a mess due to overuse of unordered maps. WIll tackle this again to optimize the logic. #DailyLeetCode #LeetCodeChallenge #ProblemSolving #CodingDaily #cpp #Code2083 👾

I just hand compiled last post's hexadecimal string to decimal conversion routine. The original code in my tinyF language can be seen in 3rd pane bottom. 'compiled' code in panes 1&2. Note the exe size is 712 bytes and the footprint is between 12K and 20K not the bloated POC the compiler by itself would generate of 2Mb-20Mb footprint (these tricks are known but rarely used and that's a shame) Next up I'll write my notltoa10 in tinyF get that running in the interpreter then probably hand compile that as well see if it results in even tinier code.

🚀 Day 92 of My #100DaysOfLeetCode Challenge ✅ Solved: LeetCode 2 - Add Two Numbers Today's problem involved adding two numbers represented as linked lists, where each digit is stored in reverse order. The challenge was to simulate the addition process digit by digit while managing carry values efficiently. 💡 Key Learnings: • Strengthened my understanding of Linked Lists. • Practiced handling carry-over during arithmetic operations. • Learned how to build a new linked list dynamically. • Improved pointer manipulation and traversal skills. • Reinforced the concept of simulating real-world mathematical operations in code. 🔹 Example: Input: l1 = [2,4,3] l2 = [5,6,4] Output: [7,0,8] Explanation: 342 + 465 = 807 ⚡ Approach: Create a dummy node to simplify list construction. Traverse both linked lists simultaneously. Add corresponding digits along with any carry from the previous step. Store the current digit in a new node. Update the carry value. Continue until both lists and carry are fully processed. ⏱️ Time Complexity: O(max(N, M)) 📦 Space Complexity: O(max(N, M)) Where: • N = Length of first linked list • M = Length of second linked list This is one of the most popular Linked List interview questions and a great exercise for mastering pointer manipulation and carry handling. #LeetCode #Day92 #100DaysOfCode #CodingChallenge #Programming #Cpp #SoftwareEngineer #DataStructures #Algorithms #LinkedList #ProblemSolving #CodingJourney #TechLearning #InterviewPreparation

Day 25 of LeetCode 🚀 Solved 3559. Number of Ways to Assign Edge Weights II 🌳⚡ A challenging tree problem that combined LCA (Binary Lifting), path distance calculations, and a clever parity observation. What initially looked complex turned into a simple mathematical pattern once the right insight clicked. 💡 Sometimes the key to solving hard problems isn't more code—it's finding the hidden pattern. #Day24 #LeetCode #DailyChallenge #DSA #Algorithms #Java #BinaryLifting #Trees #ProblemSolving #CodingJourney #SoftwareEngineering #100DaysOfCode