Rearranging Linked List: Odd Even Problem on LeetCode

🔥 Day 101 of My LeetCode Journey — Problem 160: Intersection of Two Linked Lists 💡 Problem Insight: Today’s problem focused on finding the intersection node of two singly linked lists — the node where both lists converge. It’s a classic problem that challenges logical reasoning and efficiency in linked list traversal. 🧠 Concept Highlight: The elegant solution uses two pointers, one starting at each list. When a pointer reaches the end, it jumps to the start of the other list. Eventually, both pointers will meet at the intersection node (or null if no intersection exists). This approach ensures O(n + m) time and O(1) space — a beautiful use of symmetry and synchronization in data traversal. 💪 Key Takeaway: Sometimes paths may seem different, but with persistence and alignment, they converge — both in code and in life. ✨ Daily Reflection: Starting the next 100 days with the same curiosity and determination. Every linked list teaches not just connections in data, but also connections in thought. #Day101 #LeetCode #100DaysOfCode #LinkedList #TwoPointerTechnique #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #KeepCoding

🚀 Day 47 of Solving LeetCode – Slow Steps, Strong Patterns 🧩 Problem: Merge Two Sorted Lists A classic linked-list problem where you merge two already sorted lists into one sorted list. 🧠 Concepts / Techniques Used: Linked List manipulation Two-pointer technique Dummy node pattern Iterative merging logic ✨ Learning Reflection: Today’s problem reinforced how powerful the dummy node pattern is when working with linked lists. It not only simplifies edge cases but also keeps the code cleaner and easier to reason about. Every time I revisit linked list problems, I feel my confidence improving — one small win at a time. 📊 Performance Stats: 🏆 Runtime: 0 ms (Beats 100%) 💾 Memory: 17.96 MB 💡 Closing Line: Step by step, problem by problem — this journey is shaping me into a better thinker and engineer. Consistency always pays off. 🚀 🔖 Hashtags: #LeetCode #Day47 #DSA #LinkedList #100DaysOfCode #CodingJourney #SoftwareEngineering #ProblemSolving #MERN #AnkitCodes

💡 Day 78 of #100DaysOfCode 💡 🔹 Problem: Find Closest Number to Zero – LeetCode ✨ Approach: Traversed through the array while keeping track of the number closest to zero using absolute difference comparison. Handled ties by preferring the positive number — because even in code, positivity wins 😉 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — no extra space used ✅ Runtime: 3 ms (Beats 44.80%) ✅ Memory: 46.87 MB 🔑 Key Insight: Even the smallest differences matter — especially when you’re finding what’s closest to zero! ⚡ #LeetCode #100DaysOfCode #DSA #ProblemSolving #CodingChallenge #JavaProgramming #AlgorithmDesign #CodeJourney #StayPositive

🔹 Day 70 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Combination Sum III 🔑 Topic: Backtracking 🧠 Approach: We need to find all combinations of k distinct numbers (1–9) that sum to n. Here’s how I solved it 👇 Use backtracking to explore all combinations starting from 1 to 9. Add the number and move forward recursively, reducing both k (count) and n (target). Stop when k == 0 and n == 0 → valid combination found! Backtrack by removing the last number and continue exploring. ⏳ Time Complexity: O(2⁹) ≈ O(512) 💾 Space Complexity: O(k) (recursion + temp list) 📌 Example: Input: k = 3, n = 9 Output: [[1,2,6],[1,3,5],[2,3,4]] ✅ 🎯 Takeaway: This problem teaches the power of controlled recursion — when both depth and sum conditions guide the search efficiently. 💡 #LeetCode #DSA #Backtracking #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀

💻 Day 18 of My LeetCode Journey 🚀 Problem: LeetCode 2 — Add Two Numbers (Medium) 📘 Problem Overview: You are given two non-empty linked lists representing two non-negative integers. Each node in the lists contains a single digit, and the digits are stored in reverse order — meaning the 1’s place is at the head of the list. Your task is to add the two numbers and return the sum as a new linked list, also in reverse order. 💡 Key Learnings and Algorithmic Insights: 🔹 Core Concept: This problem is an excellent exercise in linked list traversal, digit-by-digit addition, and carry management, simulating manual addition in code form. 🔹 Approach: 1️⃣ Initialize a dummy node to construct the result list. 2️⃣ Use two pointers to traverse both linked lists simultaneously. 3️⃣ Maintain a carry variable to handle sums that exceed 9. 4️⃣ Continue until all digits and any remaining carry are processed. 🔹 Time Complexity: O(max(m, n)) — both lists are traversed once. 🔹 Space Complexity: O(max(m, n)) — for the resulting linked list. 🎯 Key Takeaway: This problem elegantly demonstrates how data structures can simulate real-world operations. It emphasizes careful pointer manipulation, iteration logic, and understanding of how information flows across linked nodes. Each problem in this journey reinforces the importance of clean logic, structured thinking, and consistency in learning. On to Day 19 💡 #LeetCode #Day18 #CodingChallenge #ProblemSolving #LinkedList #DSA #AlgorithmDesign #SoftwareEngineering #LearningEveryday #100DaysOfCode

💻 LeetCode Post — Day 3 of Week 2 #Learning_Of_DSA 🚀 Today’s #LeetCode_Problem_1 – Two Sum 💡 Today’s problem reminded me — simple logic can solve powerful challenges. The task? Given an array, find two numbers that add up to a target. At first glance, it looks easy — but efficiency matters when data grows big. ⚡ 🧠 Approach: Used a HashMap to store previously seen numbers and their indices. For every element, checked if (target - current) already exists in the map — if yes, we found our pair! Time complexity: O(n) — lightning-fast compared to the brute force O(n²). 💬 Takeaway: Problem-solving isn’t about memorizing patterns — it’s about thinking logically, efficiently, and scalably. Every question is another step toward writing code that thinks before it runs. 🚀 #LeetCode #DSA #LearnInPublic #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #MERNStack #CareerGrowth #TechWithPurpose

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency

🚀 Day 93 of #100DaysOfLeetCode — Minimum Operations to Convert All Elements to Zero (Leetcode 3542) Today’s problem was a fun one that really tests your understanding of array manipulation and pattern observation! 🧩 Problem: Given an array of non-negative integers, the goal is to find the minimum number of operations needed to make all elements 0. In each operation, you can select a subarray and set all occurrences of the minimum non-zero element in that subarray to 0. 💭 Example: nums = [3, 1, 2, 1] ✅ Output → 3 ⚙️ Brute Force Approach: Iterate through the array and repeatedly find the smallest non-zero number. Set all its occurrences to zero. Count operations until all elements become zero. 🔹 Time Complexity: O(n²) 🔹 Space Complexity: O(1) ⚡ Optimal Approach (Used in my Solution): Use a stack-like logic or greedy approach to count how many unique increasing non-zero elements exist in the array. Each unique segment of increasing non-zero values corresponds to one operation. 🧠 Key Idea: If the next element is larger than the previous one, it represents a new operation zone. 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(n) 🔍 Dry Run Example: Input: [0, 2] Skip zeros. 2 is non-zero → stack is empty → push it and increment operation count. ✅ Result = 1 💡 Key Learnings: Observing array patterns helps to reduce redundant operations. Always analyze monotonic properties for greedy optimization. Stack logic can simplify subarray-based operation problems. 🔥 Tech Used: C++ | Arrays | Stack | Greedy 🧠 Concepts: Array traversal, Greedy Reduction, Monotonic Stack #LeetCode #Day93 #100DaysOfCode #DSA #CodingChallenge #CPlusPlus #Algorithms #ProblemSolving #GreedyAlgorithm #LearningEveryday #TechWithAnurag #CodeNewbie #SoftwareEngineering #FAANGPrep

Title: 🔍 Day 4 of #LearningOfCode — Finding Duplicates in Code and in Mindset 💡 Body: Today’s challenge: LeetCode 287 – Find the Duplicate Number 🧠 At first, it looked like a simple array problem… but it taught me a deep lesson about optimization and focus. Here’s how I approached it 👇 ✅ Tried sorting — worked but costly (O(n log n)) ✅ Tried HashSet — faster, but used extra space (O(n)) 💬 What I learned: Finding “duplicates” in data is like finding distractions in life — once you identify them, the path becomes clearer and faster. Each optimized solution brings me closer to becoming a more efficient engineer — not just in code, but in thought. 💪 #LeetCode #ProblemSolving #DSA #LearnInPublic #SoftwareEngineering #CareerGrowth #100DaysOfCode #Motivation #CodingJourney

🌟 Day 90 of My LeetCode Journey — Problem 921: Minimum Add to Make Parentheses Valid 💡 Problem Insight: Today’s problem was about balancing parentheses — finding the minimum number of parentheses that must be added to make a given string valid. A valid string means every opening bracket '(' has a matching closing bracket ')'. 🧠 Concept Highlight: This is a stack logic and counter-based problem. Instead of actually using a stack, a simple balance counter works efficiently — increment for '(', decrement for ')', and whenever balance drops below zero, it means an extra ')' needs to be fixed. 💪 Key Takeaway: Balance in logic — like balance in life — matters. Tracking state systematically can solve even tricky-looking problems. ⚙️ Daily Reflection: Each parentheses problem builds a stronger understanding of string validation and state tracking — essential tools for real-world parsing tasks. #Day90 #LeetCode #100DaysOfCode #ProblemSolving #Stack #StringManipulation #DSA #CodingJourney #LearnByDoing #SoftwareEngineering