Day 9: Strengthening Two-Pointer Logic in DSA

🚀 𝗗𝗮𝘆 𝟮𝟯/𝟯𝟬 — 𝗗𝗦𝗔 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 Day 23 and continuing deeper into graph problems. The interesting part about graphs is how many real-world systems they represent — networks, dependencies, routes, and connections. Problems start to feel more like exploring a map than just working through a list. Today’s focus was on using traversal techniques to explore nodes and understand relationships between them. 🔎 𝗗𝗮𝘆 𝟮𝟯 𝗙𝗼𝗰𝘂𝘀 • Strengthening DFS and BFS traversal • Understanding how to track visited nodes • Solved: ✅ Clone Graph ✅ Course Schedule ✅ Rotting Oranges Graph problems definitely require careful thinking, but it’s satisfying when the traversal logic finally clicks. On to Day 24 #DSA #Python #LeetCode #Consistency #SoftwareEngineering #ProblemSolving

feb-21-26 LeetCode 762 – Prime Number of Set Bits in Binary Representation Solved today’s problem focused on bit manipulation and prime checking! 🔹 Problem: Given two integers left and right, count how many numbers in that range have a prime number of set bits (1s) in their binary representation. 💡 Approach: Iterate through each number in the range. Count set bits using bitwise operations (& and right shift). Check whether the count of set bits is a prime number. Keep track of valid cases. 🧠 Concepts Used: Bit Manipulation Prime Number Checking Mathematical Optimization Simple problem on the surface, but a great way to strengthen understanding of binary representation and efficient computation. Consistency + Daily Practice = Growth 📈🔥 #LeetCode #BitManipulation #PrimeNumbers #Python #CodingPractice #ProblemSolving

𝗦𝗹𝗼𝘄 𝗽𝗼𝗶𝗻𝘁𝗲𝗿. 𝗙𝗮𝘀𝘁 𝗽𝗼𝗶𝗻𝘁𝗲𝗿. 𝗢𝗻𝗲 𝗲𝗻𝗱𝘀 𝗮𝘁 𝘁𝗵𝗲 𝗺𝗶𝗱𝗱𝗹𝗲. 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 10 already — and this journey is starting to feel less about solving individual problems and more about recognizing patterns and choosing the right approach faster. Today’s focus was on sliding window techniques — understanding how adjusting a window dynamically can help track subarrays or substrings efficiently without rechecking everything from scratch. 🔎 𝗗𝗮𝘆 𝟭𝟬 𝗙𝗼𝗰𝘂𝘀 • Learning sliding window logic • Practicing dynamic range tracking • Solved: ✅ Maximum Average Subarray I ✅ Longest Substring Without Repeating Characters ✅ Permutation in String Still learning, still improving — one problem at a time. On to Day 11 💪 #DSA #Python #LeetCode #LearningInPublic #Consistency #SoftwareEngineering #ProblemSolving

🐍 Your Date Column isn't a Date It just looks like one. 2026-01-15 stored as a string will pass every visual check — and silently break every time-based analysis you run. Ask these before you trust a date column: ✅ What dtype is it actually? ✅ How was it parsed? → Is 01/02/2026 January 2nd or February 1st? ✅ What timezone is it in? → UTC? Local server time? → Two timestamps can look identical and be 5 hours apart. ✅ What does a missing date mean? → Event didn't happen? Wasn't recorded? Pipeline failed? 👉 Always validate with two lines of code — it can save hours of debugging. What's the messiest date column you've encountered? 👇 #DataAnalytics #Python #AnalyticsThinking

🚀 Day 55 of #100DaysOfCode Solved LeetCode 350 – Intersection of Two Arrays II today! 🔍 Problem Insight: Given two arrays, we need to return their intersection such that each element appears as many times as it occurs in both arrays. 💡 Approach Used: - Used "Counter" (hash map) to store frequency of elements from first array - Traversed second array and matched elements - Reduced count after every match to handle duplicates correctly ⚡ Why this works: Efficient frequency tracking avoids nested loops and reduces time complexity. 🧠 Complexity: - Time: O(n + m) - Space: O(n) ✅ Key Learning: Hashing + frequency counting is powerful for problems involving duplicates and intersections. 🔥 Consistency is the key — showing up every day! #DSA #LeetCode #Python #CodingJourney #PlacementPrep #SoftwareEngineering #100DaysOfCode

🚀 𝗗𝗮𝘆 𝟭𝟭/𝟯𝟬 — 𝗗𝗦𝗔 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 Day 11 of the journey, and sliding window problems are starting to make a lot more sense. What initially felt like tricky boundary management is slowly turning into a pattern I can recognize much faster. Today was about refining that approach — learning when to expand a window, when to shrink it, and how to track values efficiently while moving through an array or string. 🔎 𝗗𝗮𝘆 𝟭𝟭 𝗙𝗼𝗰𝘂𝘀 • Strengthening sliding window logic • Managing dynamic window sizes • Solved: ✅ Minimum Size Subarray Sum ✅ Longest Repeating Character Replacement ✅ Find All Anagrams in a String Still plenty to learn, but every day the patterns feel a bit more familiar — and that’s a good sign. On to Day 12 💪 #DSA #Python #LeetCode #LearningInPublic #Consistency #SoftwareEngineering #ProblemSolving

🔥 Day 30 of #100DaysOfCode 📌 LeetCode 26 – Remove Duplicates from Sorted Array Today’s problem focused on in-place array manipulation and strengthening the two-pointer technique. 🧠 Problem Summary Given a sorted array, remove duplicates such that each unique element appears only once. Return the count of unique elements (k). Important: Do it in-place with O(1) extra space. 💡 Key Insight Because the array is already sorted, duplicates are always adjacent. So instead of checking all elements repeatedly: 👉 Compare current element with previous one. 👉 If different → place it at the next unique index. This is where the Two Pointer Approach shines: Pointer i → traverses array Pointer k → tracks position of next unique element 📊 Complexity ⏱ Time: O(n) 📦 Space: O(1) Consistency > Motivation 30 Days Done. Still going strong 💪 #Day30 #LeetCode #DSA #100DaysOfCode #Python #CodingJourney

🔥 Day 98 — #100DaysOfLeetCode ✅ Problem: Special Binary String (Hard) Today’s problem focused on special binary strings — strings where: • Number of 1s = number of 0s • Every prefix has ≥ as many 1s as 0s 🎯 Goal: Find the lexicographically largest string obtainable by swapping adjacent special substrings. 🧠 Approach: Use a counter to split the string into valid special segments. Recursively process inner substrings. Sort segments in descending order. Join them back together. ⚡ Example Input: "11011000" Output: "11100100" ⏱ Complexity Time: O(n log n) Space: O(n) 💡 Key Insight: Each valid segment behaves like a balanced block → reorder blocks for maximum lexicographic value. Hard problem ✔️ Confidence +1 🚀 #LeetCode #DSA #CodingJourney #HardProblems #Python

✨ Day 8 of #GeekStreak60 Today’s Problem of the Day focused on determining whether two strings are Isomorphic. 🔍 Problem Statement Given two strings s1 and s2 of equal length, check whether they are isomorphic. Two strings are isomorphic if: • Each character in s1 maps to exactly one character in s2 • The mapping is consistent and preserves order • No two characters in s1 map to the same character in s2 💡 Approach ✔️ Compared the pattern of first occurrences in both strings ✔️ Used list comprehension with index() to capture structural patterns ✔️ Verified if both patterns match — ensuring isomorphism 🚀 Key Insight Instead of directly mapping characters, comparing structural patterns simplifies the solution and keeps the code clean and efficient. 🎯 Outcome Clean logic ➝ Minimal code ➝ Maximum clarity 📈 Progress Update Day 8 completed successfully! Consistency is the key to building strong problem-solving skills 💪 #GeeksforGeeks #GeekStreak60 #Day8 #ProblemSolving #Python #CodingJourney #NPCI