Solved LeetCode Problem #2169: Count Operations to Zero

🚀 Day 7️⃣7️⃣ of #100DaysOfCode Solved LeetCode Problem #1437 — Check If All 1’s Are at Least K Places Away 🔍✨ 🔧 Concept: Given a binary array, ensure that every 1 is separated by at least K zeros. The solution simply tracks the previous index of 1 and checks the distance. 🧠 Key Idea: Scan the array once When a 1 is found, verify: 👉 currentIndex - previousIndex > k If any pair violates this, return false ⚡ Efficient: Time Complexity: O(n) Space Complexity: O(1) Another clean and efficient logical problem solved. #LeetCode #Java #Arrays #ProblemSolving #DSA #CodingJourney #100DaysOfCode #DeveloperLife #Motivation

🔹 Day 39 – LeetCode Practice Problem: Perfect Number (LeetCode #507) 📌 Problem Statement: A perfect number is a positive integer that is equal to the sum of its positive divisors, excluding itself. Return true if the given number is perfect, otherwise return false. ✅ My Approach (Java): Initialize sum = 0. Iterate from 1 to num / 2. For every divisor i such that num % i == 0, add it to sum. After the loop, if sum == num, it’s a perfect number. 📊 Complexity: Time Complexity: O(n/2) Space Complexity: O(1) ⚡ Submission Results: Accepted ✅ Runtime: 2108 ms Memory: 41.19 MB 💡 Reflection: This problem reinforced the importance of divisor-based iteration. While this brute-force solution works, optimizing divisor checks using square roots can greatly improve performance — a good next step for refinement! #LeetCode #ProblemSolving #Java #DSA #CodingPractice #Learning

🚀 Day 390 of #500DaysOfCode 🔹 LeetCode Problem 278: First Bad Version Today’s problem was about efficiently finding the first defective version in a product release sequence using minimal API calls. Once a version turns bad, all versions after it are bad — a perfect use case for binary search optimization! ⚙️ 🧠 Concepts Used: Binary Search 🔍 Optimization of API calls Problem-solving with boundary conditions ⚡ Time Complexity: O(log n) ⚡ Space Complexity: O(1) Each step halves the search range, making it super-efficient! 🚀 #LeetCode #Java #CodingChallenge #BinarySearch #ProblemSolving #100DaysOfCode #500DaysOfCode #CodeNewbie #LearnToCode #SoftwareEngineering

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 57/100 of #100DaysOfLeetCode Today’s problem was 1323. Maximum 69 Number 💡 The task was to maximize a given positive integer (consisting only of digits 6 and 9) by changing at most one digit — specifically, changing a 6 to a 9 to get the largest possible number. 🔑 Key Takeaways: Learned how to efficiently manipulate numbers as strings. #LeetCode #Day57 #Java #100DaysOfCode #ProblemSolving #CodingChallenge #LearningEveryday

NeetCode 35 | LeetCode #143 | Reorder Linked List This one’s all about mastering pointer manipulation! Steps I followed: 1️⃣ Find the middle using slow & fast pointers 2️⃣ Reverse the second half 3️⃣ Merge both halves alternately Such problems really sharpen understanding of linked list structure and in-place rearrangement. #NeetCode #LeetCode #Java #DSA #LinkedList #Algorithms #CodingJourney #ProblemSolving

NeetCode 14 | LeetCode #11 | Container With Most Water Solved using the two-pointer approach — expanding and shrinking boundaries to find the maximum area efficiently in O(n) time. A great example of how logical movement can outperform brute force. #NeetCode #LeetCode #Java #DSA #Algorithms #TwoPointers #ProblemSolving #CodingJourney

🚀 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 11 of 100 Days of LeetCode! 💻 Today’s problem: Implement strStr() 🔍 🧩 Problem #28: Find the Index of the First Occurrence in a String This problem is a classic example of string pattern matching, where we need to find the starting index of a substring (needle) in a given string (haystack). ✨ My Approach: Used a simple sliding window technique to check each substring of haystack with length equal to needle. Compared it directly using equals() to find a match. Time complexity: O((n - m + 1) * m), which is acceptable for moderate input sizes. ✅ Result: All test cases passed successfully — and achieved 100% runtime efficiency ⚡ Each day I’m learning to think more efficiently and write cleaner, more optimized code. Consistency really is the key 🔑 #Day11 #100DaysOfCode #LeetCode #Java #ProblemSolving #CodingJourney #SoftwareDevelopment #DSA