Counting Key Occurrences in a Linked List

Day 2 | DSA + LeetCode Practice 🚀 Continuing my #100DaysOfCode journey by focusing on problem-solving and strengthening fundamentals. ✅ Problems Solved Today: Leetcode #3 Longest Substring Without Repeating Characters 🔹 Approach: Sliding Window + Hash Set 🔹 Logic: • Used two pointers to maintain a dynamic window • Stored characters in a set to track duplicates • When a duplicate appeared, moved the left pointer and adjusted the window • Tracked the maximum window length at each step 📌 Key Learning: The sliding window technique helps optimize brute-force solutions to O(n) time complexity. Leetcode #4 Median of Two Sorted Arrays 🔹 Approach: Binary Search on the smaller array 🔹 Logic: • Applied the idea of partitioning two sorted arrays • Used binary search to find the correct partition where left-side elements are less than or equal to right-side elements • Calculated the median based on whether the combined length was even or odd 📌 Key Learning: Binary search is not just for searching—it is a powerful tool for solving optimization problems efficiently. 📌 Day 2 Takeaway: Hard problems may feel overwhelming at first, but once the core idea is clear, the solution becomes much more intuitive. Moving on to Day 3 🔁 #Day2 #100DaysOfCode #LeetCode #DSA #ProblemSolving #CPP #LearningInPublic #SoftwareEngineering 🚀

🌟 Day 73 of #100DaysOfCode 🌟 🔗 Move the Last Node to the Front – A Simple Yet Powerful Linked List Pattern! 🔹 What I Solved Today’s challenge focused on an elegant linked list manipulation where the last node is moved to the front. This problem may look simple, but it strengthens understanding of pointer traversal and last-node handling — techniques that are frequently tested in interviews. 🧩 Problem: Move Last Node to Front of Linked List 💡 Given: A linked list such as: 2 → 5 → 6 → 2 → 1 💥 Goal: Take the last node of the list and move it to the front, returning the modified list — all in O(n) time and O(1) space. 📌 Example 1 Input: 2 → 5 → 6 → 2 → 1 Output: 1 → 2 → 5 → 6 → 2 📌 Example 2 Input: 2 Output: 2 (Only one node → no change) 🧠 Concepts Used ➡️ Pointer Traversal Traverse the list to find the last and second-last nodes. ➡️ Re-linking Pointers Detach the last node and connect it before the head. ➡️ Edge Case Handling If the list has only one node, return it as-is. ➡️ Efficient Logic Single traversal → O(n) time No extra memory → O(1) space ⚙️ Approach 1️⃣ Traverse to the second-last node 2️⃣ Separate the last node 3️⃣ Point the last node to the current head 4️⃣ Update head to the last node 5️⃣ Return the modified list 🚀 Learning This problem helped improve my understanding of: ✔️ Boundary cases in linked lists ✔️ Precise pointer manipulation ✔️ Clean and optimal transformations ✔️ Writing space-efficient code ✔️ Thinking in terms of node connections #CodingLife #Programmer #LinkedList #GeeksForGeeks #JavaDeveloper #StudentCoder #ProblemSolving

Optimization Matters: How I solved LeetCode 1390 (Four Divisors) 🚀 When solving algorithmic problems, the difference between a "working" solution and an "accepted" solution usually comes down to one thing: Time Complexity. The Challenge: The problem asks for the sum of divisors of numbers that have exactly four divisors. With values up to 10⁵and an array size of 10⁴, a brute-force approach (checking every number from 1 to n for every element) would result in O(N×M) complexity. In the worst case, that's 10⁹ operations—way too slow for most environments. My Evolution of Logic: Initially, I considered a simple linear scan for divisors. However, I realized I needed a more mathematical approach to stay within the time limits. The Optimized Approach: I shifted to a Square Root of x optimization. Here’s why it works: Divisor Pairs: Divisors always appear in pairs. For a number x, if i is a divisor, then x/i is also a divisor. One will always be < √xand the other will be >=√x Efficiency: By only iterating up to √x, I reduced the operations per number from 100,000 to just 316. The Logic: Loop from 1 to √x If (x% i == 0), identify if it’s a perfect square (i == x/i) or a distinct pair. Early Exit: If the divisor count exceeds 4, I immediately break the loop. This "pruning" saves significant CPU cycles. Only if the final count is exactly 4, do I add the sum to the total. Key Takeaway: Writing code that works is the first step, but writing code that is performant is the goal. This approach brought the complexity down to O(N√M}), making the solution run almost instantly. #SoftwareEngineering #Coding #Optimization #Java #LeetCode #DSA #ContinuousLearning #DailyCoding #LeetCodeChallenge

🚀 𝑫𝒂𝒚 7 𝒐𝒇 𝑴𝒚 𝑳𝒆𝒆𝒕𝑪𝒐𝒅𝒆 𝑱𝒐𝒖𝒓𝒏𝒆𝒚 | 𝑫𝑺𝑨 – 𝑺𝒕𝒂𝒄𝒌 (𝑱𝒂𝒗𝒂) Continuing my daily DSA practice with LeetCode 📘 Today was all about using stacks to solve real-world array problems efficiently and understanding the concept of Next Smaller Element. 🔹 𝑷𝒓𝒐𝒃𝒍𝒆𝒎 𝑺𝒐𝒍𝒗𝒆𝒅 𝑻𝒐𝒅𝒂𝒚:   𝑭𝒊𝒏𝒂𝒍 𝑷𝒓𝒊𝒄𝒆𝒔 𝑾𝒊𝒕𝒉 𝒂 𝑺𝒑𝒆𝒄𝒊𝒂𝒍 𝑫𝒊𝒔𝒄𝒐𝒖𝒏𝒕 𝒊𝒏 𝒂 𝑺𝒉𝒐𝒑 (https://lnkd.in/gNZSzHNQ) 🔹 Key Concept Used: Monotonic Stack (Next Smaller or Equal Element to the Right) 🔹 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n) Space Complexity: O(n) 🔹 What I’m Learning: • Stack helps avoid unnecessary nested loops • Index-based stack usage simplifies discount calculation • Recognizing patterns like “next smaller element” is crucial • Clean logic + practice = faster problem solving Solving one problem a day and strengthening fundamentals step by step. Consistency over intensity.🚀 #LeetCode #DSA #Stacks #Java #ProblemSolving #DailyCoding #Consistency #LearningJourney #BackendDeveloper #2026Goals

"No-code" is a terrible name. It implies anyone can drag and drop their way to a working system. No technical thinking required. Just vibes and templates. That's not what actually what it is. The tools are more accessible, yes. You don't need to write Python to build a functional app anymore. But you still need to understand: → How data flows between systems → Why that automation broke at 2am → What happens when edge cases show up → How to architect something that won't collapse at scale No-code didn't remove the technical skills. It just changed which ones matter. The people winning with these tools aren't the ones who avoided learning. They're the ones who learned different things. They learned logic to work alongside code. Maybe we should call it "logicode."

🌟 Day 69 of #100DaysOfCode 🌟 🔗 Remove Linked List Elements – Clean-Up Operation in Linked Lists 🔹 What I Solved Today’s challenge focused on cleaning up a linked list by removing all nodes that match a given value. Given the head of a singly linked list and an integer val, the task was to delete every node whose value equals val and return the updated list. This problem is a great test of pointer handling, edge-case management, and safe deletion logic in linked lists. 🧩 Problem: Remove Elements from Linked List 💡 Given: A singly linked list An integer val 💥 Goal: Traverse the list and remove all nodes whose value equals val, while keeping the remaining list structure valid. 🧠 Concepts Used ➡️ Dummy Node Technique A dummy node before the head simplifies deletions, especially when the head itself needs to be removed. ➡️ Linked List Traversal Move through the list node by node while checking the next pointer. ➡️ Pointer Manipulation If a node needs to be deleted, redirect pointers to skip it safely. ➡️ Edge Case Handling Handles: Empty list Head node deletion All nodes matching val ✔️ Time Complexity: O(n) ✔️ Space Complexity: O(1) ⚙️ Approach 1️⃣ Create a dummy node pointing to head 2️⃣ Use a pointer curr starting from the dummy 3️⃣ If curr.next.val == val, skip that node 4️⃣ Otherwise, move curr forward 5️⃣ Return dummy.next as the new head 🚀 Learning This problem reinforced: ✔️ Clean and safe deletion logic ✔️ The power of dummy nodes ✔️ Pointer discipline in linked lists ✔️ Edge-case–driven problem solving ✔️ Writing concise and interview-ready solutions #CodingLife #Programmer #LeetCode #GeeksForGeeks #LinkedList #ProblemSolver #CleanCoding #SkillUp

LeetCode Problem of the Day — Back to Fundamentals Today’s POTD (LeetCode 3315: Construct the Minimum Bitwise Array II) serves as a valuable reminder that some of the most essential problem-solving skills in software engineering remain unchanged over the years. The task is straightforward: ans[i] | (ans[i] + 1) == nums[i] Minimize ans[i]. However, the real challenge lies in reasoning rather than coding. Here are a few insights that made a difference: - Even numbers are impossible: No matter what value you choose, x | (x + 1) is always odd. This observation resolves half the cases immediately. - Binary structure > brute force: Incrementing a number flips trailing bits. To achieve the minimum valid answer, you modify exactly one bit: the bit just before the first zero. - An O(1) solution emerges naturally: Once the pattern is clear, the solution simplifies to a single, clean bitwise operation. Why I appreciate problems like this is that they reward: - Understanding over memorization - Precision over trial-and-error - Fundamentals over frameworks These skills are crucial in real systems — performance tuning, debugging, and designing reliable software. Strong fundamentals compound over time. Problems like today’s POTD remind us to keep these skills sharp. On to the next one. Let's Connect : Harshit goel #LeetCode #ProblemOfTheDay #BitManipulation #DataStructures #Algorithms #ProblemSolving #SoftwareEngineering #CodingInterview #ComputerScience #LearningEveryDay

🚀 Consistency + Fundamentals = Results Just got an Accepted solution on LeetCode ✅ 💡 0 ms runtime 💯 Beats 100% submissions This problem looks simple on the surface, but it really tests how well you understand core data structures — especially stacks and matching logic. What this reinforced for me: Strong fundamentals matter more than fancy tricks Writing clean, readable logic often leads to optimal performance Small checks (like early exits) can make a big difference Every problem solved builds confidence and clarity for the next one. One step closer to becoming a better problem solver 🚀 If you’re grinding DSA right now — keep going. Progress compounds. 💪 #LeetCode #DSA #ProblemSolving #CPlusPlus #CodingJourney #Consistency #SoftwareEngineering #LearningEveryDay