How to transform n to 0 with minimum operations

LeetCode POTD 😁: Description: You are given an array nums of n integers and two integers k and x. The x-sum of an array is calculated by the following procedure: -> Count the occurrences of all elements in the array. -> Keep only the occurrences of the top x most frequent elements. If two elements have the same number of occurrences, the element with the bigger value is considered more frequent. -> Calculate the sum of the resulting array. Note that if an array has less than x distinct elements, its x-sum is the sum of the array. Return an integer array answer of length n - k + 1 where answer[i] is the x-sum of the subarray nums[i..i + k - 1]. Here's my solution: https://lnkd.in/g6gjzEq7 #Python #DSA #Leetcode #DailyChallenge

LeetCode POTD 💫: Description: You are given an array nums of n integers and two integers k and x. The x-sum of an array is calculated by the following procedure: -> Count the occurrences of all elements in the array. -> Keep only the occurrences of the top x most frequent elements. If two elements have the same number of occurrences, the element with the bigger value is considered more frequent. -> Calculate the sum of the resulting array. Note that if an array has less than x distinct elements, its x-sum is the sum of the array. Return an integer array answer of length n - k + 1 where answer[i] is the x-sum of the subarray nums[i..i + k - 1]. Here's my solution: https://lnkd.in/gmUKJuq2 #Python #DSA #Leetcode #DailyChallenge #Hard

🔷 Day 25- 30DaysChallenge(Leetcode Problem): First Missing Positive 🌟 Problem: Given an unsorted integer array nums. Return the smallest positive integer that is not present in nums. You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space. 🧠Solution: class Solution:   def firstMissingPositive(self, nums: List[int]) -> int:     unique = set(nums)     i = 1     while i in unique:       i += 1     return i #DSA #Python #CodingChallenge #30dayschallenge #Leetcode

💡 LeetCode #21 — Merge Two Sorted Lists 📘 Problem: You are given the heads of two sorted linked lists list1 and list2. Merge them into one sorted linked list and return the head of the new list. 🧠 Approach: Use a dummy node to simplify the process. Compare nodes from both lists one by one. Attach the smaller node to the merged list. Once one list is empty, connect the remaining nodes from the other list. ⚙️ Complexity: ⏱ Time: O(m + n) — traverse both lists once 💾 Space: O(1) — uses constant extra space 💬 Takeaway: This is a great example of the two-pointer technique and dummy node pattern, useful in many linked list problems. #LeetCode #Python #DataStructures #LinkedLists #CodingInterview #DSA

🧩 Day 39 — Find First and Last Position of Element in Sorted Array (LeetCode 34) 📝 Problem -Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value. -If target is not found in the array, return [-1, -1]. You must write an algorithm with O(log n) runtime complexity 🔁 Approach -Use binary search twice — once to find the first occurrence and once to find the last occurrence. -For the first position: -When nums[mid] == target, move left (right = mid - 1) to continue searching earlier indices. -For the last position: -When nums[mid] == target, move right (left = mid + 1) to continue searching later indices. -If the target does not exist in the array, return [-1, -1] 📊 Complexity -Time Complexity: O(log n) -Space Complexity: O(1) 🔑 Concepts Practiced -Binary Search -Divide and Conquer -Edge Case Handling #Leetcode #Python #DSA #BinarySearch #Divide

#Day254 of Solving #DSA ✅ LeetCode Daily Progress Today I solved Question 240 – Search a 2D Matrix II 💻 This problem was quite interesting as it required optimizing search within a sorted 2D matrix. Instead of checking every element, I used a binary search–like logic — starting from the top-right corner, and moving left if the current element was greater than the target or down if it was smaller. This approach reduced the complexity to O(m + n), making it much more efficient than a brute-force search. ⚡ 🧠 Key takeaway: Smart traversal techniques can often replace heavy loops — understanding patterns in data helps you find optimal paths! #LeetCode #Coding #DSA #BinarySearch #ProblemSolving #Python #CodingJourney

🔷 Day 19- 30DaysChallenge(Leetcode Problem): Pascal's Triangle 🌟 Problem: Given an integer numRows, return the first numRows of Pascal's triangle. In Pascal's triangle, each number is the sum of the two numbers directly. 🧠Solution: class Solution:   def generate(self, numRows: int) -> List[List[int]]:     res=[[1]]     for i in range(numRows-1):       temp=[0]+res[-1]+[0]       row=[]       for j in range(len(res[-1])+1):         row.append(temp[j]+temp[j+1])       res.append(row)     return res #DSA #Python #CodingChallenge #30dayschallenge #Leetcode

#96day of #100DaysOfCode 🌱 LeetCode 109: Convert Sorted List to Binary Search Tree Today’s challenge was about building balance — literally! Given a sorted linked list, we need to convert it into a height-balanced BST 🌳 🧠 Key Idea: The middle element of the list becomes the root. Left half forms the left subtree, right half forms the right subtree. Use slow–fast pointers to find the middle efficiently. 📈 Complexity: Time: O(n log n) Space: O(log n) (recursion stack) 💬 Learning: Balance matters — in trees, in code, and in life 🌿 Sometimes, the middle point creates the strongest foundation. #LeetCode #DSA #BinarySearchTree #LinkedList #CodingChallenge #Python #Algorithm #LeetCodeDaily #100DaysOfCode

🚀 Day 43 of #100DaysOfDSA 💡 Problem: 993. Cousins in Binary Tree 🔗 LeetCode: https://lnkd.in/djrWKuC4 🧠 Approach: - Used DFS to record the depth and parent of both target nodes (x and y). - Compared their depths and parents to check if they are cousins (same level, different parents). - Used recursion for clean and efficient traversal. 📚 Learnings: - Strengthened understanding of tree traversal using recursion. - Learned to track multiple attributes (depth, parent) simultaneously. - Improved logical reasoning for binary tree relationship problems. 👨💻 LeetCode Profile: https://lnkd.in/dGQwSXjb #100DaysOfDSA #Day43 #LeetCode #Python #BinaryTree #DFS #Recursion #ProblemSolving #CodingChallenge

#95day of #100DaysOfCode 🌳 LeetCode 98: Validate Binary Search Tree Today’s challenge was to check if a given binary tree is a valid BST (Binary Search Tree). A BST must satisfy: Left subtree < Root < Right subtree Both subtrees must also be BSTs. 🧠 Approach: Use inorder traversal — in a valid BST, inorder values are always strictly increasing. 📈 Complexity: Time: O(n) Space: O(n) (for recursion stack or list) 💬 Learning: A BST’s beauty lies in order — like life, balance and structure ensure correctness 🌿 #LeetCode #BinarySearchTree #DSA #CodingChallenge #Python #TreeTraversal #ProblemSolving #LeetCodeDaily #100DaysOfCode