Solved LeetCode Problem 2011: Final Value of Variable After Operations

💻 LeetCode 50 Days Challenge — Day 3: Remove Duplicates from Sorted Array Day 3 of my #LeetCode50DaysChallenge ✅ Today’s problem was about array manipulation — Remove Duplicates from Sorted Array ✨ 🧩 Problem: Given an integer array nums sorted in non-decreasing order, remove duplicates in-place such that each unique element appears only once. The relative order of the elements should remain the same. 💡 Approach: This problem is a classic two-pointer approach! One pointer i keeps track of the last unique element’s position. The other pointer j iterates through the array. Whenever a new element is found (nums[i] != nums[j]), we move it forward by incrementing i and assigning nums[i] = nums[j]. In the end, i + 1 gives the count of unique elements. A simple yet elegant technique to modify arrays in-place! ⏱️ Time Complexity: O(n) 📊 Example: Input: [0,0,1,1,1,2,2,3,3,4] Output: [0,1,2,3,4] Consistency is the secret ingredient to progress! 🌱 Each problem solved adds another brick to the wall of mastery 💪 #LeetCode #CodingChallenge #Day3 #ProblemSolving #Java #SoftwareDevelopment #Consistency #100DaysOfCode

💻 LeetCode 50 Days Challenge — Day 5: Search Insert Position Day 5 of my #LeetCode50DaysChallenge ✅ Today’s problem was about finding the correct insertion index in a sorted array efficiently — Search Insert Position ✨ 🧩 Problem: Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order. The goal is to achieve a runtime complexity of O(log n). 💡 Approach: I implemented a binary search approach. The idea is to use two pointers (left and right) to narrow down the range. If the middle element is less than the target, move the left pointer up. Otherwise, move the right pointer down. Once the pointers converge, the left index represents the correct insertion position. This method ensures an efficient and clean solution, making use of binary search logic rather than linear iteration. ⏱️ Time Complexity: O(log n) 📊 Example: Input: nums = [1, 3, 5, 6], target = 2 Output: 1 “Small steps every day lead to big progress — keep showing up!” 💪 #LeetCode #CodingChallenge #Day5 #ProblemSolving #Java #SoftwareDevelopment #Consistency #100DaysOfCode

💻 Day 59 of #100DaysOfCode Challenge 🚀 Today's problem: Leetcode 240 – Search a 2D Matrix II 🔍 This problem was about efficiently searching for a target value in a 2D matrix where each row and each column is sorted in ascending order. 💡 Key Insight: Instead of searching the entire matrix, start from the top-right corner: If the current element is greater than the target → move left. If it’s smaller → move down. This approach ensures that we eliminate one row or one column in every step — achieving O(m + n) time complexity. 📊 Result: ✅ Accepted – All test cases passed successfully! ⚡ Time Complexity: O(m + n) 💾 Space Complexity: O(1) 🧠 Takeaway: This problem was a great reminder that understanding data structure properties can help you find smarter solutions rather than brute-forcing through the problem. Every problem adds another brick to the foundation of logical thinking and algorithmic mastery. 💪 #Day59 #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #TechLearning #DSA

💻 LeetCode 50 Days Challenge — Day 2: Longest Common Prefix Day 2 of my #LeetCode50DaysChallenge ✅ Today’s problem was all about string manipulation — Longest Common Prefix ✨ 🧩 Problem: Given an array of strings, find the longest common prefix among them. If there’s no common prefix, return an empty string "". 💡 Approach: I sorted the array alphabetically, then compared the first and last strings (since they’ll have the maximum difference). By comparing characters until they differ, I was able to build the common prefix using a StringBuilder. This approach is both elegant and efficient for the problem! ⏱️ Time Complexity: O(n × m) — where n is the number of strings and m is the length of the shortest string. 📊 Example: Input: ["flower", "flow", "flight"] Output: "fl" This problem really highlights how a simple sorting trick can simplify logic significantly. Feeling more confident with string problems — consistency is the key! 🔥 #LeetCode #CodingChallenge #Day2 #ProblemSolving #Java #SoftwareDevelopment #Consistency #100DaysOfCode

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

🚀 Day 118 of 120 – #DSAwithJava Challenge Hey LinkedIn fam! 👋 Today’s problem was all about Linked Lists and HashSets — a combination that makes node deletions efficient and elegant ⚡ ✅ Problem: Delete Nodes From Linked List Present in Array (LeetCode #3217 – Medium) 🎯 Objective: Given an array nums and the head of a linked list, remove all nodes whose values exist in nums. 🧠 Key Insight: Store all elements of nums in a HashSet for O(1) lookups. Use a dummy node before the head to handle edge deletions easily. Traverse the list, and if a node’s value exists in the set, skip it by adjusting pointers. The result is a clean linked list containing only valid nodes. 💡 Example: Input → nums = [1,2,3], head = [1,2,3,4,5] Output → [4,5] 🕒 Time Complexity: O(n + m) 📦 Space Complexity: O(m) 🔥 Takeaway: When dealing with linked lists, HashSets simplify membership checks, and dummy nodes simplify pointer logic. A small design tweak can lead to clean and optimal solutions! 💪 #120DaysOfCode #DSAwithJava #LeetCode #Java #LinkedList #HashSet #ProblemSolving #CodingChallenge #TechJourney #Consistency #LearnByDoing

🚀 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

#100DaysOfCode – Day 81 Linked List Cycle Problem Given the head of a linked list, determine whether the list contains a cycle meaning a node’s next pointer refers back to a previous node. My Approach Used Floyd’s Cycle Detection Algorithm (Tortoise & Hare Method): Initialized two pointers slow and fast. Moved slow one step and fast two steps in each iteration. If they ever meet → cycle detected. If fast or fast.next becomes null → no cycle exists. Complexity Time: O(n) Space: O(1) Even in problems involving dynamic structures like linked lists, a simple pointer-based approach can lead to an elegant and optimal solution. #100DaysOfCode #LeetCode #Java #ProblemSolving #DataStructures #LinkedList #TortoiseAndHare #takeUforward #CodeNewbie #CodingJourney

💻 Day 410 of #500DaysOfCode 🚀 Problem: Minimum One Bit Operations to Make Integers Zero (LeetCode #1611) Difficulty: Hard Today’s challenge was all about bit manipulation — one of those topics that looks simple on the surface but reveals some deep patterns when you dig in. The task: Given an integer n, you have to transform it into 0 using specific bit operations — flipping bits based on certain conditions. At first glance, it seems like a direct simulation problem, but the optimal approach lies in understanding Gray Code transformations! 💡 Key Idea: The number of operations needed to reduce n to 0 follows an inverse Gray code pattern. Using recursion and bitwise manipulation, we can calculate the answer efficiently in O(log n) time. ✨ Concepts Learned: Gray code transformation patterns Recursive bit manipulation How mathematical patterns simplify complex bit problems Each hard problem strengthens logical thinking a bit more 🔥 #Day410 #LeetCode #BitManipulation #Java #CodingChallenge #ProblemSolving #CodeEveryday #500DaysOfCode