Solved LeetCode Problem 2654: Minimum Operations to Make Array Equal to 1

🚀 Solved a Classic String-Search Problem! I recently worked on the problem “Find the index of the first occurrence of a string in another string” (LeetCode 28 — strStr()), and it was a great exercise in understanding string manipulation and efficient search techniques. 🔍 Problem Summary Given two strings, haystack and needle, the goal is to return the index of the first occurrence of needle within haystack, or -1 if it doesn’t exist. 🔧 My Approach I implemented two solutions: 1️⃣ Basic Sliding Window Approach Iterate through haystack Compare each substring with needle Return the index when a match is found 2️⃣ Optimized Thought Process (KMP-ready) Explored how KMP can reduce time complexity from O(n*m) to O(n) Understood prefix functions and pattern matching fundamentals 🧠 What I Learned Strengthened understanding of string traversal Learned how to optimize search operations Practiced writing clean and readable code Got a deeper understanding of how real search algorithms (like KMP) work behind the scenes Happy to connect with others exploring DSA, algorithms, and problem-solving! 🚀 #️⃣ #dsa #leetcode #coding #programming #python #softwaredevelopment #algorithms #computerscience

"Day 3 is a massive win for efficiency! I dedicated the morning to mastering the Two-Pointer technique, a critical step in optimizing array algorithms. I successfully tackled two key problems, including the famous Remove Duplicates (#26), which confirmed the absolute necessity of O(1) auxiliary space optimization. Key Technical Insight: O(1) Space is King I compared different approaches for removing duplicates and confirmed the core DSA lesson: 1. The Slow/Fast Pointer method is the correct, efficient approach, achieving O(1) space and O(n) time by manipulating the array in-place. 2. Brute-force solutions using helper data structures violate the memory constraint and often lead to slow O(n^2) time complexity. The lesson is clear: Master the mechanism, don't just rely on the wrapper. Understanding this difference is essential for building scalable applications. All progress is documented and pushed. Now, the plan pivots to laying the foundation for my Python OOP skills and project architecture. #DSA #TwoPointers #Python #LeetCode #SoftwareEngineering #Consistency #O1Space"

⚡ Day 87 of #100DaysOfDSA – 3Sum Closest 🔍 📌 Problem. no 16: Given an integer array nums and an integer target, find the sum of three integers in nums such that the sum is closest to the target. Implemented an optimized Two-Pointer Approach after sorting the array. ⚡ Runtime: 431 ms – Beats 75.40% of submissions 💾 Memory: 12.59 MB – Beats 39.70% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 106 test cases passed successfully! This problem helped me strengthen my skills in pointer manipulation, array traversal, and optimization of nested loops. It was a great exercise in precision and efficiency under constraints. 🔑 Key Learnings: ✔️ Learned to balance between accuracy and performance ✔️ Gained deeper understanding of sorting and two-pointer techniques ✔️ Improved debugging and edge-case analysis for numerical problems 🎯 Day 87 — A logical yet challenging problem that sharpened my optimization mindset and coding discipline! 💪🔥 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills

🚀 DSA Progress – Day 96 ✅ Problem #1404: Number of Steps to Reduce a Number in Binary Representation to One 🧠 Difficulty: Medium | Topics: String, Bit Manipulation, Simulation 🔍 Approach: Implemented a bitwise simulation approach to reduce a binary string to "1" without converting it to an integer. Step 1 (Right-to-Left Traversal): Start from the least significant bit (rightmost) and move leftwards until the most significant bit. Step 2 (Check Bit + Carry): At each step, evaluate (bit + carry) — If the result is odd (1) → perform two operations: add 1 (causing carry) and divide by 2. If the result is even (0) → perform one operation: divide by 2. Step 3 (Carry Handling): Maintain a carry variable to track the overflow when a +1 operation is applied. After the loop, if a carry still exists, add it to the total count. This method effectively simulates binary addition and division using string traversal, avoiding large integer conversions. 🕒 Time Complexity: O(n) — Single traversal of the binary string. 💾 Space Complexity: O(1) — Constant extra space for carry and counter variables. 📁 File: https://lnkd.in/emqeMm9h 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem deepened my understanding of binary arithmetic and carry propagation. Instead of direct numeric operations, I learned how to simulate binary behavior efficiently using strings — a crucial skill for handling large number representations. It also strengthened my logic for simulation problems, where each step mimics low-level arithmetic rules. ✅ Day 96 complete — reduced a long binary trail down to one shining bit! 💡⚙️🧠 #LeetCode #DSA #Python #Binary #BitManipulation #Simulation #Strings #CodingChallenge #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney

Day 10 of #100DaysOfLeetCode Today’s problem, Count Operations to Obtain Zero, focused on a simple yet powerful iterative process — teaching the importance of loop control, conditional swapping, and mathematical reasoning in problem-solving. 1️⃣ Count Operations to Obtain Zero The challenge was to determine how many operations are needed to make either of two given integers zero. In each operation, the larger number is reduced by subtracting the smaller one, and the process repeats until one of them becomes zero. 🔹 My Approach: Used a while loop to repeatedly subtract the smaller number from the larger one. After every subtraction, incremented a counter to keep track of total operations. Carefully managed the condition to handle both cases where either number could be larger. The process naturally ends when one of the numbers reaches zero. What I Learned: This problem demonstrates how even a simple operation can model deeper mathematical principles, like the Euclidean algorithm for computing GCD. It reinforces that efficiency often lies in understanding the pattern rather than overcomplicating logic. Complexity Analysis: Time Complexity: O(max(num1, num2)) in the naive subtraction form, or O(log n) if optimized using division. Space Complexity: O(1) — constant extra space used. #100days #leetcode #leetcodejourney #100daysofleetcode #consistent #DSA #python

⚡ Day 83 of #100DaysOfDSA – Majority Element 💡 📌 Problem. no 169: Given an array nums, find the element that appears more than ⌊n / 2⌋ times. Implemented an efficient hash map-based counting approach to track element frequency and determine the majority element quickly. ⚡ Runtime: 13 ms – Beats 37.81% of submissions 💾 Memory: 13.60 MB – Beats 64.79% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 53 test cases passed successfully! This challenge helped me better understand frequency counting, dictionary operations, and threshold-based decision making. It’s a great problem for mastering counting logic and handling arrays efficiently. 🔑 Key Learnings: ✔️ Strengthened my understanding of hash maps and element frequency counting ✔️ Learned how to use early termination for optimization ✔️ Improved confidence in solving majority and occurrence-based problems 🎯 Day 83 — A solid step forward in mastering counting logic and data structure efficiency! 🚀🔥 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills

🚀 DSA Challenge – Day 86 Problem: Minimum Operations to Make Array Elements Zero ⚙️💥 This problem was a simple yet insightful exercise in greedy thinking and recognizing that we only need to count distinct positive values to reach the goal efficiently. 🧠 Problem Summary: You are given a non-negative integer array nums. In one operation, you can choose an integer x (≤ smallest non-zero element) and subtract it from all positive numbers. Your task: Find the minimum number of operations to make all elements 0. ⚙️ My Approach: 1️⃣ Sort the array to process numbers in ascending order. 2️⃣ Maintain a running subtraction value curr to track how much has already been subtracted. 3️⃣ For each new smallest element, if it’s still positive after prior subtractions, perform one operation and update curr. 4️⃣ Each operation corresponds to discovering a new distinct positive number. 📈 Complexity: Time: O(n log n) → Sorting dominates the time complexity. Space: O(1) → Only a few extra variables used. ✨ Key Takeaway: Every distinct positive number in a sorted array represents a new operation — a clean and intuitive greedy solution that avoids overcomplication. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #GreedyAlgorithm #Sorting #CodingChallenge #Python #Algorithms #EfficientCode #Optimization #TechCommunity #InterviewPrep #CodeEveryday #LearningByBuilding

⚡ Day 85 of #100DaysOfDSA – Reverse Bits 💡 📌 Problem. no 190: Given a 32-bit unsigned integer, reverse its bits and return the result. Solved using bit manipulation by shifting and combining bits efficiently through iterative processing. ⚡ Runtime: 15 ms – Beats 74.65% of submissions 💾 Memory: 12.49 MB – Beats 49.36% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 600 test cases passed successfully! This problem strengthened my understanding of low-level bit operations, binary manipulation, and efficient use of shifting operators. It’s a great reminder that small operations can have big effects on data representation. 🔑 Key Learnings: ✔️ Learned how to manipulate bits effectively using bitwise operators ✔️ Understood the significance of shifting and masking in binary form ✔️ Improved my grasp of algorithmic efficiency at the bit level 🎯 Day 85 — A smart bitwise challenge that sharpened my binary logic and precision-based problem-solving! ⚙️💻🔥 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills

🧠 Day 25 Theme: Recursion & Backtracking Concepts Covered Recursive calls and base conditions Decision tree and state-space exploration Backtracking for constraint satisfaction Handling duplicates and pruning branches Classic examples: combinations, permutations, subsets, and N-Queens 📚 Learn from These Resources 📘 Recursion Fundamentals 👉 https://lnkd.in/gPQvuduf 👉 https://lnkd.in/gt-mteqM 📗 Backtracking Algorithms 👉 https://lnkd.in/gaRCKvJT 👉 https://lnkd.in/g87eEpKa 📙 Visual Demos & Tutorials 👉 https://lnkd.in/g8FWB-Mq 👉 https://lnkd.in/g6Rt5zgf 🧩 Practice Ideas Generate all subsets of an array Solve permutations of numbers or strings N-Queens / Sudoku solver (classic backtracking) Word search (DFS + backtracking combo) Combinations that sum to target (like Combination Sum I/II) #75DaysOfKnowledge #Recursion #Backtracking #ProblemSolving #CodingJourney #LeetCode #AlgorithmicThinking #Java #Python #Programming