Anastasios Amanatidis’ Post

🚀 Day 28 of Problem Solving Journey Today, I worked on an interesting problem: Group Anagrams 🔍 Problem Statement: Given an array of strings, group the anagrams together. Anagrams are words that have the same characters but arranged differently. 💡 Approaches I explored: ✅ Approach 1: Character Frequency Count (Optimized) Used a fixed-size array (26 letters) to count character occurrences Converted the count into a tuple to use as a dictionary key Achieved an efficient time complexity of O(n * k) ✅ Approach 2: Sorting Strings Sorted each string and used it as a key Simple and intuitive approach Time complexity: O(n * k log k) 📌 Key Learning: Understanding how hashing works with different representations (frequency vs sorted string) helps in optimizing solutions. ⚡ Takeaway: There are always multiple ways to solve a problem, but choosing the most efficient one makes a difference in real-world applications and interviews. 💻 Tech Used: Python | HashMap | Arrays #Day28 #ProblemSolving #Python #DataStructures #Algorithms #CodingJourney #100DaysOfCode

Day 43 of LeetCoding everyday until I get a J-O-B: Check If a String Contains All Binary Codes of Size K. If K = 2, the possible codes are 00, 01, 10, 11. We need to prove every combination exists inside our string. The Noob Trap: Generating all $2^k$ combinations upfront to cross them off. If K = 20, you need over a million strings. You just blew up your RAM. The Senior Fix: Math & Sliding Windows 1. The Math Filter: For a string to even physically fit all combinations, its length must be at least 2^k + K - 1. If it's shorter? Instant return False. Just like my job applications. 2. The Set: We slide a window of size K across the string, dumping every slice into a Python Set (which automatically vaporizes duplicates). 3. The Check: At the end, we check if len(seen) == (1 << k). (We use a Bitwise Left Shift because we are elite). See more: https://lnkd.in/gUki2imQ #LeetCode #Python #DataStructures #Engineering #TechHumor

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

Today's office discussion took an unexpected turn, diving deep into the nuances of loops. We began with a seemingly simple question: What’s the real difference between a for loop and a while loop? Initially, it seemed straightforward: - Use a for loop when you know how many times to iterate. - Use a while loop when you only know the condition, not the count. However, the conversation quickly evolved. We discovered that the difference goes beyond syntax; it’s about intent and control. Interestingly, despite their differences, Python allows us to make for and while loops behave similarly. For instance: - A for loop is driven by an iterator. - A while loop is driven by a condition check. You can even rewrite a for loop using a while loop by manually handling the iterator. Ultimately, it’s not about which loop is more powerful; it’s about how you approach the problem. Final insights: - For loop → cleaner and more readable when iteration is defined. - While loop → more flexible when termination is dynamic. - Under the hood, both are simply different methods of controlling flow. It's fascinating how a "beginner topic" can lead to a rich discussion about Python internals and abstraction layers. Sometimes, the simplest concepts reveal the deepest insights. #Python #Programming #SoftwareEngineering #LearningEveryday #CleanCode

Day 12/30 🔹 Problem: Print multiplication table of a number 🔹 What I focused on today: Using loops to repeat calculations efficiently 🔹 My Thinking Process: Take a number as input Use a loop from 1 to 10 Multiply the number with each value Print the result step by step 👉 Repetition becomes easy with loops 🔹 Inputs I used: A number 🔹 Code: num = int(input("Enter a number: ")) for i in range(1, 11): result = num * i print(num, "x", i, "=", result) 🔹 Example: Input: 5 Output: 5 x 1 = 5 5 x 2 = 10 5 x 3 = 15 ... 5 x 10 = 50 🔹 Key Takeaway: Loops help automate repetitive tasks, making code more efficient and scalable #Day12 #Python #30DaysOfCode #LearningInPublic #DataAnalytics #ProblemSolving

🚀 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 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

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

Another LeetCode problem down! ✅ Today I tackled Valid Anagram. The core of the problem is verifying if two strings contain identical character counts. For my solution, I leveraged Python's built-in sorted() function. The Logic: 1️⃣ Check if the lengths are equal (if not, they can't be anagrams!). 2️⃣ Sort both strings alphabetically. 3️⃣ Compare the sorted strings—if they match perfectly, return True. It’s a clean and readable approach that gets the job done. #Coding #DataStructures #Python3 #LeetCode #SoftwareEngineering

Today I worked on a classic string manipulation problem that looks simple but tests your understanding of logic and edge cases. 🔍 Problem: Given a string and a substring, count how many times the substring appears in the main string. ⚠️ The catch? 👉 You must count overlapping occurrences as well. 💡 Approach I Used: Instead of using built-in shortcuts, I applied a sliding window technique: ++Loop through the string ++Extract a substring of the same length ++Compare it with the target substring ++Increment count when matched This ensures we don’t miss overlapping patterns. 🧠 Key Learning: Sometimes, simple problems reveal powerful concepts. This one reinforces: ++String slicing ++Loop boundaries ++Sliding window logic 📌 Example: "ABCDCDC" → "CDC" appears 2 times (including overlap) 💻 Check out the visuals: 🖼️ Problem breakdown 🧑💻 Python solution 🔥 Why this matters? This pattern is widely used in: --Text processing --Pattern matching --Data parsing #Python #HackerRank #CodingPractice #DataStructures #ProblemSolving #100DaysOfCode #LearningInPublic #SoftwareEngineering