"Finding Closest to Zero in Array with Java"

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency

🚀 Day 80 of #100DaysOfCode 🚀 🧩 Problem: Merge Sorted Array — LeetCode 💡 Approach: Started from the end of both arrays, comparing elements and placing the larger one at the last position. This in-place merging avoids extra space and ensures efficiency — a clean, optimal two-pointer solution! ⚡ 📊 Complexity Analysis: ⏱ Time Complexity: O(m + n) 💾 Space Complexity: O(1) ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 43.82 MB ✨ Key Insight: Sometimes, the best way forward is to start from the end — both in arrays and in problem-solving. 😉 #LeetCode #100DaysOfCode #JavaProgramming #ProblemSolving #DSA #CodingChallenge #AlgorithmDesign #TechJourney #CodeEveryday

🚀 LeetCode POTD — 3542. Minimum Operations to Convert All Elements to Zero 🎯 Difficulty: Medium | Topics: Stack, Greedy, Array Manipulation 🔗 Solution Link: https://lnkd.in/gxxibyS7 Today’s #LeetCode Problem of the Day was a really interesting one — not too hard conceptually, but it took some time to reason through the logic clearly. The goal was to make all elements of the array 0 using the minimum number of operations, where each operation lets you zero out all occurrences of the minimum non-negative integer in a chosen subarray. 🧠 My Approach: Used a stack to efficiently track the current sequence of minimum values. While iterating: Pop from the stack if the current element is smaller (since it resets the sequence). If the stack is empty or the top is smaller than the current value (and not zero), push it and increment the operation count. Each push represents a distinct “operation boundary.” 📈 Complexity: Time: O(n) Space: O(n) 💡 Takeaway: Sometimes, the best solutions come from combining greedy intuition with stack-based optimization — focusing only on transitions that matter. #LeetCode #ProblemOfTheDay #DSA #CodingChallenge #GreedyAlgorithm #Stack #ArrayProblems #CodingJourney #SoftwareEngineering #ProblemSolving #100DaysOfCode #LearningInPublic #TechCommunity

🚀 Day 81 of 100 Days of Leetcode Challenge - Problem 3354: Make Array Elements Equal to Zero 🔍 Problem Overview: In today's challenge, we are tasked with finding the number of valid selections in an integer array nums. The goal is to select a starting position, curr, where nums[curr] = 0, and choose a direction (left or right) to move, while following specific conditions. 🌟 Solution Walkthrough: We start by selecting a valid initial position and direction. The movement continues, updating the position and reversing direction based on the values at the current position. We track the possible valid selections that lead to all elements becoming zero. 🔧 Dry Run Example: For the input nums = [1, 0, 2, 0, 3]: We test multiple initial positions and directions. The possible valid selections are identified, leading to the final result. 💡 Brute Force Approach: We iterate through all possible initial positions and directions, but this results in suboptimal time complexity. ⚡ Optimal Approach: Using efficient iteration and tracking mechanisms, we can achieve a more optimal solution that reduces the overall time complexity. ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) ✅ Key Learnings: Handling edge cases is crucial. A good understanding of direction reversal and boundary checks is essential. 🔑 Edge Cases: Arrays with all zeros. Handling large arrays efficiently. 🔝 Hashtags & Keywords: #100DaysOfLeetcode #LeetcodeChallenge #CodingJourney #ProblemSolving #AlgorithmDesign #TechieLife #LeetcodeSolutions #LeetcodeProblems #TimeComplexity #SpaceComplexity #CodingCommunity #TechCareer #CodingIsLife #BruteForceVsOptimal #CompetitiveProgramming

Day 44 of LeetCode Grind ⚡🔥 Problem 1: Check If Digits Are Equal in String After Operations Ever wonder how fast a simple reduction process unveils hidden patterns? Today’s challenge repeatedly condenses a digit string until only two remain—and checks if both are equal. The real kicker: tiny transforms, big reach, and pure digit dynamics at play. Problem 2: Next Greater Numerically Balanced Number Numerically balanced numbers are those quirky beauties where every digit appears exactly as often as its own value. Finding the next such number above a threshold is more than brute force: it’s a test of constraint handling and mathematical curiosity. Key lesson? Sometimes, exhaustive search is the simplest answer when working with rare structures. 💡 Insights: * Layered reduction and transformation often reveal hidden regularities—look for invariants! * “Digit frequency” problems test your ability to model constraints and efficiently recognize special structures. * A simple approach (like BFS or direct enumeration) can be best if the solution space is small or tightly constrained. ✨ Reflect: Progress means getting comfortable with both lightning-fast reductions and the patience of searching for “quirky” gems. Today was all about rigorous attention to constraints and embracing simple, robust methods. #AlgorithmicThinking #PatternRecognition #LeetCode #Day44 #ProblemSolving #100DaysOfCode

⚡ 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

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

🚀 Day 7 of #120DaysOfCode Challenge 💡 Problem: Reverse Integer (LeetCode #7 | Medium) 📄 Problem Statement: Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes it to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], then return 0. 🧩 My Approach: Extract the last digit of x using % 10. Build the reversed number step by step using rev = rev * 10 + digit. Carefully check for overflow before multiplying or adding — using INT_MAX and INT_MIN limits to ensure the reversed number stays valid. If overflow is detected, return 0. 🔍 Key Learnings: How to handle integer overflow without using 64-bit variables. Importance of edge case testing and boundary conditions. Reinforced understanding of modulus (%) and integer division (/) operations. 🔥 Progress: Day 7 / 120 📚 Language: C 🏁 Problem Solved: Reverse Integer (LeetCode #7) Every problem is a small step toward stronger logic and cleaner code! 💪 #100DaysOfCode #120DaysOfCode #CodingChallenge #LeetCode #CProgramming #ProblemSolving #LearnEveryday #BuildInPublic

🔥 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 Challenge – Day 64 ✅ Took on a twist of yesterday’s problem — this time, unique combinations only. 🔗 LeetCode 40 – Combination Sum II Unlike the original, this version adds a layer of complexity by introducing duplicates. It’s not just about generating combinations anymore — it’s about ensuring uniqueness through careful pruning and logical control. This challenge sharpens precision in backtracking and reinforces the value of constraints in problem design. 💡 Key Takeaways: • Constraints drive creativity — limitations often lead to smarter solutions. • Sorting and skipping duplicates build clean, efficient recursion. • Small tweaks in problem statements can completely reshape the solution approach. #Day64 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Backtracking #Recursion #Combinations