How to solve Minimum Operations to Make Array Elements Zero in Python

⚡ 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 Challenge – Day 85 Problem: Check if All Integers in a Range Are Covered ✅📏 This problem was an elegant use of the Prefix Sum technique, where I used range updates to efficiently check coverage over an interval. 🧠 Problem Summary: You are given several inclusive integer intervals and a target range [left, right]. You must verify if every integer within [left, right] is covered by at least one of the given intervals. ⚙️ My Approach: 1️⃣ Initialize an array line to track coverage at each integer position. 2️⃣ For every range [a, b], increment line[a] and decrement line[b + 1] — this marks the start and end of coverage. 3️⃣ Convert line into a prefix sum array, so each position reflects how many intervals cover that number. 4️⃣ Finally, iterate through [left, right] to ensure each integer has coverage (> 0). 📈 Complexity: Time: O(n + 52) → Linear scan and prefix sum computation. Space: O(52) → Fixed-size array since ranges are small. ✨ Key Takeaway: Prefix sum is not just for subarray sums — it’s a powerful trick for range marking and coverage problems, offering O(1) updates and O(n) verification. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #PrefixSum #RangeUpdate #ProblemSolving #Algorithms #CodingChallenge #Python #EfficientCode #Optimization #TechCommunity #InterviewPrep #CodeEveryday #LearningByBuilding

🚀 DSA Challenge – Day 80 Problem: Maximum Distance Between Valid Pairs 🌊📏 Today’s problem tested the combination of binary search and array monotonicity — finding the farthest valid pair between two non-increasing arrays! 🧠 Problem Summary: We’re given two non-increasing arrays, nums1 and nums2. A pair (i, j) is valid if: i ≤ j, and nums1[i] ≤ nums2[j]. The goal is to find the maximum distance (j - i) among all valid pairs. ⚙️ My Approach: 1️⃣ Iterate through each element in nums1. 2️⃣ Use binary search on nums2 to find the farthest valid index satisfying the condition. 3️⃣ Keep track of the maximum j - i distance encountered. This solution leverages the sorted (non-increasing) property of arrays for logarithmic efficiency. 📈 Complexity: Time: O(n log m) → For each element in nums1, a binary search on nums2. Space: O(1) → Only a few variables used. ✨ Key Takeaway: Sometimes, monotonic properties allow you to blend binary search with iteration — turning what looks like a brute-force problem into a clean and efficient search-based solution. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Algorithms #BinarySearch #TwoPointers #CodingChallenge #Python #InterviewPrep #TechCommunity #Optimization #EfficientCode #CodeEveryday

🚀 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

🚀 Solved LeetCode 3234: Count Substrings with Dominant Ones! 🧠 Just tackled a challenging substring problem: 3234. Count the Number of Substrings With Dominant Ones. The goal is to find all substrings where the count of '1's is greater than or equal to the square of the count of '0's. A simple O(N²) approach is too slow, so a more optimized strategy is needed. My Approach: Key Insight: The condition ones >= zeros² means the number of zeros in any valid substring is small (at most √N). This is the key to optimization. Fix the Endpoint: I iterate through the string, fixing the end of the potential substring. "Zero-Hopping" Technique: From the end, I iterate backward, but instead of going one by one, I "hop" from each '0' to the previous '0'. A precomputed array makes this hop O(1). Efficient Counting: At each hop, I calculate the number of valid start positions in the segment between the two zeros, bringing the total time complexity down to O(N√N). This was a great puzzle in finding the bottleneck and building an algorithm around it! 🔗 Problem Link: https://lnkd.in/gpmZdskg #LeetCode #Coding #Algorithm #Python #ProblemSolving #SoftwareEngineering #Optimization #LeetCode #Coding #Algorithm #Python #Programming #InterviewPrep

🚀 DSA Challenge – Day 92 Problem: N-Queens Puzzle ♟️👑 This classic problem beautifully combines recursion, backtracking, and constraint satisfaction — a true test of algorithmic thinking and precision. 🧠 Problem Summary: You are given an integer n, representing an n × n chessboard. The goal is to place n queens such that no two queens attack each other — meaning no two share the same row, column, or diagonal. We must return all distinct board configurations that satisfy this condition. ⚙️ My Approach: 1️⃣ Use backtracking to try placing one queen per row. 2️⃣ Maintain three sets to track attacks: col → columns already occupied. positiveDiag (r + c) → major diagonals. negativeDiag (r - c) → minor diagonals. 3️⃣ For each row, place a queen only if it’s not under attack, then recurse for the next row. 4️⃣ Once all queens are placed, record the configuration as a valid solution. 📈 Complexity: Time: O(n!) → Since we explore all valid placements row by row. Space: O(n²) → For the board representation and recursion stack. ✨ Key Takeaway: The N-Queens problem teaches the art of constraint-driven backtracking — building solutions step by step while eliminating invalid paths early. It’s a perfect showcase of logical pruning in action. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Backtracking #Recursion #NQueens #Algorithms #Python #Optimization #Chessboard #InterviewPrep #EfficientCode #TechCommunity #LearningByBuilding #CodeEveryday

💡 Day 17 of 30 – LeetCode Challenge: Word Search (Backtracking) Today’s problem tested my understanding of DFS (Depth-First Search) and Backtracking — a key algorithmic concept used in exploring possible paths or configurations in grids, trees, and graphs. 🧩 Problem Summary We are given an m x n character grid (board) and a string word. We must determine if the word exists in the grid by moving horizontally or vertically through adjacent cells. Each cell can be used only once per word construction. ⚙️ Example Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]] word = "ABCCED" Output: true 📖 Explanation: The path A → B → C → C → E → D forms the word “ABCCED” through valid adjacent cells. 🧠 Approach 1. Traverse every cell in the grid. 2. If the character matches the first letter of word, start a DFS. 3. Explore all 4 directions — up, down, left, right — recursively. 4. Mark cells as visited (temporarily) to prevent reuse. 5. Backtrack after exploring each path (restore cell value). 6. Return True as soon as the word is found. ⏱ Complexity Analysis Time Complexity O(m * n * 4^L) → where L = length of word Space Complexity O(L) (Recursion stack) 🧩 Key Learnings ✨ Learned how DFS + Backtracking can explore all potential paths efficiently. ✨ Importance of restoring state (backtracking) after recursive exploration. ✨ Strengthened my problem-solving in grid-based traversal problems. Backtracking is like exploring a maze — you move forward when possible and step back when you hit a dead end. #Day17 #LeetCode #Backtracking #DFS #WordSearch #CodingChallenge #Python #DSA #WomenWhoCode #ProblemSolving #MTech #LearningJourney

🚀 DSA Challenge – Day 90 Problem: Single Element in a Sorted Array ⚙️🔍 This problem was a clever application of binary search where understanding the index patterns of paired elements was the key to achieving logarithmic efficiency. 🧠 Problem Summary: You are given a sorted array where every element appears exactly twice, except for one element that appears only once. Your task: return that single element in O(log n) time and O(1) space. ⚙️ My Approach: 1️⃣ Used binary search to narrow down the segment containing the single element. 2️⃣ Checked if the middle element breaks the pairing rule — if so, that’s our unique number. 3️⃣ Observed the pattern: Before the single element, pairs start at even indices. After it, pairs start at odd indices. 4️⃣ Used this parity observation to adjust the search boundaries efficiently. 📈 Complexity: Time: O(log n) → Binary search halves the search space each step. Space: O(1) → Constant space used. ✨ Key Takeaway: Sometimes, the structure of sorted pairs reveals more than meets the eye — a small parity trick transforms a linear scan into a logarithmic search. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #BinarySearch #Algorithms #CodingChallenge #Python #Optimization #EfficientCode #TechCommunity #InterviewPrep #LearningByBuilding #CodeEveryday

⚡ Day 88 of #100DaysOfDSA – Next Permutation 🔁 📌 Problem. no 31: Implement an algorithm to rearrange numbers into the next lexicographically greater permutation of numbers. If no such arrangement exists, transform it into the lowest possible order (i.e., sorted in ascending order). 🚀 Runtime: 0 ms – Beats 💯% of Python submissions 💾 Memory: 12.43 MB – Beats 52.01% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 266 test cases passed successfully! This problem was a great exercise in in-place array manipulation and understanding lexicographical ordering. It strengthened my skills in reverse traversal and efficient element swapping to achieve the next permutation sequence. 🔑 Key Learnings: ✔️ Learned how to find and swap pivot points efficiently ✔️ Improved logic-building for in-place array operations ✔️ Understood how permutations can be generated without extra space 🎯 Day 88 — A solid step forward in mastering array algorithms and improving my analytical approach to sequence transformations! 🔥💡 #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 103 Problem: Binary Tree Maximum Path Sum 🌲⚡ This is one of the most impactful binary tree problems — it tests your understanding of recursion, subtree evaluation, and handling multiple return values during DFS. 🧠 Problem Summary: You're given the root of a binary tree. A path is a sequence of connected nodes, and it can start and end anywhere in the tree (it does NOT need to pass through the root). Your task → Return the maximum path sum of any non-empty path. ⚙️ My Approach: To solve this, we perform a DFS on the tree and compute two values at every node: 1️⃣ Max downward path sum → can be extended upward to parent 2️⃣ Max complete path sum → may go left → node → right Here’s what happens at each node: Recursively compute the best path from the left child Recursively compute the best path from the right child Update the global maximum using all possible combinations Return the best single-branch path upward: root.val root.val + left root.val + right We do not return left + root.val + right upwards because that forms a closed path. 📌 Key Observations: Negative child paths should not be taken upward unless they are part of the best path. The main trick is maintaining: A global maximum A returnable path (used for parent decision) DFS ensures every node evaluates both subtrees correctly. 📈 Complexity: Time: O(n) — every node visited exactly once Space: O(h) — recursion stack (h = tree height) ✨ Key Takeaway: The challenge is correctly distinguishing between: the max path usable by parents, and the max path for the final answer. Mastering this separation unlocks many advanced tree problems. 🌳🔥 🔖 #DSA #100DaysOfCode #Day103 #BinaryTrees #MaxPathSum #Recursion #DFS #LeetCode #ProblemSolving #Python #AlgorithmicThinking #TechCommunity #CodeEveryday #LearningByBuilding Let me know if you'd like the code block included in the post as well!