Solved LeetCode 278: First Bad Version with Binary Search

Day 44 of #50DaysOfLeetCodeChallenge Problem: Add Two Numbers -Approach: Since the digits are stored in reverse, I started adding from the head nodes, just like manual addition from the least significant digit. Maintained a carry for sums ≥ 10. Traversed both lists simultaneously, creating new nodes for each sum digit. If a carry remained at the end, added it as a new node. -Key Takeaways: Linked lists can represent numbers in creative ways. Starting from the least significant digit simplifies addition. Carry handling is crucial for correctness. #LinkedInLearning #CodingJourney #Java #DataStructures #ProblemSolving #Algorithms #LeetCode #50Days

🚀 Day 7️⃣0️⃣ of #100DaysOfCode Solved LeetCode Problem #2169 — Count Operations to Obtain Zero ⚙️💡 Logic: In this problem, we repeatedly subtract the smaller number from the larger one until one of them becomes zero. If num1 >= num2, subtract num2 from num1. Else, subtract num1 from num2. Increment the operation count each time. Continue until either num1 or num2 becomes 0. 💭 Simple yet logical — one of those problems that tests clarity of thought over complexity. #LeetCode #Java #100DaysOfCode #ProblemSolving #CodingJourney #LearnByDoing #DeveloperLife #LogicBuilding #TechCommunity #CodeDaily #KeepCoding

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept: Find the node where two singly linked lists intersect. Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic: Move both pointers through the lists. When one pointer reaches the end, switch it to the other list’s head. They’ll either meet at the intersection node or end up as null together. ✅ Complexity: Time – O(n + m) Space – O(1) 💬 Takeaway: Sometimes, the best solutions come from balancing the path — literally! Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept:  Find the node where two singly linked lists intersect.  Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic:  Move both pointers through the lists.  When one pointer reaches the end, switch it to the other list’s head.  They’ll either meet at the intersection node or end up as null together. ✅ Complexity:  Time – O(n + m)  Space – O(1) 💬 Takeaway:  Sometimes, the best solutions come from balancing the path — literally!  Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 Day 43 of #100DaysOfLeetCode Today's problem: LeetCode #160 – Intersection of Two Linked Lists 💡 Concept:  Find the node where two singly linked lists intersect.  Used the Two Pointer Approach — a smart and efficient way to solve this without using extra memory. 🧠 Logic:  Move both pointers through the lists.  When one pointer reaches the end, switch it to the other list’s head.  They’ll either meet at the intersection node or end up as null together. ✅ Complexity:  Time – O(n + m)  Space – O(1) 💬 Takeaway:  Sometimes, the best solutions come from balancing the path — literally!  Understanding how pointers sync up teaches a lot about memory references and linked list behavior. #LeetCode #CodingChallenge #Java #DataStructures #TwoPointerTechnique #ProblemSolving #LinkedLists

🚀 Day 391 of #500DaysOfCode Today, I solved LeetCode Problem 2011: Final Value of Variable After Performing Operations 🧮 📝 Problem Summary: You start with a variable X = 0 and a list of operations such as "++X", "X++", "--X", or "X--". Each "++" increases the value by 1, and each "--" decreases it by 1. The goal is to return the final value of X after performing all operations. 💡 Approach: Initialize X = 0. Loop through the list of operations. If the operation contains "++", increment X. Otherwise, decrement X. Return the final result. ✅ Example: Input: ["--X","X++","X++"] Output: 1 A simple yet elegant problem that helps sharpen conditional logic and string manipulation fundamentals. ⚡ #LeetCode #CodingChallenge #Java #100DaysOfCode #500DaysOfCode #ProblemSolving #LearnEveryday

💻 LeetCode Challenge – Day 6: Merge Two Sorted Lists Today’s challenge was all about linked lists — merging two sorted lists into one sorted list 🔗 🔹 Problem: Given two sorted linked lists, merge them into a single sorted linked list and return it. 🔹 Key Learnings: ✅ Deepened understanding of linked list traversal and pointers ✅ Practiced building a dummy node approach for cleaner logic ✅ Learned how to handle edge cases efficiently ✅ Reinforced the importance of iterative vs recursive thinking This problem really helped me think more clearly about data structure manipulation and clean code design. 💪 #LeetCode #100DaysOfCode #Java #CodingChallenge #ProblemSolving #LinkedList #MergeTwoSortedLists #CodingJourney

#Day-44) of Problem Solving | LeetCode 2011 – Final Value of Variable After Performing Operations Just solved a fun one! 🚀 This problem tests how well you can interpret simple string-based operations and apply them efficiently. Given a list of operations like "++x", "x--", etc., the goal is to compute the final value of a variable starting from zero. 🔍 My approach (Java): Used String.indexOf("+") to detect increment operations and updated the counter accordingly. Clean, readable, and runs in linear time. #LeetCode #Java #ProblemSolving #DSA #CodingChallenge #PranshuCodes #LinkedInCoding #TechJourney

Problem: Final Value of Variable After Performing Operations Difficulty: Easy Sometimes coding challenges are not about complex algorithms — they’re about writing clean, readable logic. Today’s problem gives a list of increment/decrement operations (++X, X++, --X, X--) and asks to compute the final value of a variable starting from 0. Simple? Yes. But it's a good reminder that clarity > cleverness. #Day17 #LeetCode #Java #BeginnerFriendly #Consistency #100DaysOfCode #ProblemSolving #CodingJourney

🚀 Day 37 of #100DaysOfCode 🧩 Problem: Remove K Digits Given a number represented as a string and an integer k, remove k digits to make the smallest possible number. 💡 My Intuition: I realized that to get the smallest number, I need to remove all bigger digits that appear before a smaller one. So I used a stack — whenever the current digit is smaller than the top of the stack and I still have digits left to remove (k > 0), I pop the larger digits. This greedy approach ensures every remaining digit contributes to the smallest possible number. 🧠 Key Idea: “Keep removing from the left if you find something smaller on the right — minimal number starts from minimal prefix.” 🔥 Learning: Stack problems aren’t just about pushing and popping — they’re about making optimal local decisions that lead to the global minimum or maximum. #Day37 #LeetCode #Java #DSA #Stack #CodingJourney #ProblemSolving #100DaysOfCodeChallenge