Merge pull request #43 from iamAntimPal/Daily-Task

Daily task

Author: iamAntimPal

Python_Daily_Solutions/3396. Minimum Number of Operations to Make Elements/3396. Minimum Number of Operations to Make Elements in Array Distinct.py

@@ -0,0 +1,7 @@
+def minOperationsToDistinct(nums):
+    seen = set()
+    count = 0
+    while len(set(nums)) != len(nums):
+        nums = nums[3:]  # Remove first 3 elements
+        count += 1
+    return count

Python_Daily_Solutions/3396. Minimum Number of Operations to Make Elements/readme.md

@@ -0,0 +1,130 @@
+# 📄 3396. Minimum Number of Operations to Make Elements in Array Distinct  
+
+## 📌 Problem Statement  
+You are given an integer array **`nums`**. You need to ensure that the elements in the array are distinct. To achieve this, you can perform the following operation any number of times:
+
+### **Operations:**  
+1. **Remove the first 3 elements** from the array. If the array has fewer than 3 elements, remove all remaining elements.
+2. Repeat this process until all elements in the array are distinct.
+3. The goal is to **find the minimum number of operations** needed.
+
+---
+
+## 🗂 **Constraints**  
+- **`1 ≤ nums.length ≤ 100`**  
+- **`1 ≤ nums[i] ≤ 100`**  
+
+---
+
+## 🔢 **Example 1**  
+
+### **Input:**  
+```python
+nums = [1,2,3,4,2,3,3,5,7]
+```
+### **Output:**  
+```python
+2
+```
+### **Explanation:**  
+1️⃣ **Remove first 3 elements:** `[4, 2, 3, 3, 5, 7]`  
+2️⃣ **Remove next 3 elements:** `[3, 5, 7]` (distinct now)  
+✅ **Answer = `2`**
+
+---
+
+## 🔢 **Example 2**  
+
+### **Input:**  
+```python
+nums = [4,5,6,4,4]
+```
+### **Output:**  
+```python
+2
+```
+### **Explanation:**  
+1️⃣ **Remove first 3 elements:** `[4, 4]`  
+2️⃣ **Remove remaining elements:** `[]` (distinct now)  
+✅ **Answer = `2`**
+
+---
+
+## 🔢 **Example 3**  
+
+### **Input:**  
+```python
+nums = [6,7,8,9]
+```
+### **Output:**  
+```python
+0
+```
+### **Explanation:**  
+The array is already distinct. ✅
+
+---
+
+## 🚀 **Optimized Approach**  
+
+### **Steps to Solve:**  
+1️⃣ **Count duplicate elements** in the array.  
+2️⃣ **Calculate the number of removals required** to eliminate duplicates.
+3️⃣ **Perform removal in groups of 3** to reach a distinct set efficiently.  
+
+---
+
+## 🐍 **Python Solution**  
+
+```python
+def minOperationsToDistinct(nums):
+    seen = set()
+    count = 0
+    while len(set(nums)) != len(nums):
+        nums = nums[3:]  # Remove first 3 elements
+        count += 1
+    return count
+
+# Example Usage
+nums = [1,2,3,4,2,3,3,5,7]
+print(minOperationsToDistinct(nums))  # Output: 2
+```
+
+---
+
+## 💡 **Time Complexity Analysis**  
+- **Checking for duplicates:** **`O(N)`**  
+- **Removing elements:** **`O(N)`** (max 34 operations for `N=100`)  
+
+✅ **Overall Complexity:** **`O(N)`** (Efficient for `N ≤ 100`)  
+
+---
+
+## 📂 **File Structure**  
+```
+MinOps-DistinctArray/
+│── 📁 problems/
+│   ├── 3396_min_operations.py
+│── README.md  
+│── requirements.txt  
+```
+
+---
+
+## 🔥 **Want to Participate?**  
+🚀 Solve more **LeetCode Easy problems** in **Python**!  
+
+| #    | Problem Name                              | Solution                                  | LeetCode Link                                                                                                |
+| ---- | ----------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| 3396 | **Min Operations to Make Array Distinct** | [🔗 View](problems/3396_min_operations.py) | [🔗 LeetCode](https://leetcode.com/problems/minimum-number-of-operations-to-make-elements-in-array-distinct/) |
+
+---
+
+## 🔗 **Useful Links**  
+- 📘 [LeetCode Easy Problems](https://leetcode.com/problemset/all/?difficulty=Easy)  
+- 🐍 [Python Set Operations](https://docs.python.org/3/library/stdtypes.html#set)  
+- 🌟 [Contribute on GitHub](https://github.com/your-username/LeetCode_Easy_Problems)  
+
+---
+
+💡 **Let's learn, code, and master easy problems together! 🚀**

Python_Daily_Solutions/416. Partition Equal Subset Sum/416. Partition Equal Subset Sum.py

@@ -0,0 +1,12 @@
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        m, mod = divmod(sum(nums), 2)
+        if mod:
+            return False
+        n = len(nums)
+        f = [[False] * (m + 1) for _ in range(n + 1)]
+        f[0][0] = True
+        for i, x in enumerate(nums, 1):
+            for j in range(m + 1):
+                f[i][j] = f[i - 1][j] or (j >= x and f[i - 1][j - x])
+        return f[n][m]

Python_Daily_Solutions/416. Partition Equal Subset Sum/readme.md

@@ -0,0 +1,74 @@
+# Partition Equal Subset Sum
+
+## Problem Statement
+Given an integer array `nums`, return `true` if you can partition the array into two subsets such that the sum of the elements in both subsets is equal, otherwise return `false`.
+
+## Examples
+
+### Example 1:
+**Input:**
+```plaintext
+nums = [1,5,11,5]
+```
+**Output:**
+```plaintext
+true
+```
+**Explanation:**
+The array can be partitioned as `[1, 5, 5]` and `[11]`.
+
+### Example 2:
+**Input:**
+```plaintext
+nums = [1,2,3,5]
+```
+**Output:**
+```plaintext
+false
+```
+**Explanation:**
+The array cannot be partitioned into equal sum subsets.
+
+## Constraints
+- `1 <= nums.length <= 200`
+- `1 <= nums[i] <= 100`
+
+## Approach
+The problem can be solved using **Dynamic Programming (Subset Sum Problem)**:
+1. Compute the total sum of the array.
+2. If the total sum is odd, return `false` (since it's impossible to split into two equal parts).
+3. Use a **0/1 Knapsack** approach to determine if a subset with sum `total_sum/2` exists.
+4. Use a **bottom-up DP approach** to check if we can form the required sum.
+
+## Solution
+The solution uses a **boolean DP array** `dp[i]`, where `dp[i]` is `true` if a subset with sum `i` can be formed.
+- Initialize `dp[0] = true` (sum `0` is always possible).
+- Iterate over each number in `nums`, updating the `dp` array in reverse order.
+- If `dp[target]` is `true`, return `true`, otherwise return `false`.
+```python
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        m, mod = divmod(sum(nums), 2)
+        if mod:
+            return False
+        n = len(nums)
+        f = [[False] * (m + 1) for _ in range(n + 1)]
+        f[0][0] = True
+        for i, x in enumerate(nums, 1):
+            for j in range(m + 1):
+                f[i][j] = f[i - 1][j] or (j >= x and f[i - 1][j - x])
+        return f[n][m]
+```
+
+## Complexity Analysis
+- **Time Complexity:** `O(n * sum/2)`, where `n` is the number of elements.
+- **Space Complexity:** `O(sum/2)`, optimized using a 1D DP array.
+
+## Usage
+To run the solution, use the following function:
+```python
+from solution import canPartition
+print(canPartition([1,5,11,5]))  # Output: True
+print(canPartition([1,2,3,5]))   # Output: False
+```
+