Rotating a Linked List with LeetCode Problem 61

🚀 Day 37 of #100DaysOfCode Challenge 🚀 🧠 Problem: 🧩 LeetCode 282 — Expression Add Operators (Hard) This problem was all about exploring backtracking with arithmetic logic. We’re given a string of digits and need to insert +, -, or * between them to reach a target value. ⚙️ Approach Used backtracking to: -Pick every possible substring as the next number. -Try adding each operator before it (+, -, *). -Track three things: -current value → total so far -previous operand → to handle multiplication correctly -expression → the string we’re building -Also skipped invalid paths like numbers with leading zeros. 📘 Learning -Understood how to evaluate expressions on the fly without using eval(). -Learned to manage operator precedence (* before +/-) using recursion and previous operand adjustment. -Realized that some problems can’t be optimized further — they test how well you can prune and organize recursion. #100DaysOfCode #DSA #CodingChallenge #StriversSheet #ProblemSolving #TakeUForward  #Recursion #CodingInterview #ProgrammingTips #LeetCode  #Backtracking 

🔥 Day 92 of My LeetCode Journey — Problem 28: Find the Index of the First Occurrence in a String 💡 Problem Insight: Today’s problem was about finding the first occurrence of a substring (needle) inside another string (haystack). Essentially, it’s like implementing your own version of the strStr() function — a classic problem in string searching. 🧠 Concept Highlight: This challenge sharpens understanding of string traversal and pattern matching. The intuitive solution uses simple iteration and substring comparison, while the optimized approach can involve algorithms like KMP (Knuth-Morris-Pratt) for efficient searching. 💪 Key Takeaway: Sometimes, even built-in functions hide deep logic beneath simplicity — mastering these fundamentals builds confidence for more advanced string algorithms. ⚙️ Daily Reflection: Every search begins with clarity — whether in code or in life. Precision and patience always lead to the right match. #Day92 #LeetCode #100DaysOfCode #StringSearch #PatternMatching #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🚀 LeetCode Daily Challenge – Count Operations to Obtain Zero (#2169) 🧩 Problem Statement Given two integers num1 and num2, perform operations until either of them becomes 0. In one operation, if num1 >= num2, replace num1 = num1 - num2, else num2 = num2 - num1. Return the total number of operations performed. 💡 Approach : Instead of performing subtraction repeatedly (which is inefficient), we can directly calculate how many times one number can be subtracted from the other using integer division (/) and modulo (%). This idea is similar to the Euclidean Algorithm used to find the GCD of two numbers. Steps: While both num1 and num2 are not zero: Add num1 / num2 to the count (this represents how many subtractions happen at once). Update num1 = num1 % num2. Swap num1 and num2 to continue. Return the total count. ⏱️ Time Complexity: O(log(min(num1, num2))) — Each iteration reduces one of the numbers significantly (like in GCD). 💾 Space Complexity: O(1) — Constant extra space used. #LeetCode #Coding #DSA #Learning #ProblemSolving #Consistency

💡 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 97 of My LeetCode Journey — Problem 328: Odd Even Linked List 💡 Problem Insight: Today’s problem focused on rearranging a singly linked list so that all nodes at odd indices come first, followed by all even-indexed nodes — while maintaining their relative order. A great challenge to test how well you understand pointer manipulation! 🧠 Concept Highlight: The solution revolves around re-linking nodes using two pointers — one tracking odd nodes and another for even nodes. By carefully connecting them, we achieve the rearrangement in-place without extra space. It’s a smart exercise in linked list restructuring and pointer logic. 💪 Key Takeaway: Organizing efficiently — whether in data or in life — often means rearranging, not replacing. A small change in order can create big clarity. ✨ Daily Reflection: Linked lists truly train the mind to think sequentially and structurally — every link counts, just like every day of consistent learning. #Day97 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Pointers

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

Just solved LeetCode 283: Move Zeroes! Problem: Given an integer array nums, move all 0’s to the end while keeping the relative order of non-zero elements (in-place). leetcode.com +1 Approach: Used a two-pointer technique — one pointer tracks the position to place the next non-zero, the other scans the array. When we find a non-zero, swap it into the “next non-zero” position. Then fill the trailing positions with 0. AlgoMonster +1 Complexity: O(n) time, O(1) extra space. Takeaway: Even simple problems become elegant once you apply the right pattern (here: two-pointer in-place). https://lnkd.in/gJif99sG #coding #leetcode #interviewprep #arrays

🔥 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 74 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Next Greater Element II 🔑 Topic: Stack + Circular Array 🧠 Approach: We need to find the next greater element for each item in a circular array. Here’s the logic 👇 Use a monotonic stack to store indices of elements (in decreasing order). Traverse the array twice (2 × n) to simulate circular behavior. Whenever the current element is greater than the element at the stack’s top, pop it and record the next greater value. Push the index during the first pass only. Default all elements to -1 (in case no greater element exists). ⏳ Time Complexity: O(n) 💾 Space Complexity: O(n) 📌 Example: Input: nums = [1,2,1] Output: [2, -1, 2] ✅ 🎯 Takeaway: Monotonic stacks are super efficient for "next greater" problems — linear time, no brute force, and elegant logic! ⚡ #LeetCode #DSA #Stack #MonotonicStack #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀

I recently tackled LeetCode 2654 – Minimum Number of Operations to Make All Array Elements Equal to 1. Most solutions simulate every operation. The approach that worked for me came from stepping back and thinking mathematically: 1️⃣ If there’s already a 1 in the array, it can be spread to all other elements efficiently. 2️⃣ If no 1 exists, find the shortest subarray whose GCD is 1 – creating a 1 from that subarray is the minimal first step. 3️⃣ Once a 1 exists, the rest follows in a straightforward way. It’s a reminder that sometimes understanding the structure of a problem beats brute-force coding. And here’s a little validation: ✅ Runtime: 1ms, beats 100% of submissions ✅ Memory: 56.1MB, beats 100% of submissions For anyone doing coding challenges or preparing for interviews, focus on insights like these – they often save more time than writing extra lines of code. #ProblemSolving #Algorithms #CodingMindset #LeetCode #SoftwareEngineering