add solutions, explanation and update README file of the day 2064

Aarzoo · Aarzoo · commit 697e94224708 · 2024-11-14T08:03:05.000+05:30
diff --git a/Algorithms/README.md b/Algorithms/README.md
@@ -53,6 +53,7 @@
 | 2022            | Convert 1D Array Into 2D Array  | [C++](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Code/solution.cpp), [Java](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Code/solution.java), [JavaScript](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Code/solution.js), [Python](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Code/solution.py), [Go](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Code/solution.go) | [Explanation](./Algorithms/src/2022.%20Convert%201D%20Array%20Into%202D%20Array/Explanation/explanation.md)   | Easy             |
 | 2044            | Count Number of Maximum Bitwise-OR Subsets  | [C++](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Code/solution.cpp), [Java](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Code/solution.java), [JavaScript](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Code/solution.js), [Python](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Code/solution.py), [Go](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Code/solution.go) | [Explanation](./Algorithms/src/2044.%20Count%20Number%20of%20Maximum%20Bitwise-OR%20Subsets/Explanation/explanation.md)   | Medium             |
 | 2053            | Kth Distinct String in an Array  | [C++](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Code/solution.cpp), [Java](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Code/solution.java), [JavaScript](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Code/solution.js), [Python](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Code/solution.py), [Go](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Code/solution.go) | [Explanation](./Algorithms/src/2053.%20Kth%20Distinct%20String%20in%20an%20Array/Explanation/explanation.md)   | Easy             |
+| 2064            | Minimized Maximum of Products Distributed to Any Store  | [C++](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Code/solution.cpp), [Java](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Code/solution.java), [JavaScript](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Code/solution.js), [Python](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Code/solution.py), [Go](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Code/solution.go) | [Explanation](./Algorithms/src/2064.%20Minimized%20Maximum%20of%20Products%20Distributed%20to%20Any%20Store/Explanation/explanation.md)   | Medium             |
 | 2070            | Most Beautiful Item for Each Query  | [C++](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Code/solution.cpp), [Java](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Code/solution.java), [JavaScript](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Code/solution.js), [Python](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Code/solution.py), [Go](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Code/solution.go) | [Explanation](./Algorithms/src/2070.%20Most%20Beautiful%20Item%20for%20Each%20Query/Explanation/explanation.md)   | Medium             |
 | 2134            | Minimum Swaps to Group All 1's Together II  | [C++](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Code/solution.cpp), [Java](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Code/solution.java), [JavaScript](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Code/solution.js), [Python](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Code/solution.py), [Go](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Code/solution.go) | [Explanation](./Algorithms/src/2134.%20Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/Explanation/explanation.md)   | Medium             |
 | 2275            | Largest Combination With Bitwise AND Greater Than Zero  | [C++](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Code/solution.cpp), [Java](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Code/solution.java), [JavaScript](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Code/solution.js), [Python](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Code/solution.py), [Go](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Code/solution.go) | [Explanation](./Algorithms/src/2275.%20Largest%20Combination%20With%20Bitwise%20AND%20Greater%20Than%20Zero/Explanation/explanation.md)   | Medium             |
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.cpp b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.cpp
@@ -0,0 +1,42 @@
+#include <vector>
+#include <cmath>
+#include <algorithm>
+
+class Solution
+{
+public:
+    bool canDistribute(const std::vector<int> &quantities, int maxProducts, int n)
+    {
+        int storesNeeded = 0;
+        for (int quantity : quantities)
+        {
+            storesNeeded += std::ceil((double)quantity / maxProducts);
+            if (storesNeeded > n)
+                return false;
+        }
+        return storesNeeded <= n;
+    }
+
+    int minimizedMaximum(int n, std::vector<int> &quantities)
+    {
+        int low = 1;
+        int high = *std::max_element(quantities.begin(), quantities.end());
+        int answer = high;
+
+        while (low <= high)
+        {
+            int mid = low + (high - low) / 2;
+            if (canDistribute(quantities, mid, n))
+            {
+                answer = mid;
+                high = mid - 1;
+            }
+            else
+            {
+                low = mid + 1;
+            }
+        }
+
+        return answer;
+    }
+};
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.go b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.go
@@ -0,0 +1,34 @@
+import "math"
+
+func minimizedMaximum(n int, quantities []int) int {
+    canDistribute := func(maxProducts int) bool {
+        storesNeeded := 0
+        for _, quantity := range quantities {
+            storesNeeded += int(math.Ceil(float64(quantity) / float64(maxProducts)))
+            if storesNeeded > n {
+                return false
+            }
+        }
+        return storesNeeded <= n
+    }
+
+    low, high := 1, 0
+    for _, quantity := range quantities {
+        if quantity > high {
+            high = quantity
+        }
+    }
+    answer := high
+
+    for low <= high {
+        mid := low + (high - low) / 2
+        if canDistribute(mid) {
+            answer = mid
+            high = mid - 1
+        } else {
+            low = mid + 1
+        }
+    }
+
+    return answer
+}
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.java b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.java
@@ -0,0 +1,29 @@
+class Solution {
+    private boolean canDistribute(int[] quantities, int maxProducts, int n) {
+        int storesNeeded = 0;
+        for (int quantity : quantities) {
+            storesNeeded += (int) Math.ceil((double) quantity / maxProducts);
+            if (storesNeeded > n)
+                return false;
+        }
+        return storesNeeded <= n;
+    }
+
+    public int minimizedMaximum(int n, int[] quantities) {
+        int low = 1;
+        int high = Arrays.stream(quantities).max().getAsInt();
+        int answer = high;
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            if (canDistribute(quantities, mid, n)) {
+                answer = mid;
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        return answer;
+    }
+}
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.js b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number[]} quantities
+ * @return {number}
+ */
+var minimizedMaximum = function (n, quantities) {
+  const canDistribute = (maxProducts) => {
+    let storesNeeded = 0;
+    for (const quantity of quantities) {
+      storesNeeded += Math.ceil(quantity / maxProducts);
+      if (storesNeeded > n) return false;
+    }
+    return storesNeeded <= n;
+  };
+
+  let low = 1;
+  let high = Math.max(...quantities);
+  let answer = high;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (canDistribute(mid)) {
+      answer = mid;
+      high = mid - 1;
+    } else {
+      low = mid + 1;
+    }
+  }
+
+  return answer;
+};
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.py b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Code/solution.py
@@ -0,0 +1,25 @@
+import math
+from typing import List
+
+class Solution:
+    def minimizedMaximum(self, n: int, quantities: List[int]) -> int:
+        def canDistribute(maxProducts):
+            storesNeeded = 0
+            for quantity in quantities:
+                storesNeeded += math.ceil(quantity / maxProducts)
+                if storesNeeded > n:
+                    return False
+            return storesNeeded <= n
+
+        low, high = 1, max(quantities)
+        answer = high
+
+        while low <= high:
+            mid = (low + high) // 2
+            if canDistribute(mid):
+                answer = mid
+                high = mid - 1
+            else:
+                low = mid + 1
+
+        return answer
diff --git a/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Explanation/explanation.md b/Algorithms/src/2064. Minimized Maximum of Products Distributed to Any Store/Explanation/explanation.md
@@ -0,0 +1,152 @@
+# Minimized Maximum Distribution - Step-by-Step Explanation
+
+This README provides a step-by-step breakdown of the solution for the problem of minimizing the maximum number of products any store can receive when distributing products among multiple stores. The solution is implemented in multiple languages: C++, Java, JavaScript, Python, and Go.
+
+The solution uses **binary search** on the potential maximum number of products per store and checks the feasibility of each mid-point using a helper function.
+
+## Problem Summary
+
+- **Goal**: Distribute products among `n` stores to minimize the maximum number of products any store receives.
+- **Approach**: Use binary search to find the smallest feasible "maximum products per store".
+
+---
+
+## Approach Overview
+
+The following steps outline the common approach used in all languages:
+
+1. **Initialize Binary Search Range**:
+   - Set `low` to 1 (minimum possible max products per store).
+   - Set `high` to the maximum value in the `quantities` array, representing the initial upper bound for products per store.
+
+2. **Binary Search Loop**:
+   - Calculate the midpoint `mid` between `low` and `high`.
+   - Use a helper function to check if it’s feasible to distribute products such that no store has more than `mid` products.
+     - For each product type, calculate the number of stores required to hold its quantity without exceeding `mid` per store.
+   - If the distribution is feasible with `mid`, update `high` to `mid - 1` to try for a smaller maximum.
+   - If not feasible, update `low` to `mid + 1` to allow more products per store.
+
+3. **Return the Result**:
+   - After the binary search concludes, `low` will hold the minimum possible maximum products per store for an optimal distribution.
+
+---
+
+## Language-Specific Explanation
+
+---
+
+### C++ Code
+
+1. **Define Helper Function**:
+   - Implement a helper function to check if it’s feasible to distribute products with `mid` as the maximum limit.
+   - For each product type, compute the number of stores required if each store receives no more than `mid` products.
+
+2. **Binary Search Setup**:
+   - Set `low` to 1 and `high` to the maximum quantity in the array.
+   - Initialize `answer` to store the optimal maximum products per store.
+
+3. **Binary Search Execution**:
+   - Calculate `mid`, the midpoint between `low` and `high`.
+   - Use the helper function to check if distributing with `mid` is feasible.
+   - If feasible, set `high = mid - 1` and update `answer`.
+   - If not feasible, set `low = mid + 1`.
+
+4. **Return the Result**:
+   - Return `answer`, which now holds the minimized maximum products per store.
+
+---
+
+### Java Code
+
+1. **Define Helper Method**:
+   - Create a helper method that takes `quantities`, `maxProducts`, and `n` as inputs.
+   - Loop over `quantities` and calculate the required number of stores for each product type under the `maxProducts` limit.
+
+2. **Binary Search Initialization**:
+   - Set `low` to 1 and `high` to the maximum value in `quantities`.
+   - Initialize `answer` to store the smallest possible maximum products per store.
+
+3. **Execute Binary Search**:
+   - Find `mid` as the average of `low` and `high`.
+   - Use the helper method to verify if distributing with `mid` is possible.
+   - If feasible, set `high = mid - 1` and update `answer`.
+   - If not feasible, set `low = mid + 1`.
+
+4. **Return the Solution**:
+   - Return `answer` after completing the search for the minimized maximum.
+
+---
+
+### JavaScript Code
+
+1. **Define Helper Function**:
+   - Write a helper function that calculates if `mid` products per store is feasible.
+   - For each product in `quantities`, calculate the number of stores required to meet `mid` constraints.
+
+2. **Initialize Binary Search Variables**:
+   - Set `low` to 1 and `high` to the maximum element in `quantities`.
+   - Initialize `answer` to store the minimal feasible "maximum products per store".
+
+3. **Run Binary Search**:
+   - Compute `mid` as the midpoint between `low` and `high`.
+   - Check feasibility using the helper function.
+   - If feasible, update `high` to `mid - 1` and set `answer` to `mid`.
+   - If not, update `low` to `mid + 1`.
+
+4. **Final Output**:
+   - Return `answer`, which holds the minimized maximum value for product distribution.
+
+---
+
+### Python Code
+
+1. **Define Feasibility Check Function**:
+   - Implement a function to check if distributing products with a maximum of `mid` per store is possible.
+   - Loop through `quantities`, calculating the required stores for each product type under the `mid` constraint.
+
+2. **Binary Search Preparation**:
+   - Set `low` to 1 and `high` to the maximum value in `quantities`.
+   - Use `answer` to store the minimum possible maximum products per store.
+
+3. **Binary Search Execution**:
+   - Calculate `mid` as the midpoint between `low` and `high`.
+   - If the helper function determines that `mid` is feasible, set `high = mid - 1` and update `answer`.
+   - If not feasible, increase `low` to `mid + 1`.
+
+4. **Return Result**:
+   - Return `answer`, the minimized maximum products per store for an optimal distribution.
+
+---
+
+### Go Code
+
+1. **Define Helper Function**:
+   - Implement a helper function to check if distributing products with a maximum of `mid` per store is feasible.
+   - For each quantity, calculate the required number of stores under the `mid` constraint.
+
+2. **Binary Search Initialization**:
+   - Set `low` to 1 and `high` to the maximum value in `quantities`.
+   - Store the answer in a variable `answer` for the minimized maximum value.
+
+3. **Binary Search Execution**:
+   - Calculate `mid` as the average of `low` and `high`.
+   - Check feasibility using the helper function.
+   - If feasible, set `high = mid - 1` and update `answer`.
+   - If not, set `low = mid + 1`.
+
+4. **Return the Solution**:
+   - After the search, return `answer`, which holds the minimized maximum number of products per store.
+
+---
+
+## Complexity Analysis
+
+- **Time Complexity**: \(O(m \log(\text{max}(\text{quantities})))\)
+  - The binary search range is bounded by the maximum value in `quantities`, leading to \(O(\log(\text{max}(\text{quantities})))\) iterations.
+  - Each iteration involves a feasibility check that takes \(O(m)\) time, where \(m\) is the number of product types.
+
+- **Space Complexity**: \(O(1)\), since we use a constant amount of extra space.
+
+---
+
+Each implementation follows the same logic with slight variations in syntax and function handling. This method ensures that the maximum number of products per store is minimized for optimal distribution.
diff --git a/README.md b/README.md
