Decode String with Stack and String Manipulation

🚀 Day 13 of My Coding Journey Today I worked on an interesting problem: 527 Valid Word Abbreviation 💡 👉 The challenge was to check whether a given abbreviation correctly represents a word. It involved handling: Character matching ✅ Skipping characters using numbers 🔢 Edge cases like leading zeros ❌ 💻 Key Logic I Used: Two pointers (i for word, j for abbreviation) If characters match → move both pointers If digit found → build number and skip characters in word If invalid case → return false ✨ Code Snippet: class Solution { public: bool validWordAbbreviation(string word, string abbr) { int i=0, j=0; while(i<word.size() && j<abbr.size()) { if(abbr[j]=='0') return false; if(word[i]==abbr[j]) { i++; j++; } else if(isalpha(abbr[j])) return false; else { int num=0; while(j<abbr.size() && isdigit(abbr[j])) { num = (num*10) + (abbr[j]-'0'); j++; } i += num; } } return i==word.size() && j==abbr.size(); } }; 🧠 What I Learned: How to efficiently parse strings with mixed characters & numbers Importance of handling edge cases like "01" ❗ Two-pointer technique is 🔥 for string problems 📌 Consistency > Perfection See you tomorrow with Day 14! 💪 #100DaysOfCode #DSA #Cpp #CodingJourney #LeetCode #ProblemSolving

🚀 Daily Coding Progress Solved a problem on LeetCode today: 🔹 Problem: Maximum Value of a String in an Array (Easy) 💻 Example 1: Input: ["alic3","bob","3","4","00000"] "alic3" → contains letters → value = 5 (length) "bob" → only letters → value = 3 "3" → only digits → value = 3 "4" → only digits → value = 4 "00000" → only digits → value = 0 ✅ Output: 5 🧠 Approach: Loop through each string in the array. Check if the string is numeric using Character.isDigit(). If numeric → value = integer value of the string. Else → value = length of the string. Track the maximum value while iterating. ⚡ Why this approach? • Time Complexity: O(n * m) – n strings of max length m ≤ 9. • Space Complexity: O(1) – only tracking max value. • Simple, efficient, and handles leading zeros perfectly. 💡 Key Learning: Checking if a string is numeric with Character.isDigit() avoids regex overhead. Handling mixed alphanumeric strings elegantly by using string length. Iterating through an array while maintaining a running maximum is a fundamental technique. Consistency pays off 🔁 Step by step, improving problem-solving skills and coding fluency. #LeetCode #DSA #CodingJourney #100DaysOfCode #SoftwareEngineering #Java #ProblemSolving

Is your code getting lost in a maze of nested `if` statements? 😵💫 There's a cleaner path to more readable and maintainable functions. We've all been there: functions riddled with deeply indented conditional logic, making it tough to follow the "happy path" and spot crucial edge cases. This "arrow code" significantly increases cognitive load and can quickly become a source of subtle bugs. One of my favorite patterns for dramatically improving readability and maintainability is using **Guard Clauses** (or Early Exits). Instead of wrapping your core logic in multiple `if` blocks, you validate conditions at the start of your function and return early if any prerequisites aren't met. This simple refactoring flattens your code, making the primary flow much clearer. It pushes error handling and invalid state checks to the forefront, allowing your main business logic to live in a clean, unindented section. It's a huge win for developer experience and often prevents subtle bugs by handling invalid states upfront. Here's a quick Python example demonstrating the power of guard clauses: ```python # Before (nested ifs) def process_order_old(order): if order: if order.is_valid(): if order.items: # Core processing logic return "Order processed successfully." else: return "Error: Order has no items." else: return "Error: Order is invalid." else: return "Error: Order is None." # After (using Guard Clauses) def process_order_new(order): if not order: return "Error: Order is None." if not order.is_valid(): return "Error: Order is invalid." if not order.items: return "Error: Order has no items." # Core processing logic (clean, unindented) return "Order processed successfully." ``` The takeaway here is simple: prioritize clear, linear code paths. Guard clauses help you achieve this, pushing error handling to the front and letting your main logic shine, boosting both productivity and code quality. What's your go-to refactoring technique for improving code readability and maintainability? Share your tips below! 👇 #Programming #CodingTips #SoftwareEngineering #Python #CleanCode #Refactoring #DeveloperExperience

🚀 50 Important Coding Questions – Question 50/50 🔹 Subsets (Power Set) | LeetCode A classic problem to master recursion + backtracking. 📌 Problem Statement Given an integer array, return all possible subsets (the power set). 💡 Approach Used (Backtracking / Recursion) I solved this using a recursive backtracking approach where: 👉 At every index, we have two choices Include the current element Exclude the current element 👉 Maintain a temporary list to build subsets 👉 When we reach the end of the array, store the current subset 🔍 How it works 👉 Traverse the array index by index 👉 For each element: First include it and move forward Then backtrack (remove it) and explore exclusion 👉 This forms a decision tree (include / exclude) ⏱ Time Complexity: O(2ⁿ) 📦 Space Complexity: O(n) (recursion stack) 📌 LeetCode Result ✔ Accepted ⚡ Runtime: 0 ms 🧠 Concepts Strengthened ✔ Backtracking fundamentals ✔ Recursion tree thinking ✔ Include–Exclude pattern ✔ State management (push & pop) 🏁 50/50 Questions Completed! 💯🔥 Consistency = Results 💪 From basics → advanced patterns 🚀 #DSA #LeetCode #Backtracking #Recursion #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

🚀 50 Important Coding Questions – Question 49/50 🔹 Power of Three | LeetCode A simple yet important problem to understand recursion and mathematical patterns. 📌 Problem Statement Given an integer n, return true if it is a power of three. Otherwise, return false. 💡 Approach Used (Recursive) I solved this using a recursive approach where: 👉 If the number is less than or equal to 0 → return false 👉 If the number becomes 1 → it is a valid power of three 👉 If the number is not divisible by 3 → return false 👉 Otherwise, recursively divide the number by 3 🔍 How it works 👉 Continuously divide the number by 3 👉 Check divisibility at every step 👉 Stop when it either becomes 1 (valid) or fails condition ⏱ Time Complexity: O(log₃ n) 📦 Space Complexity: O(log n) (recursion stack) 📌 LeetCode Result ✔ Accepted ⚡ Runtime: 0 ms 🧠 Concepts Strengthened ✔ Recursion fundamentals ✔ Mathematical reasoning ✔ Divide and reduce approach ✔ Base case handling 📍 Question 49 of 50 in my “50 Important Coding Questions” series. Only 1 question left 💯🔥 👉 Final Question coming next! #DSA #LeetCode #Recursion #Math #CodingInterview #ProblemSolving #CPlusPlus #TechJourney

Claude Code has been taking notes on me. Build commands I use, mistakes it made, my coding patterns. Type /memory, then 'Open auto-memory folder'. Plain markdown files. It's been doing this automatically. It's called auto-memory. Claude writes notes to itself when it learns something useful. Next session, it loads them and doesn't repeat the same mistakes. /memory also shows your user memory (~/.claude/CLAUDE.md) and project memory (./CLAUDE.md). You write CLAUDE.md to guide Claude. Claude writes auto-memory to guide itself. Both load at session start, both are plain markdown you can edit. /memory to see it all.

Up until now, we've given our agent tools, planning capabilities, and subagents. But there is a fatal flaw when running long tasks: 𝘁𝗵𝗲 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝘄𝗶𝗻𝗱𝗼𝘄. A single file read can easily consume 4,000 tokens. After reading 30 files and running 20 bash commands, you can easily blow past 100,000 tokens. Without a way to manage memory, the agent simply cannot work on large codebases. The solution isn't just relying on a larger context window. It requires strategic forgetting. In this post, I break down a three-layer context compression strategy that allows an agent to run infinitely without losing coherence:  • 𝗠𝗶𝗰𝗿𝗼-𝗰𝗼𝗺𝗽𝗮𝗰𝘁: A nearly free operation that runs on every turn. It silently strips out verbose, old tool results and replaces them with short placeholders.  • 𝗔𝘂𝘁𝗼-𝗰𝗼𝗺𝗽𝗮𝗰𝘁: When the agent hits a specific token threshold, it saves the full, uncompressed transcript to disk as a JSONL file for safekeeping. It then asks the LLM to summarize the entire conversation and replaces the active history with that single summary block.  • 𝗠𝗮𝗻𝘂𝗮𝗹-𝗰𝗼𝗺𝗽𝗮𝗰𝘁: A dedicated tool that allows the user to explicitly trigger a summarization when a fresh start is needed. By layering these approaches, the cheap cleanup runs constantly to keep the context tidy, while the expensive summarization only runs when absolutely necessary. Nothing is truly lost because the permanent record stays on disk, but the active memory stays lean and focused. You can read the full technical breakdown and see the Python implementation here: https://lnkd.in/gfSWfpbf #SoftwareEngineering #AIAgents #Python #LLMs #SystemArchitecture

"TypeScript advanced generics and type inference are revolutionizing code reliability. Yet, many developers struggle to harness their full potential." When was the last time you reconsidered how you use generics in TypeScript? Many of us stick to the basics but miss out on the depth they offer. Type-level programming, especially with advanced generics and inference, can lead to more robust and maintainable code. After diving deep into some real-world projects, I've seen how leveraging these features transforms codebases. For instance, applying default generic values and using conditional types together can enable a highly flexible API design. Types become self-documenting, reducing the need for extensive documentation. Consider the power of leveraging type inference in complex type transformations. I've prototyped solutions using what I call "vibe coding," allowing the flow of development to guide the typing process, resulting in efficient workflows. Here's a quick demonstration with a simple utility type using TypeScript's conditional types and inference: ```typescript type FunctionReturnTypeT = T extends

Can’t solve coding problems? You’re probably missing this Big O + Arrays + Strings foundation. Before you solve problems, you need to understand what’s happening under the hood. Let’s start simple. Arrays store data in continuous memory That’s why: • Access is fast → O(1) • Insert/Delete is slow → O(n) (because elements shift) Strings are just arrays of characters So every string problem is secretly an array problem. Now let’s talk about Big O (this is where most people get confused) Big O tells you: “How does my code behave as input grows?” Examples: • O(1) → constant (fastest) • O(n) → loop once • O(n²) → nested loops (slow) • O(log n) → very efficient Here’s the mistake most people make: They memorize Big O, but don’t see it in code. Example: for i in range(n): print(i) That’s O(n) because it runs n times. The goal is simple: Don’t just write code. Understand what it costs. Because once you understand cost, You start writing better solutions naturally. In my next post, I’ll break down the two patterns that solve most problems: → Two Pointers & → Sliding Window Trust me, this is where things start to click. Follow along #Web3 #DataStructures #Algorithms #LearnToCode #TechGrowth