Day 25: Generate Valid IP Addresses with Backtracking

🗓 7 April 2026 🚀 LeetCode Problem #973 — K Closest Points to Origin Solved this problem using a Heap (Priority Queue) approach in Python. 💡 Approach: - Calculated the distance of each point from origin using: 👉 x² + y² (no need for square root) - Used a max heap (by pushing negative distance) - Maintained heap size = k - If size exceeds k → removed the farthest point ⚡ Time Complexity: O(n log k) ⚡ Space Complexity: O(k) 🔥 This is a great example of optimizing from brute force (sorting O(n log n)) to a more efficient heap-based solution. Consistency update: solving problems daily and improving problem-solving skills step by step. #leetcode #dsa #python #coding #100DaysOfCode #heaps #learning

Day 3 / 100 🚀 Solved “Reverse Integer” — a problem that looks simple but actually tests how carefully you handle edge cases. At first, reversing digits feels straightforward. But the real challenge is handling 32-bit overflow without using extra space. 💡 Key learning: Before updating the result, always check if multiplying by 10 will exceed the allowed range. Core idea: rev * 10 + digit must stay within [-2³¹, 2³¹ - 1] Highlights: • Time Complexity: O(log n) • Space Complexity: O(1) • Correctly handles negative numbers and overflow This problem reinforced a critical habit: Don’t just make the logic work — validate boundary conditions. #100DaysOfCode #LeetCode #DSA #Python #ProblemSolving #CodingInterview

60 Days of Problem Solving Challenge - Day 27 👉 Today’s Problem: Vertical Tree Traversal (Binary Tree) The goal was to print the vertical order traversal of a binary tree from the leftmost vertical line to the rightmost. 💡 Approach / Logic: Used Level Order Traversal (BFS) with a queue. Assigned each node a Horizontal Distance (HD) from the root: Root → HD = 0 Left child → HD − 1 Right child → HD + 1 Stored nodes in a hashmap/dictionary where: HD → list of node values BFS ensures nodes in the same vertical line appear in level order. Finally, sorted the horizontal distances and printed values from leftmost to rightmost column. This problem reinforced concepts of Binary Trees, BFS traversal, and mapping nodes using horizontal distance. 📈 Progress Update 🔥 Current Streak: 27 Days 🎯 Goal: 60 Days of Consistent Problem Solving #60DaysOfCode #GeeksforGeeks #DSA #BinaryTree #ProblemSolving #Python #CodingJourney #Consistency

🚀Day-7 LeetCode Problem Solved – #3 Longest Substring Without Repeating Characters Today I solved one of the most popular Sliding Window problems on LeetCode: Longest Substring Without Repeating Characters 💡 Problem Summary: Given a string, find the length of the longest substring without any repeating characters. 🔍 Approach Used: I solved this using the Sliding Window + HashSet technique. The idea is to maintain a window of unique characters using two pointers: - left → start of the window - right → end of the window - set → stores current unique characters Whenever a duplicate character appears, I move the left pointer until the duplicate is removed, while continuously tracking the maximum length. ✨ Key Learning: This problem helped me strengthen my understanding of: - Sliding Window - Two Pointers - HashSet / Set operations - Time complexity optimization ⚡ Complexity: Time: O(n) Space: O(n) Every problem solved is one step closer to mastering DSA and problem-solving skills 💻 #LeetCode #DSA #Python #ProblemSolving #CodingJourney #SoftwareDeveloper #SlidingWindow #100DaysOfCode #InterviewPreparation

Day 10/100 – DSA Challenge Today’s problem: Move Zeroes (LeetCode 283) What I Learned: The goal was to move all zeroes to the end of an array while maintaining the relative order of non-zero elements — and importantly, doing it in-place. Key Idea: Two-Pointer Technique I used a two-pointer approach: One pointer (fast) iterates through the array Another pointer (slow) tracks where the next non-zero element should go Whenever a non-zero element is found, it is swapped with the element at the slow pointer, ensuring all non-zero elements are shifted forward while zeroes naturally move to the end. Why this approach? Maintains order of elements Works in O(n) time complexity Uses O(1) extra space (in-place) Takeaway: This problem reinforced how powerful the two-pointer technique is for array manipulation problems, especially when constraints require in-place operations. Looking forward to tackling more problems and improving consistency! #Day10 #100DaysOfCode #DSA #Python #CodingJourney #LeetCode #ProblemSolving

🚀 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 16/100 – DSA Challenge Solved: Convert a Number to Hexadecimal Today’s problem was a great exercise in bit manipulation and understanding how numbers are represented at a lower level. Key Learnings: Used bitwise operations (&, >>) to extract hexadecimal digits Handled negative numbers using 32-bit two’s complement Avoided built-in conversion functions to strengthen core logic This problem reinforced how powerful bit operations can be when working with number systems. Consistency is the goal — small progress every day adds up! #DSA #LeetCode #ProblemSolving #100DaysOfCode #Python #CodingJourney #SoftwareEngineering

🚀 𝗗𝗮𝘆 𝟮𝟴/𝟯𝟬 — 𝗗𝗦𝗔 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 Day 28 and today was all about revisiting and strengthening the tougher concepts from the past few days. Instead of jumping into new topics, I focused on reinforcing dynamic programming and graph patterns — going back to problems that felt challenging and solving them again with a clearer approach. 🔎 𝗗𝗮𝘆 𝟮𝟴 𝗙𝗼𝗰𝘂𝘀 • Revisiting dynamic programming patterns • Strengthening problem-solving without relying on hints • Re-solved selected problems from recent topics It’s interesting to see how problems that felt complex earlier start to make more sense with repetition. That’s probably the biggest lesson from this challenge so far. Almost there. On to Day 29 #DSA #Python #LeetCode #SoftwareEngineering #ProblemSolving #Consistency

Used Claude Code for the first time to explore MCP (Model Context Protocol) hands-on. Built a simple app that scans any public GitHub repo using the GitHub MCP server and returns a structured breakdown of the codebase via the Claude API. From coding → testing → pushing to GitHub → posting on LinkedIn, the whole thing came together in under an hour. Not bad for a quick prototype. Tech used: Python · Streamlit · Anthropic Claude API · Model Context Protocol (MCP) · Claude Code Code: https://lnkd.in/gn5WGscf Heads up: Pointing this at large repos will burn through API tokens quickly. #AI #Claude #ClaudeCode #MCP #Python #Streamlit #OpenSource #GenerativeAI

Check out my latest project: an automated system that applies Modern Portfolio Theory with a focus on statistical "de-noising". By utilizing Principal Component Analysis, the system filters out market noise to create a more stable, theoretically efficient covariance matrix. Key Highlights: -Automated Execution: The pipeline runs weekly via GitHub Actions and executes trades through the Alpaca API. -Algorithmic De-noising: Uses Random Matrix Theory to identify significant factors. -Transparency: Automatically generates and emails a performance report with visualizations and backtesting metrics. Check out the full report and Python implementation on GitHub: https://lnkd.in/eWSyd2pi #QuantFinance #Python #AlgorithmicTrading #FinTech