Maximum Candies Allocated to K Children

Author: volodimyr

179.largest_number/numbers.py

@@ -34,9 +34,7 @@ def largestNumber(self, nums: List[int]) -> str:
         def compare(x, y):
             if x + y > y + x:
                 return -1
-            elif x + y < y + x:
-                return 1
-            return 0
+            return 1
         nums_str.sort(key=cmp_to_key(compare))
         if nums_str[0] == '0':
             return nums_str[0]

2226.maximum_candies_allocated_to_K_children/max.py

@@ -0,0 +1,59 @@
+# 2226. Maximum Candies Allocated to K Children
+# Topics: 'Array', 'Binary Search'
+# Level: 'Medium'
+
+# 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
+
+from typing import List
+
+class Solution:
+    def maximumCandies(self, candies: List[int], k: int) -> int:
+        if sum(candies) < k:
+            return 0
+
+        maxx = max(candies)
+        minn = 1
+        res = 0
+        while maxx >= minn:
+            mid  = minn + (maxx-minn) // 2
+            times = 0
+            for c in candies:
+                if mid > c:
+                    continue
+                times += c // mid
+                if times >= k:
+                    break
+            if times < k:
+                maxx = mid-1
+            else:
+                res = mid
+                minn = mid+1
+        return res
+
+

2226.maximum_candies_allocated_to_K_children/test_max.py

@@ -0,0 +1,111 @@
+import unittest
+from typing import List
+from max import Solution
+
+class TestMaximumCandies(unittest.TestCase):
+    def setUp(self):
+        self.solution = Solution()
+
+    def test_example_1(self):
+        """Example 1: Basic case with 3 children"""
+        candies = [5, 8, 6]
+        k = 3
+        self.assertEqual(self.solution.maximumCandies(candies, k), 5)
+
+    def test_example_2(self):
+        """Example 2: Not enough candies"""
+        candies = [2, 5]
+        k = 11
+        self.assertEqual(self.solution.maximumCandies(candies, k), 0)
+
+    def test_single_pile_single_child(self):
+        """Single pile, single child gets all"""
+        candies = [10]
+        k = 1
+        self.assertEqual(self.solution.maximumCandies(candies, k), 10)
+
+    def test_single_pile_multiple_children(self):
+        """Single pile divided among multiple children"""
+        candies = [20]
+        k = 4
+        self.assertEqual(self.solution.maximumCandies(candies, k), 5)
+
+    def test_equal_distribution(self):
+        """All piles same size, perfect division"""
+        candies = [10, 10, 10, 10]
+        k = 4
+        self.assertEqual(self.solution.maximumCandies(candies, k), 10)
+
+    def test_one_child(self):
+        """Only one child, gets max pile"""
+        candies = [1, 2, 3, 4, 5]
+        k = 1
+        self.assertEqual(self.solution.maximumCandies(candies, k), 5)
+
+    def test_exact_division(self):
+        """Piles divide exactly into k portions"""
+        candies = [9, 12, 15]
+        k = 12
+        self.assertEqual(self.solution.maximumCandies(candies, k), 3)
+
+    def test_large_k(self):
+        """Very large k value (edge case from constraints)"""
+        candies = [1, 2, 3]
+        k = 1000000000000  # 10^12
+        self.assertEqual(self.solution.maximumCandies(candies, k), 0)
+
+    def test_all_ones(self):
+        """All piles have size 1"""
+        candies = [1, 1, 1, 1, 1]
+        k = 5
+        self.assertEqual(self.solution.maximumCandies(candies, k), 1)
+
+    def test_all_ones_too_many_children(self):
+        """All piles have size 1, but k is larger"""
+        candies = [1, 1, 1]
+        k = 5
+        self.assertEqual(self.solution.maximumCandies(candies, k), 0)
+
+    def test_large_piles(self):
+        """Large pile values"""
+        candies = [10000000, 10000000]
+        k = 2
+        self.assertEqual(self.solution.maximumCandies(candies, k), 10000000)
+
+    def test_cannot_divide_evenly(self):
+        """Candies cannot be divided evenly"""
+        candies = [7, 11]
+        k = 5
+        self.assertEqual(self.solution.maximumCandies(candies, k), 3)
+
+    def test_single_large_pile(self):
+        """Single very large pile"""
+        candies = [1000000]
+        k = 100
+        self.assertEqual(self.solution.maximumCandies(candies, k), 10000)
+
+    def test_zero_children_edge_case(self):
+        """Edge case: k = 1 (minimum from constraints)"""
+        candies = [100]
+        k = 1
+        self.assertEqual(self.solution.maximumCandies(candies, k), 100)
+
+
+def run_tests():
+    """Run all tests and display results"""
+    suite = unittest.TestLoader().loadTestsFromTestCase(TestMaximumCandies)
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    print("\n" + "="*70)
+    print(f"Tests run: {result.testsRun}")
+    print(f"Successes: {result.testsRun - len(result.failures) - len(result.errors)}")
+    print(f"Failures: {len(result.failures)}")
+    print(f"Errors: {len(result.errors)}")
+    print("="*70)
+    
+    return result.wasSuccessful()
+
+
+if __name__ == "__main__":
+    run_tests()