Merge pull request #1 from iamAntimPal/main

leet conde daily python solutions

Author: iamAntimPal

2115. Find All Possible Recipes from Given Supplies.py

@@ -0,0 +1,67 @@
+ 
+ """ 
+  2115. Find All Possible Recipes from Given Supplies
+
+You have information about n different recipes. You are given a string array recipes and a 2D string array ingredients. The ith recipe has the name recipes[i], and you can create it if you have all the needed ingredients from ingredients[i]. A recipe can also be an ingredient for other recipes, i.e., ingredients[i] may contain a string that is in recipes.
+
+You are also given a string array supplies containing all the ingredients that you initially have, and you have an infinite supply of all of them.
+
+Return a list of all the recipes that you can create. You may return the answer in any order.
+
+Note that two recipes may contain each other in their ingredients.
+
+ 
+
+Example 1:
+
+Input: recipes = ["bread"], ingredients = [["yeast","flour"]], supplies = ["yeast","flour","corn"]
+Output: ["bread"]
+Explanation:
+We can create "bread" since we have the ingredients "yeast" and "flour".
+Example 2:
+
+Input: recipes = ["bread","sandwich"], ingredients = [["yeast","flour"],["bread","meat"]], supplies = ["yeast","flour","meat"]
+Output: ["bread","sandwich"]
+Explanation:
+We can create "bread" since we have the ingredients "yeast" and "flour".
+We can create "sandwich" since we have the ingredient "meat" and can create the ingredient "bread".
+Example 3:
+
+Input: recipes = ["bread","sandwich","burger"], ingredients = [["yeast","flour"],["bread","meat"],["sandwich","meat","bread"]], supplies = ["yeast","flour","meat"]
+Output: ["bread","sandwich","burger"]
+Explanation:
+We can create "bread" since we have the ingredients "yeast" and "flour".
+We can create "sandwich" since we have the ingredient "meat" and can create the ingredient "bread".
+We can create "burger" since we have the ingredient "meat" and can create the ingredients "bread" and "sandwich".
+ 
+
+Constraints:
+
+n == recipes.length == ingredients.length
+1 <= n <= 100
+1 <= ingredients[i].length, supplies.length <= 100
+1 <= recipes[i].length, ingredients[i][j].length, supplies[k].length <= 10
+recipes[i], ingredients[i][j], and supplies[k] consist only of lowercase English letters.
+All the values of recipes and supplies combined are unique.
+Each ingredients[i] does not contain any duplicate values.
+"""
+
+class Solution:
+    def findAllRecipes(
+        self, recipes: List[str], ingredients: List[List[str]], supplies: List[str]
+    ) -> List[str]:
+        g = defaultdict(list)
+        indeg = defaultdict(int)
+        for a, b in zip(recipes, ingredients):
+            for v in b:
+                g[v].append(a)
+            indeg[a] += len(b)
+        q = supplies
+        ans = []
+        for i in q:
+            for j in g[i]:
+                indeg[j] -= 1
+                if indeg[j] == 0:
+                    ans.append(j)
+                    q.append(j)
+        return ans

2206. Divide Array Into Equal Pairs.py

@@ -0,0 +1,41 @@
+2206. Divide Array Into Equal Pairs
+'''
+You are given an integer array nums consisting of 2 * n integers.
+
+You need to divide nums into n pairs such that:
+
+Each element belongs to exactly one pair.
+The elements present in a pair are equal.
+Return true if nums can be divided into n pairs, otherwise return false.
+
+ 
+
+Example 1:
+
+Input: nums = [3,2,3,2,2,2]
+Output: true
+Explanation: 
+There are 6 elements in nums, so they should be divided into 6 / 2 = 3 pairs.
+If nums is divided into the pairs (2, 2), (3, 3), and (2, 2), it will satisfy all the conditions.
+Example 2:
+
+Input: nums = [1,2,3,4]
+Output: false
+Explanation: 
+There is no way to divide nums into 4 / 2 = 2 pairs such that the pairs satisfy every condition.
+ 
+
+Constraints:
+
+nums.length == 2 * n
+1 <= n <= 500
+1 <= nums[i] <= 500
+'''
+
+
+# Now start Solution
+# Solution
+class Solution:
+  def divideArray(self, nums: list[int]) -> bool:
+    return all(value % 2 == 0 for value in collections.Counter(nums).values())  
+ 

2226. Maximum Candies Allocated to K Children.py

@@ -0,0 +1,97 @@
+/*
+
+2226. Maximum Candies Allocated to K Children
+
+You are given a 0-indexed integer array candies. Each element in the array denotes a pile of candies of size candies[i]. You can divide each pile into any number of sub piles, but you cannot merge two piles together.
+
+You are also given an integer k. You should allocate piles of candies to k children such that each child gets the same number of candies. Each child can be allocated candies from only one pile of candies and some piles of candies may go unused.
+
+Return the maximum number of candies each child can get.
+
+ 
+
+Example 1:
+
+Input: candies = [5,8,6], k = 3
+Output: 5
+Explanation: We can divide candies[1] into 2 piles of size 5 and 3, and candies[2] into 2 piles of size 5 and 1. We now have five piles of candies of sizes 5, 5, 3, 5, and 1. We can allocate the 3 piles of size 5 to 3 children. It can be proven that each child cannot receive more than 5 candies.
+Example 2:
+
+Input: candies = [2,5], k = 11
+Output: 0
+Explanation: There are 11 children but only 7 candies in total, so it is impossible to ensure each child receives at least one candy. Thus, each child gets no candy and the answer is 0.
+ 
+
+Constraints:
+
+1 <= candies.length <= 105
+1 <= candies[i] <= 107
+1 <= k <= 1012
+'''
+*/
+
+class Solution:
+    def maximumCandies(self, candies: List[int], k: int) -> int:        
+        left, right = 1, max(candies)
+        result = 0
+        
+        while left <= right:
+            mid = (left + right) // 2
+            
+            children_count = sum(pile // mid for pile in candies)
+            
+            if children_count >= k:
+                result = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+                
+        return result
+
+# Time complexity : O(nlogm) where n is the number of piles and m is the maximum number of candies in a pile.
+# Space complexity : O(1) as we are using only constant space.
+
+// Java code
+class Solution {
+    public int maximumCandies(int[] candies, int k) {
+        int left = 1, right = Arrays.stream(candies).max().getAsInt();
+        int result = 0;
+        
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            
+            int childrenCount = Arrays.stream(candies).mapToInt(candy -> candy / mid).sum();
+            
+            if (childrenCount >= k) {
+                result = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        
+        return result;
+    }
+}
+
+// Time complexity : O(nlogm) where n is the number of piles and m is the maximum number of candies in a pile.
+// Space complexity : O(1) as we are using only constant space.
+'''
+'''
+
+from typing import List
+
+class Solution:
+    def maximumCandies(self, candies: List[int], k: int) -> int:
+        left, right = 1, max(candies)
+        result = 0
+        while left <= right:
+            mid = (left + right) // 2
+            children_count = sum(pile // mid for pile in candies)
+            if children_count >= k:
+                result = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+        return result
+'''