Day 16 DSA Journey: Pointer Manipulation and Recursion in Linked Lists

🚀 Day 16/100 – DSA Journey Today’s problem was a great exercise in pointer manipulation and recursion thinking 🔗 🔹 Problem Solved: 1. Swap Nodes in Pairs 💡 Key Learnings: 👉 Approach 1: Iterative (Pointer Manipulation) Use a dummy node to simplify edge cases Swap nodes in pairs by adjusting pointers Move pointers step by step 👉 Key Insight: Careful pointer updates are crucial — one wrong link breaks the list 👉 Approach 2: Recursive Swap first two nodes Recursively solve for the rest of the list 👉 Core Idea: Break problem into smaller subproblems ✅ O(n) Time ✅ O(1) Space (Iterative) ⚠️ Recursive uses call stack → O(n) space 🔥 What I learned today: Same problem, two different mindsets: Iterative → control everything step-by-step Recursive → trust the function to handle smaller parts Both are powerful — knowing when to use which is key 👀 Day 16 done ✅ Consistency continues! 💬 Quick question: Which approach do you prefer for Linked Lists — Iterative or Recursive? #100DaysOfDSA #buildinpublic #developersoflinkedin #codinginpublic #leetcodejourney #softwareengineerlife #frontenddeveloper #dailylearning #codingpractice #devcommunity #programminglife #techcareers #jobready #growthmindset

🚀 Day 15/100 – DSA Journey Today was all about restructuring Linked Lists efficiently and thinking in terms of pointer movement 🔗 🔹 Problems Solved: 1. Rotate List 2. Merge Two Sorted Lists 💡 Key Learnings: 👉 Problem 1: Rotate List First, calculate the length of the list Optimize rotations using: k % length Use two pointers (fast & slow) to find new head 👉 Key Insight: Instead of rotating one by one, directly find the breaking point ✅ O(n) Time ✅ O(1) Space 👉 Problem 2: Merge Two Sorted Lists Used dummy node technique for clean implementation Compare nodes and attach smaller one 👉 Key Insight: Avoid extra space by reusing existing nodes ✅ O(n + m) Time ✅ O(1) Space 🔥 What I learned today: Most Linked List problems become easier when you: - Use dummy nodes - Think in terms of breaking & reconnecting links Also realized how small optimizations (like k % n) can save a lot of work 👀 Day 15 done ✅ Staying consistent! #100DaysOfDSA #buildinpublic #developersoflinkedin #codinginpublic #leetcodejourney #softwareengineerlife #frontenddeveloper #dailylearning #codingpractice #devcommunity #programminglife #techcareers #jobready #growthmindset

🚀 Day 36 of solving DSA problems ✅ Problem Solved: Combination Sum Today I solved a powerful backtracking problem where the goal is to find all unique combinations of numbers that sum up to a target. 💡 What I learned: Backtracking is all about decision making with recursion The same element can be used multiple times At every step, we have two choices: Include the current element Skip it and move to the next ⚡ Key Insight: 👉 If we call recursion with the same index, we can reuse the same element multiple times 👉 If we move to the next index, we explore new elements 🧠 Approach: Use a recursive backtracking function Base cases: target == 0 → valid combination found target < 0 → stop (invalid path) At each step: pick the element backtrack skip and move forward ⏱ Complexity: Time: Exponential (Backtracking) Space: O(target) 💻 Result: ✅ Accepted ⚡ Runtime: 1 ms 🔥 Beats: 100% Consistency is the real power. Step by step, improving every day 💪 #Day36 #DSA #Backtracking #LeetCode #CodingJourney #CSharp #ProblemSolving #DeveloperJourney 🚀

🚀 Day 15/100 – DSA Journey Today was all about restructuring Linked Lists efficiently and thinking in terms of pointer movement 🔗 🔹 Problems Solved: 1. Rotate List 2. Merge Two Sorted Lists 💡 Key Learnings: 👉 Problem 1: Rotate List First, calculate the length of the list Optimize rotations using: k % length Use two pointers (fast & slow) to find new head 👉 Key Insight: Instead of rotating one by one, directly find the breaking point ✅ O(n) Time ✅ O(1) Space 👉 Problem 2: Merge Two Sorted Lists Used dummy node technique for clean implementation Compare nodes and attach smaller one 👉 Key Insight: Avoid extra space by reusing existing nodes ✅ O(n + m) Time ✅ O(1) Space 🔥 What I learned today: Most Linked List problems become easier when you: - Use dummy nodes - Think in terms of breaking & reconnecting links Also realized how small optimizations (like k % n) can save a lot of work 👀 Day 15 done ✅ Staying consistent! #100DaysOfDSA #buildinpublic #developersoflinkedin #codinginpublic #leetcodejourney #softwareengineerlife #dailylearning #codingpractice #devcommunity #programminglife #techcareers #jobready #growthmindset

🚀 Day 19/100 – DSA Journey Today’s focus was on string manipulation and pattern-based thinking 🔤 These problems looked simple but required careful handling of conditions 👀 🔹 Problems Solved: 1. Split a String in Balanced Strings 2. Reverse String II 💡 Key Learnings: 👉 Problem 1: Split Balanced Strings Traverse string and keep a counter Increment for 'L', decrement for 'R' (or vice versa) Whenever count becomes 0 → one balanced substring found 👉 Key Insight: Balance tracking helps split efficiently ✅ O(n) Time ✅ O(1) Space 👉 Problem 2: Reverse String II Process string in chunks of size 2k Reverse first k characters, leave next k as it is 👉 Key Insight: Careful boundary handling is crucial (edge cases matter!) ✅ O(n) Time ✅ O(1) Space (in-place logic conceptually) 🔥 What I learned today: Many string problems are about identifying the right pattern (counting / chunking) rather than complex logic. Small mistakes in conditions can break the entire solution — attention to detail is everything 👀 Day 19 done ✅ Consistency continues! 💬 Quick question: Which do you find trickier — handling edge cases or finding the right pattern? #100DaysOfDSA #buildinpublic #developersoflinkedin #codinginpublic #leetcodejourney #softwareengineerlife #frontenddeveloper #dailylearning #codingpractice #devcommunity #programminglife #techcareers #jobready #growthmindset

🚀 Day 37 of My DSA Journey 🔍 LeetCode Problem #73 – Set Matrix Zeroes Today’s problem was a great exercise in optimizing space while working with matrices. At first, the straightforward solution is to use extra space to track rows and columns that need to be set to zero. But the real challenge was to solve it in-place with constant space. 💡 Key Learning: We can use the first row and first column of the matrix itself as markers to keep track of which rows and columns need to be updated. This avoids using additional memory and keeps the solution efficient. ⚡ Insight: Handling the first row and first column separately is crucial to avoid overwriting important information during the process. 📌 Takeaway: Optimization is not always about reducing time complexity — sometimes it’s about using space more intelligently. Consistency continues — Day 37 💪 #Day37 #LeetCode #DSA #Matrix #ProblemSolving #CodingJourney #Consistency

I thought rotating an array k times was easy… until my code broke for k = 2. While learning basic DSA concepts on arrays from takeUforward articles, I came across a problem on rotating an array k times. At first glance, it felt simple. “Why not just use the modulus operator like we do for a single left rotation?” Confident with this thought, I decided to implement it my own way and started coding. But then reality hit. The code gave a wrong answer. Since I didn’t have TakeUforward premium access 😅 to run it multiple times or submit it, I moved to VS Code and started debugging it myself. And that’s where things got interesting… It worked perfectly for k = 1 ✅ It failed for k = 2 ❌ Now curiosity kicked in. I started testing more cases, observing patterns, and digging deeper into what was actually happening behind the scenes. And then I found something unexpected: 👉 For even-sized arrays and k = 2, my approach was only rotating the even indices. That moment changed everything. What looked like a small extension of a simple idea turned out to have a subtle flaw. It wasn’t about the modulus operator being wrong — it was about how I was applying the logic. 💡 Biggest takeaway: In DSA, understanding the movement of data is far more important than just applying formulas or tricks. Sometimes, struggling with your own bug teaches you more than directly reading the solution ever could. #DSA #LearningInPublic #CodingJourney #ProblemSolving #Arrays #Debugging #TakeUforward

💡 “In DSA, the smartest solutions often come from transforming the problem into something you already know.” 🚀 #geekstreak60 — Day 46 Day 46 of the streak! Today’s problem was a perfect example of how problem transformation can turn a tricky question into a familiar one. 📌 Problem Statement Given an array, we can assign + or - before each element and form an expression. Goal: ➡️ Count the number of ways to reach a given target sum 🧠 My Thought Process At first, this looked like a brute-force recursion problem: 👉 Try all combinations of + and - → exponential complexity (2ⁿ) But then came the key transformation: Let: S1 = sum of elements with + S2 = sum of elements with - We know: S1 - S2 = target S1 + S2 = totalSum Solving: 👉 S1 = (totalSum + target) / 2 🛠️ Optimized Approach The problem reduces to: ✅ Count number of subsets with sum = S1 Applied Dynamic Programming (subset sum counting) to efficiently compute the answer. ⚡ Complexity Analysis Time Complexity: O(n × sum) Space Complexity: O(sum) Efficient for given constraints. 💡 Key Learning Transforming a problem is often more powerful than solving it directly. Today strengthened my understanding of: ✅ Problem transformation techniques ✅ Subset sum DP ✅ Counting-based dynamic programming ✅ Optimizing exponential problems Consistency continues strong 💪🔥 #geekstreak60 #npci #DSA #CPP #DynamicProgramming #ProblemSolving #CodingJourney #ContinuousLearning

🚀 Day 21/100 – DSA Journey Today’s problems were all about string comparison and pattern matching 🔤 At first they looked straightforward… but handling all cases cleanly was the real challenge 👀 🔹 Problems Solved: 1. Valid Anagram 2. Longest Common Prefix 💡 Key Learnings: 👉 Problem 1: Valid Anagram Compare character frequencies of both strings If every character count matches → strings are anagrams 👉 Key Insight: Frequency counting using Map/Object makes comparison efficient ✅ O(n) Time ✅ O(1) Space (fixed alphabet size) 👉 Problem 2: Longest Common Prefix Start with the first word as prefix Compare it with remaining strings Reduce prefix until all strings match 👉 Key Insight: Gradually shrinking the prefix is simpler than generating all prefixes ✅ O(n * m) Time (m = prefix length) ✅ O(1) Extra Space 🔥 What I learned today: String problems are less about complicated algorithms and more about: choosing the right approach handling edge cases carefully writing clean logic Small optimizations and cleaner thinking are becoming more natural now ⚡ Day 21 done ✅ Still showing up every day! 💬 Quick question: Which do you prefer solving more: 🔹 String problems 🔹 Linked List problems 🔹 Array problems #100DaysOfDSA #buildinpublic #developersoflinkedin #codinginpublic #leetcodejourney #softwareengineerlife #frontenddeveloper #dailylearning #codingpractice #devcommunity #programminglife #techcareers #jobready #growthmindset

🚀 Day 16 of DSA — Pattern-wise Practice Today I tackled a classic Sliding Window problem: 🔹 Longest Subarray with Ones After Replacement Under the amazing guidance of @Pratyush Bhaiya, I'm following a structured, pattern-wise approach — and it's making all the difference! 💡 ───────────────────────────── 🧩 Problem: Given a binary array and an integer k, find the length of the longest subarray containing only 1s — after replacing at most k zeros with ones. ───────────────────────────── 💡 Approach (Sliding Window): 1️⃣ Use two pointers — left and right — to maintain a window. 2️⃣ Expand the window by moving right and keep a count of zeros inside the window. 3️⃣ If zeros > k, shrink the window from the left until zeros ≤ k. 4️⃣ At each step, track the maximum window size → that's your answer! ⏱ Time Complexity: O(n) — single pass 📦 Space Complexity: O(1) — no extra space ───────────────────────────── 🔑 Key Insight: The window always holds at most k zeros. The trick is — instead of counting 1s, we count zeros and control the window based on that! ───────────────────────────── The pattern-wise approach is 🔥. Once you understand the template, similar problems become much easier to solve! Grateful for the structured learning under Pratyush Narain Bhaiya 🙌 Keep solving, keep growing! 💪 #DSA #SlidingWindow #CodingJourney #Day16 #LeetCode #100DaysOfCode #DataStructures #Algorithms #CompetitiveProgramming