Learning Sorting Algorithms & Shipping Code with FastAPI

📅 Day 12 of My DSA Journey 🚀 Today I solved a problem on finding the length of the longest subarray with a given sum using the Prefix Sum + HashMap technique. 🔢 Problem: Given an array arr = [1,2,3,1,1,1,1] and target = 3, find the length of the longest subarray whose sum equals the target. 💡 Approach: • Maintain a running sum (prefix sum) • Use a hashmap to store first occurrence of each sum • Check if (current_sum - target) exists • Calculate subarray length and track maximum 🧠 Key Learning: Storing the first occurrence of prefix sum helps in getting the longest subarray efficiently in O(n) time. ✅ Output: 3 📌 This problem improved my understanding of optimizing subarray problems using prefix sums. #DSA #Python #CodingJourney #100DaysOfCode #Learning #ProblemSolving

DSA Tip: Queue If you process tasks in random order… you’ll run into problems. Use a Queue. It follows FIFO (First In, First Out) the first item added is the first to be removed. From print jobs to request handling, queues keep systems organized and fair. Insight: Order isn’t just important, it determines how systems behave. Quick Challenge: If you enqueue A, B, C… which comes out first? Drop your answer, I’ll review the best ones. FOLLOW FOR MORE DSA TIPS & INSIGHTS #DSA #Queue #Python #CodingTips #LearnToCode

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

DSA Tip: Binary Trees (Part 1) If you're storing hierarchical data in flat lists and struggling with fast lookups… there’s a better way. Use Binary Trees. Each node connects to up to two children: left and right. No rigid structure. No long chains of data. Just organized relationships. Insight: The right structure can turn slow searches into powerful ones. Challenge: Insert these values into a tree: [5, 3, 7, 1, 4, 6, 9] Then search for 4. Drop “Done” when you complete it. Also this post has issues, let's know who first notice it. FOLLOW FOR MORE DSA TIPS & INSIGHTS #DSA #Python #BinaryTree #CodingChallenge #LearnToCode

🚀 Day 12 of Consistency | #75DaysLeetCodeChallenge 🧠 Today’s Problem : 3Sum (#15) 💡 Key Learning: This problem teaches how to efficiently find triplets using sorting + two-pointer technique, while carefully handling duplicates. ⚡ Approach: Sort the array → fix one element (i) → use two pointers (l, r) → If sum == 0 → store triplet & skip duplicates If sum < 0 → move l++ If sum > 0 → move r-- 🧠 Why this works: Reduces complexity from O(n³) → O(n²) Avoids duplicate triplets Efficient use of sorting + two pointers 🔥 Result : ✔️ Runtime: 574 ms (Beats 75.21%) 📈 Problems like this build strong intuition for tackling complex array & pattern-based questions. Consistency is compounding. Keep going. 💪 #Day12 #LeetCode #DSA #CodingJourney #100DaysOfCode #Python #TwoPointers #Consistency

𝗦𝗹𝗼𝘄 𝗽𝗼𝗶𝗻𝘁𝗲𝗿. 𝗙𝗮𝘀𝘁 𝗽𝗼𝗶𝗻𝘁𝗲𝗿. 𝗢𝗻𝗲 𝗲𝗻𝗱𝘀 𝗮𝘁 𝘁𝗵𝗲 𝗺𝗶𝗱𝗱𝗹𝗲. Today's problem: Middle of a Linked List on GFG 🟢 — an easy one, but worth understanding properly. Slow moves 1 step, fast moves 2. When fast hits the end, slow is at the middle — because fast covers exactly 2x the distance. The thing worth noting: while fast and fast.next aren't the same check. fast handles an empty list or fast landing on None mid-traversal. fast.next prevents fast.next.next from crashing when fast is on the last node. Same line, two different failure cases. ✅ 1115/1115 | First attempt | O(n) time, O(1) space Day 14 of #1000DaysOfLearning #DSA #Python #GFG #LearningInPublic

🚀 Day 9 of #100DaysOfCode Today’s problem: Valid Anagram ✅ 🔍 What I learned: How to check if two strings are anagrams Importance of sorting vs frequency counting Strengthened my understanding of strings & hashing concepts 💡 Approach: I used a simple and clean method: Sort both strings Compare them If equal → Anagram ✔️ 📊 Result: ✅ All test cases passed (54/54) ⏱️ Runtime: 19 ms 🔥 Key takeaway: Sometimes a simple solution is enough, but there’s always room to optimize using hash maps for better performance. Consistency > Perfection 💯 Let’s keep going! #LeetCode #DSA #CodingJourney #Day9 #Python #ProblemSolving

✅ Day 14 of #DSAPrep >Topic: Time Complexity & Space Complexity > Concept: Big-O Notation Today I focused on understanding how to analyze the efficiency of algorithms. Learned how time complexity represents how the execution time grows with input size, and space complexity shows how much memory an algorithm uses. Covered key complexities: O(1) → Constant Time O(log n) → Logarithmic O(n) → Linear O(n²) → Quadratic Also understood how to compare different approaches and choose the most optimal solution. > Time Complexity: Measures performance > Space Complexity: Measures memory usage #DSAPrep #Algorithms #Python #ProblemSolving #CodingJourney #BigO

🚀 Solved Today’s GeeksforGeeks POTD: Subarrays with First Element Minimum using Python 🐍 Problem: Given an integer array, count the number of subarrays where the first element is the minimum element of that subarray. Approach: Solved this problem using the Next Smaller Element technique with a stack: • For each element, found the next smaller element to its right • All subarrays starting at that index and ending before the next smaller element remain valid • Counted these ranges to compute the total number of valid subarrays efficiently This problem helped reinforce my understanding of: ✔️ Monotonic stack patterns ✔️ Next smaller element concept ✔️ Optimizing subarray problems from O(n²) to O(n) 💡 Time Complexity: O(n) 💡 Space Complexity: O(n) Consistent practice with DSA problems continues to improve my problem-solving skills and algorithmic thinking 💪 #geekstreak60 #npci #geeksforgeeks #dsa #python #algorithms #monotonicstack #codingjourney