Python Scenario-Based Programs for Real-World Decision Making

Python Automation & Utilities:- I built small but powerful Python utilities — one for automatic file organization and another for converting CSV data into dictionaries. I created them to practice automation and data handling, and to reduce repetitive manual work that often slows us down. At a high level, the file organizer scans a directory and moves files into categorized folders, while the CSV utility reads rows from a CSV file and maps them into key-value pairs for easier processing. Through these projects, I learned how Python’s standard libraries like os, shutil, and csv can simplify everyday tasks and how automation can save significant time in real workflows. Automatic File Organization Links:- https://lnkd.in/g-yDHwi7 CSV to Dict:- https://lnkd.in/gRiPJv2y https://lnkd.in/gbXHmMQN

🚀 Day 303 of solving 365 medium questions on LeetCode! 🔥 Today’s challenge: “532. K-diff Pairs in an Array” ✅ Problem: Given an array of integers and an integer k, return the number of unique pairs where the absolute difference between the two numbers is exactly k. ✅ Approach (Hash Map / Frequency Counter) Instead of a slow double loop, we can use a Hash Map (Python's Counter) to solve this in linear time. Count Frequencies: First, tally up how many times each number appears in the array. Handle k = 0: If the target difference is 0, we just need to find numbers that appear at least twice. I looped through the map and counted elements with a frequency > 1. Handle k > 0: For a non-zero difference, iterate through the unique numbers in the map. For each number x, simply check if x + k exists in the map. If it does, increment the count! ✅ Key Insight By using a map of unique numbers and only checking for x + k (looking "up" the number line), we naturally handle the absolute value requirement and completely prevent double-counting pairs like (1, 3) and (3, 1). The uniqueness is guaranteed without ever needing to store the results in a Set! ✅ Complexity Time: O(N) — One pass to build the frequency map, and at most one pass through its unique keys. Lookups are O(1). Space: O(N) — To store the frequency map. 🔍 Python solution attached! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #Arrays #HashMap #Python #ProblemSolving #DSA #Coding #SoftwareEngineering

Everyone learns stacks. But very few understand where they actually matter. Take a simple problem: Checking if brackets are balanced. Most people think it’s about counting. It’s not. It’s about order. Here’s what really happens behind the scenes: → You scan the expression left to right → Every opening bracket goes into a stack → Every closing bracket tries to match the last opening one If it matches → remove it If it doesn’t → the entire structure breaks That’s the moment you realize: Stacks aren’t just data structures. They are decision systems. They enforce rules like: Last In → First Out And that’s exactly how: • Code editors validate syntax • Compilers detect errors • Browsers manage navigation history A simple example: [(a+b)] → Valid ✔ [(a+b] → Invalid ❌ Same characters. Different structure. That’s the difference between working code and broken logic. The lesson? In programming — and in systems — structure beats quantity. Always. #DataStructures #Python #ProblemSolving #CodingJourney #AIThinking

🚀 Day 311 of solving 365 medium questions on LeetCode! 🔥 Today’s challenge: “946. Validate Stack Sequences” ✅ Problem: Given two integer arrays with distinct values, pushed and popped, return true if they represent a valid sequence of push and pop operations on an initially empty stack. ✅ Approach (Greedy Simulation) The best way to know if a sequence works is to just try it! Simulate: Create an actual stack array and a pointer i to track our position in the popped array. Push & Check: Loop through the pushed array, adding each number to our simulated stack. Pop Greedily: Immediately after pushing, use a while loop to check if the top of the stack matches the current target in popped[i]. If it does, pop it off and move our target pointer forward (i += 1). Keep popping as long as the top continues to match! Result: If the input sequences are valid, every pushed element will eventually be matched and popped, leaving us with an empty stack (len(stack) == 0). ✅ Key Insight Don't overthink with complex math or permutations! The rules of a stack make this strictly deterministic. If the top of your stack matches the next required popped value, you must pop it right then and there. By greedily executing the only logical move at every step, the simulation perfectly validates the sequence in a single pass. ✅ Complexity Time: O(N) — Where N is the length of the arrays. Even with the inner while loop, every element is pushed exactly once and popped at most once, making it linear time. Space: O(N) — We use an extra array to act as our simulated stack. 🔍 Python solution attached! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #Stack #Simulation #Python #ProblemSolving #DSA #Coding #SoftwareEngineering

Mini Project | N-Queens Game & Algorithm Visualizer Developed an interactive N-Queens solver and game using Python (Tkinter) to visualize backtracking and constraint satisfaction. Implemented recursive backtracking with diagonal & column checks Built non-blocking animated visualization using Tkinter’s event loop Used efficient 1D board representation and clean OOP structure 🔗 GitHub: https://lnkd.in/d3nZgByM #Python #Algorithms #Backtracking #Tkinter #MiniProject #ComputerScience

🚀 Day 308 of solving 365 medium questions on LeetCode! 🔥 Today’s challenge: “503. Next Greater Element II” ✅ Problem: Given a circular integer array (the element after the last element is the first element), return the next strictly greater number for every element. If it doesn't exist, return -1. ✅ Approach (Monotonic Stack + Loop Twice) A brute-force double loop would be O(N^2). We can optimize this to linear time using a Monotonic Stack! The Stack: Use a stack to store the indices of numbers that are still "waiting" to find their next greater element. The Circular Trick: Instead of messy modulo arithmetic (i % n), just loop through the array exactly twice. This naturally simulates the circular wrap-around! The Logic: As we iterate, we compare the current number to the number at the index on top of the stack. If the current number is bigger, we've found the "next greater" for that stack element! Pop it off, update our result array, and repeat. Then, push the current index onto the stack. ✅ Key Insight Monotonic Stacks are the ultimate cheat code for "next greater/smaller" problems. By keeping the stack strictly decreasing, we instantly know when we've hit a "peak" that resolves the waiting elements. Combining this with the "loop twice" trick makes handling the circular property completely effortless. ✅ Complexity Time: O(N) — Even though there are nested while loops, each index is pushed and popped from the stack at most once across the two passes. Space: O(N) — To store the stack and the result array. 🔍 Python solution attached! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #Stack #MonotonicStack #Arrays #Python #ProblemSolving #DSA #Coding #SoftwareEngineering

I’ve just finished building a FastAPI-powered portfolio application with dynamic tag-based search and full CI test automation. The app allows artworks to be filtered by tags using a graph-style relationship model, making search intuitive and scalable as new content is added. Images are processed using Pillow, and the backend is fully asynchronous for performance and clarity. To ensure reliability, I implemented a comprehensive pytest suite with enforced coverage thresholds, and configured GitHub Actions to automatically run tests on every push and pull request. This project was a great exercise in combining clean API design, async database patterns, automated testing, and CI/CD discipline — all in a production-style setup. Below is a short demo showing the tag search in action 👇 The artworks are my own. It is good to combine a technical education with an arts education, especially when designing user interfaces. And I keep ferrets! Source code: https://lnkd.in/ekKTnEQH #FastAPI #Python #GraphSearch #Pillow #Pytest #GitHubActions #SQLAlchemy #AsyncPython #BackendDevelopment #CI #SoftwareEngineering

Day 48 of Solved: 696. Count Binary Substrings on LeetCode Today’s challenge was a perfect reminder that great solutions come from great observations, not longer code. 💡 Problem Insight We need to count substrings that: ✔ Contain equal number of 0’s and 1’s ✔ Have all 0’s together and all 1’s together At first glance, the brute-force approach (checking all substrings) looks tempting… but that leads to O(n²) ⛔ — not scalable for large inputs. ⚡ Optimization Thought Process Instead of generating every substring: ✨ Count consecutive groups of 0’s and 1’s ✨ Compare adjacent groups ✨ Add min(previous_group, current_group) This transforms the solution into: 🚀 Time Complexity → O(n) 🚀 Space Complexity → O(1) Efficient, clean, and interview-ready. 🧠 What I learned today 🔹 How powerful pattern recognition is in DSA 🔹 Converting brute force → optimal approach 🔹 Writing logic that works for large constraints 🔹 Importance of dry running on examples 🔹 Thinking in terms of groups instead of substrings #Day48 LeetCode #DSA DataStructure Technologies #CodingChallenge PROBLEMSOLVING Python CodeEveryDay LearnInPublic

🚀 Day 307 of solving 365 medium questions on LeetCode! 🔥 Today’s challenge: “3766. Minimum Operations to Make Binary Palindrome” ✅ Problem: You are given an array of integers. You can increment or decrement any number by 1. Find the minimum number of operations required to turn each number into a "binary palindrome" (a number whose binary representation, without leading zeros, reads the same forwards and backwards). ✅ Approach (Precomputation + Binary Search) Instead of checking numbers one by one to see if they are binary palindromes, we can pre-build the answers! Precompute: I looped through a fixed range (up to 5000) to generate and store all valid binary palindromes in a sorted list. Binary Search: For each number in the input array, I used bisect_right to quickly find its position within our precomputed list. Compare: This gives us the closest binary palindrome above the number and the closest one below it. Just calculate the absolute difference for both and pick the smaller one! ✅ Key Insight Precomputing the search space is a massive time-saver! Because binary palindromes are actually quite sparse, building a lookup array once prevents us from constantly doing expensive string conversions and reverse-checks inside the main loop. Combined with Binary Search, finding the nearest neighbor becomes blazing fast. ✅ Complexity Time: O(N log P) — Where N is the length of the array and P is the number of precomputed palindromes. Binary search takes log P time for each element. Space: O(P) — To store our lookup array of binary palindromes. 🔍 Python solution attached! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #BinarySearch #Precomputation #Python #ProblemSolving #DSA #Coding #SoftwareEngineering