Largest Number from List of Non-Negative Integers

🚀 Just solved the “Valid Number” problem on LeetCode! This problem looks simple at first glance—but handling edge cases like decimals, signs, and exponents makes it a great test of attention to detail and logical thinking. ✅ Key takeaways: Careful handling of edge cases is crucial Validating input step-by-step can simplify complex parsing problems Writing clean, readable logic beats overcomplicated solutions 💡 Performance: ⚡ Runtime: 3 ms 🧠 Efficient space usage ✅ All test cases passed Problems like this remind me that consistency in practice is what builds strong problem-solving skills. On to the next one! 🔥 #LeetCode #Coding #Python #ProblemSolving #SoftwareEngineering #AIEngineerJourney link of #Solution :- https://lnkd.in/ga9b5pVb

🚀 Day 96 of #LeetCode Journey 📌 Problem: Count and Say (Medium) Today’s problem looked simple at first glance—but it quickly tested my ability to observe patterns and think recursively. 🔍 Key Idea: The sequence builds itself by describing the previous term: - Start with "1" - Then keep "reading" the digits of the last result Example progression: 1 → "1" 2 → "11" (one 1) 3 → "21" (two 1s) 4 → "1211" (one 2, one 1) 💡 What I learned: - This problem is all about pattern recognition + string manipulation - It’s essentially run-length encoding (RLE) - Breaking the problem into a helper logic made it much cleaner ⚡ Challenges faced: - Handling consecutive characters correctly - Avoiding off-by-one mistakes while traversing - Keeping the logic readable instead of overcomplicating 📈 Outcome: ✅ Accepted ⚡ Runtime: 7 ms Consistency > Motivation. Showing up every day. #Day96 #LeetCode #DSA #ProblemSolving #CodingJourney #Python #Consistency

Just solved “Second Largest Digit in a String” on LeetCode — and here’s the simple approach I followed 👇 Instead of overcomplicating it, I focused on clean thinking + Python basics: 🔹 Converted the string into a set → removes duplicates instantly 🔹 Filtered only digits using isdigit() 🔹 Stored them as integers in a list 🔹 Sorted the list → easy access to largest & second largest 🔹 Edge case check: if less than 2 digits → return -1 💡 Key takeaway: Sometimes the most optimal solution isn’t about complex algorithms — it’s about using the right built-in tools smartly. 🚀 What I’m improving with each problem: • Writing cleaner logic • Thinking in steps instead of rushing • Handling edge cases early Consistency > Complexity. #LeetCode #DSA #Python #ProblemSolving #CodingJourney #100DaysOfCode

🚀 Day 66 / 200 – Consistency is the real power 💡 Today’s challenge: **Implementing Pow(x, n)** using an optimized approach ⚡ Instead of the brute-force method, I used **Binary Exponentiation (Fast Power)** to reduce the time complexity from O(n) to O(log n). This approach efficiently handles both positive and negative powers, making the solution scalable and interview-ready. 🔹 Key Learnings: * Breaking problems into smaller subproblems improves efficiency * Handling edge cases (like negative exponents) is crucial * Optimization matters just as much as correctness 📊 Result: ✔️ 307 / 307 test cases passed ⚡ Runtime: 1 ms 🧠 Memory Efficiency: Top 2% Small improvements every day lead to big results over time. Staying consistent and sharpening problem-solving skills one challenge at a time 💪 #Day66 #100DaysOfCode #200DaysChallenge #LeetCode #Python #DSA #CodingJourney #ProblemSolving #Consistency

Day 5 of #14DaysOfPython Completed Strings (core + advanced) and consolidated everything in one place. Strings are a major part of problem solving — most questions are based on text manipulation. Concepts Covered: Indexing and slicing Traversing using loops (for, while) Built-in methods: lower(), upper(), strip(), replace() ASCII basics using ord() and chr() String immutability Concatenation and repetition Membership operators (in, not in) String comparison Advanced methods: split(), join(), find(), count() String formatting (f-strings) Escape characters Validation methods: isalpha(), isdigit(), isalnum() Problems practiced: Palindrome check Reverse a string Count vowels and consonants Remove spaces Anagram check Character frequency Remove duplicate characters First non-repeating character Key takeaway: Most string problems follow the same pattern — iterate through characters, apply conditions, and keep track of counts. Understanding this pattern makes complex problems easier to solve. Strings topic completed. Moving to next. #HackerRank #Python #ProblemSolving #CodingJourney #Developer #LearningInPublic #codegnan

Day 26 of 50 days of LeetCode The Problem: Best Time to Buy and Sell Stock. The Mistake: My initial logic used global max() and min() functions. This failed because it didn't account for time—you can't sell a stock before you've actually bought it! The Correction: I refactored the code to a single-pass approach. By tracking the min_price seen so far and updating the max_profit dynamically, I ensured the "buy" always happens before the "sell" while keeping the efficiency at O(n). #LeetCode #Python #ProblemSolving #CodingJourney #CSDesign

Most FastAPI codebases look clean at first glance. Until you try to change something. I’ve noticed a pattern — a lot of complexity doesn’t come from the problem itself, but from where the logic lives. When routes start handling more than just request/response, things get harder to reason about. Lately, I’ve been keeping one constraint: Routes should stay thin. They handle the HTTP layer. All business logic moves to services. It’s a small shift, but it changes a lot: 1) Clearer separation of concerns 2) Easier testing 3) Fewer side effects when making changes Also started appreciating dependency injection more. Not as a framework feature, but as a way to keep things decoupled and predictable. Nothing groundbreaking here. But in a time where a lot of code is being generated faster than it’s being designed, maintainability comes down to how consistently we apply these basics — not whether we know them. Curious how others approach structuring FastAPI projects at scale. #FastAPI #BackendDevelopment #CleanCode #SoftwareEngineering #Python

New blog post! Live Life on the Edge: A Layered Strategy for Testing Data Models This post is about a three-layer testing pattern for complex software systems I've landed on in python: structural coverage with Polyfactory, value-level probing with Hypothesis, cross-field invariants with icontract. Includes a practical example, an honest tradeoffs section, and a note on what schema-first design and consumer-driven contract testing solve instead. Link in comments. #Python #SoftwareTesting #SoftwareArchitecture #Pydantic #PropertyBasedTesting

🚀 Day 36 – LeetCode Journey Today’s problem: String to Integer (atoi) ✔️ Handled leading spaces and signs (+/-) ✔️ Processed numeric characters step by step ✔️ Managed overflow conditions within 32-bit integer range 💡 Key Insight: Carefully handling edge cases (like spaces, signs, and overflow) is just as important as the core logic. Small conditions can make a big difference in correctness. This problem strengthened my understanding of string parsing, edge cases, and boundary conditions. Learning to write robust and reliable code every day 💪🔥 #LeetCode #Day36 #Strings #EdgeCases #Python #ProblemSolving #CodingJourney #100DaysOfCode

📝 Why I deliberately write "boring" code: Fancy code is impressive. Boring code is reliable. What boring code looks like: ✅ Clear variable names (customer_count not cc) ✅ Small functions that do one thing ✅ Comments that explain WHY, not WHAT ✅ Consistent formatting ✅ Error handling for edge cases Who benefits? → Future me (6 months from now, I won't remember) → My teammates (they can actually read it) → Production (less surprises at 2 AM) Clever code makes you feel smart. Boring code makes you effective. Which do you prefer to maintain? #CodeQuality #Python #DataEngineering #CleanCode