23:I[344796,["/_next/static/chunks/083cs_iw_ie0y.js","/_next/static/chunks/2sk2f47durg8o.js","/_next/static/chunks/00mfjk9z2ewie.js","/_next/static/chunks/0ynk8uq7fqs0l.js","/_next/static/chunks/0uf80u9-0x190.js","/_next/static/chunks/0fxdv63hya-rx.js","/_next/static/chunks/2qcnia-og0qh0.js","/_next/static/chunks/10fiiv3_svxbv.js"],"default"] 2b:I[27201,["/_next/static/chunks/083cs_iw_ie0y.js","/_next/static/chunks/2sk2f47durg8o.js","/_next/static/chunks/00mfjk9z2ewie.js","/_next/static/chunks/0ynk8uq7fqs0l.js","/_next/static/chunks/0uf80u9-0x190.js","/_next/static/chunks/0fxdv63hya-rx.js","/_next/static/chunks/2qcnia-og0qh0.js"],"IconMark"] 24:T1401,

Partition Computational Units

A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i]. The units must be handed out to exactly k models, and a model always receives a contiguous block of the row, so the row is cut into k consecutive non-empty blocks that together cover all n units.

A model that receives a block of length m only runs if the capacities inside that block are exactly 1, 2, ..., m in some order — a permutation of 1..m. Any unit inside a block may be replaced by a unit of any capacity you like; one replaced unit costs one operation.

Let minOp be the smallest total number of replacements over all ways of cutting the row into k blocks. Report the block lengths of a cut that achieves minOp. If several cuts achieve minOp, report the lexicographically smallest list of lengths modelCap.

Input Format

The first line contains an integer n, the number of computational units.
Each of the next n lines contains an integer storage[i].
The last line contains an integer k, the number of models.

Output Format

Print k lines. Line i holds modelCap[i], the number of units given to the i-th model, for the lexicographically smallest modelCap among all cuts that need only minOp replacements.

Constraints

1 <= n <= 100
1 <= k <= n
1 <= storage[i] <= 100

Examples

Example 1

Input:

Output:

1
5

Explanation: storage = [2, 3, 1, 5, 6, 2] and k = 2. The cut [[2], [3, 1, 5, 6, 2]] turns [2] into [1] with one replacement and [3, 1, 5, 6, 2] into [3, 1, 5, 4, 2] with one more, so minOp = 2. No cut into two blocks does better, and [1, 5] is the smallest length list that reaches 2.

Example 2

Input:

Output:

4
1
2

Explanation: storage = [4, 2, 1, 3, 1, 1, 2] and k = 3. The cut [[4, 2, 1, 3], [1], [1, 2]] leaves every block already a permutation, so minOp = 0. A first block of length 1, 2 or 3 would force at least one replacement, so 4 really is the smallest possible first length here — lexicographic minimality is applied only among the cuts that cost minOp.

Example 3

Input:

Output:

Explanation: k = n, so the only cut is into four single units. Blocks [2], [3] and [4] each need one replacement and minOp = 3.

Example 4

Input:

Output:

1
1
3

Explanation: every unit has capacity 5. A block shorter than five units can keep nothing, and a block of length five can keep a single 5, so every cut of these five units into three blocks costs 5 replacements. All cuts tie, and [1, 1, 3] is the lexicographically smallest list of three positive lengths summing to 5.

Notes

The blocks are contiguous and in order: block 1 starts at storage[0], and each later block starts right where the previous one ended. The lengths therefore sum to n.
Every block must be non-empty, so a cut into k blocks exists exactly when k <= n.
Duplicate capacities are allowed and are common; two units with the same capacity cannot both survive inside one block, since a permutation has no repeats.
A block of length m can keep a unit only if its capacity lies in [1, m]; a capacity above m is useless there no matter what the rest of the block looks like.
modelCap lists lengths, not capacities of individual units. Comparison is the usual list order: compare the first entries, then the second, and so on.
Lexicographic minimality is a tie-break inside the set of cuts of cost minOp. A shorter first block that raises the total replacement count is never allowed, as Example 2 shows.
storage[i] may exceed n; such a unit is unusable in every block and always has to be replaced.

25:T8c2,#include using namespace std; static const int INF = 1000000000; // cost[i][j] = replacements needed to turn storage[i..j] into a permutation of // 1..(j-i+1): length minus the number of DISTINCT values already in [1,length]. vector getModelCapacities(const vector &storage, int k) { int n = (int)storage.size(); if (k < 1 || k > n) return {}; vector> cost(n, vector(n, 0)); for (int i = 0; i < n; ++i) { for (int j = i; j < n; ++j) { int m = j - i + 1; vector seen(m + 1, 0); int keep = 0; for (int x = i; x <= j; ++x) { int v = storage[x]; if (v >= 1 && v <= m && !seen[v]) { seen[v] = 1; ++keep; } } cost[i][j] = m - keep; } } // dp[t][i] = minimum replacements to cut storage[i..n-1] into exactly t parts vector> dp(k + 1, vector(n + 1, INF)); dp[0][n] = 0; for (int t = 1; t <= k; ++t) { int limit = n - t; for (int i = limit; i >= 0; --i) { int best = INF; for (int j = i; j <= limit; ++j) { int nxt = dp[t - 1][j + 1]; if (nxt < INF) { int c = cost[i][j] + nxt; if (c < best) best = c; } } dp[t][i] = best; } } if (dp[k][0] >= INF) return {}; vector res; int curr = 0; for (int t = k; t >= 1; --t) { int limit = n - t; for (int j = curr; j <= limit; ++j) { if (dp[t - 1][j + 1] < INF && cost[curr][j] + dp[t - 1][j + 1] == dp[t][curr]) { res.push_back(j - curr + 1); curr = j + 1; break; } } } return res; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; if (!(cin >> n)) return 0; vector storage(n); for (int i = 0; i < n; ++i) cin >> storage[i]; int k; if (!(cin >> k)) return 0; vector res = getModelCapacities(storage, k); string out; for (int v : res) { out += to_string(v); out += '\n'; } cout << out; return 0; } 26:T8b3,import sys INF = 10 ** 9 def build_cost(storage): """cost[i][j] = replacements needed to turn storage[i..j] into a permutation of 1..(j-i+1): length minus the number of DISTINCT values of the segment that already lie in [1, length].""" n = len(storage) cost = [[0] * n for _ in range(n)] for i in range(n): for j in range(i, n): m = j - i + 1 seen = [False] * (m + 1) keep = 0 for x in range(i, j + 1): v = storage[x] if 1 <= v <= m and not seen[v]: seen[v] = True keep += 1 cost[i][j] = m - keep return cost def getModelCapacities(storage, k): n = len(storage) if k < 1 or k > n: return [] cost = build_cost(storage) # dp[t][i] = minimum replacements to cut storage[i..n-1] into exactly t parts dp = [[INF] * (n + 1) for _ in range(k + 1)] dp[0][n] = 0 for t in range(1, k + 1): limit = n - t # a first segment may end no later than this for i in range(limit, -1, -1): best = INF row = cost[i] prev = dp[t - 1] for j in range(i, limit + 1): nxt = prev[j + 1] if nxt < INF: c = row[j] + nxt if c < best: best = c dp[t][i] = best if dp[k][0] >= INF: return [] # Lexicographically smallest length list: at every step take the SHORTEST # first segment that still leaves an optimal remainder. res = [] curr = 0 for t in range(k, 0, -1): limit = n - t for j in range(curr, limit + 1): if dp[t - 1][j + 1] < INF and cost[curr][j] + dp[t - 1][j + 1] == dp[t][curr]: res.append(j - curr + 1) curr = j + 1 break return res def main(): data = sys.stdin.buffer.read().split() if not data: return n = int(data[0]) storage = [int(v) for v in data[1:1 + n]] k = int(data[1 + n]) sys.stdout.write("".join(str(v) + "\n" for v in getModelCapacities(storage, k))) if __name__ == "__main__": main() 27:Td4f,import java.io.DataInputStream; import java.io.IOException; public class Main { static final int INF = 1000000000; static int[] getModelCapacities(int[] storage, int k) { int n = storage.length; if (k < 1 || k > n) return new int[0]; int[][] cost = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { int m = j - i + 1; boolean[] seen = new boolean[m + 1]; int keep = 0; for (int x = i; x <= j; x++) { int v = storage[x]; if (v >= 1 && v <= m && !seen[v]) { seen[v] = true; keep++; } } cost[i][j] = m - keep; } } int[][] dp = new int[k + 1][n + 1]; for (int[] row : dp) java.util.Arrays.fill(row, INF); dp[0][n] = 0; for (int t = 1; t <= k; t++) { int limit = n - t; for (int i = limit; i >= 0; i--) { int best = INF; for (int j = i; j <= limit; j++) { int nxt = dp[t - 1][j + 1]; if (nxt < INF) { int c = cost[i][j] + nxt; if (c < best) best = c; } } dp[t][i] = best; } } if (dp[k][0] >= INF) return new int[0]; int[] res = new int[k]; int cnt = 0, curr = 0; for (int t = k; t >= 1; t--) { int limit = n - t; for (int j = curr; j <= limit; j++) { if (dp[t - 1][j + 1] < INF && cost[curr][j] + dp[t - 1][j + 1] == dp[t][curr]) { res[cnt++] = j - curr + 1; curr = j + 1; break; } } } int[] trimmed = new int[cnt]; System.arraycopy(res, 0, trimmed, 0, cnt); return trimmed; } public static void main(String[] args) throws IOException { FastReader in = new FastReader(); int n = in.nextInt(); int[] storage = new int[n]; for (int i = 0; i < n; i++) storage[i] = in.nextInt(); int k = in.nextInt(); StringBuilder sb = new StringBuilder(); for (int v : getModelCapacities(storage, k)) sb.append(v).append('\n'); System.out.print(sb); } static class FastReader { private final DataInputStream din = new DataInputStream(System.in); private final byte[] buffer = new byte[1 << 16]; private int pointer = 0, bytesRead = 0; int nextInt() throws IOException { return (int) nextLong(); } long nextLong() throws IOException { long ret = 0; int b = read(); while (b != -1 && b <= ' ') b = read(); boolean neg = b == '-'; if (neg) b = read(); while (b >= '0' && b <= '9') { ret = ret * 10 + (b - '0'); b = read(); } return neg ? -ret : ret; } private int read() throws IOException { if (pointer == bytesRead) { bytesRead = din.read(buffer, 0, buffer.length); pointer = 0; if (bytesRead <= 0) { bytesRead = 0; return -1; } } return buffer[pointer++]; } } } 28:T6de,import java.io.DataInputStream; import java.io.IOException; public class Main { // Return the lexicographically smallest list of k block lengths // that needs the minimum number of replacements. static int[] getModelCapacities(int[] storage, int k) { // Write your code here return new int[0]; } public static void main(String[] args) throws IOException { FastReader in = new FastReader(); int n = in.nextInt(); int[] storage = new int[n]; for (int i = 0; i < n; i++) storage[i] = in.nextInt(); int k = in.nextInt(); StringBuilder sb = new StringBuilder(); for (int v : getModelCapacities(storage, k)) sb.append(v).append('\n'); System.out.print(sb); } static class FastReader { private final DataInputStream din = new DataInputStream(System.in); private final byte[] buffer = new byte[1 << 16]; private int pointer = 0, bytesRead = 0; int nextInt() throws IOException { return (int) nextLong(); } long nextLong() throws IOException { long ret = 0; int b = read(); while (b != -1 && b <= ' ') b = read(); boolean neg = b == '-'; if (neg) b = read(); while (b >= '0' && b <= '9') { ret = ret * 10 + (b - '0'); b = read(); } return neg ? -ret : ret; } private int read() throws IOException { if (pointer == bytesRead) { bytesRead = din.read(buffer, 0, buffer.length); pointer = 0; if (bytesRead <= 0) { bytesRead = 0; return -1; } } return buffer[pointer++]; } } } 29:Tf4a,# Partition Computational Units A machine learning cluster owns `n` computational units in a fixed row. Unit `i` has capacity `storage[i]`. The units must be handed out to exactly `k` models, and a model always receives a **contiguous block** of the row, so the row is cut into `k` consecutive non-empty blocks that together cover all `n` units. A model that receives a block of length `m` only runs if the capacities inside that block are exactly `1, 2, ..., m` in some order — a permutation of `1..m`. Any unit inside a block may be **replaced** by a unit of any capacity you like; one replaced unit costs one operation. Let `minOp` be the smallest total number of replacements over all ways of cutting the row into `k` blocks. Report the block lengths of a cut that achieves `minOp`. If several cuts achieve `minOp`, report the **lexicographically smallest** list of lengths `modelCap`. ## Input Format - The first line contains an integer `n`, the number of computational units. - Each of the next `n` lines contains an integer `storage[i]`. - The last line contains an integer `k`, the number of models. ## Output Format Print `k` lines. Line `i` holds `modelCap[i]`, the number of units given to the `i`-th model, for the lexicographically smallest `modelCap` among all cuts that need only `minOp` replacements. ## Constraints - `1 <= n <= 100` - `1 <= k <= n` - `1 <= storage[i] <= 100` ## Examples **Example 1** Input: ```text 6 2 3 1 5 6 2 2 ``` Output: ```text 1 5 ``` Explanation: `storage = [2, 3, 1, 5, 6, 2]` and `k = 2`. The cut `[[2], [3, 1, 5, 6, 2]]` turns `[2]` into `[1]` with one replacement and `[3, 1, 5, 6, 2]` into `[3, 1, 5, 4, 2]` with one more, so `minOp = 2`. No cut into two blocks does better, and `[1, 5]` is the smallest length list that reaches `2`. **Example 2** Input: ```text 7 4 2 1 3 1 1 2 3 ``` Output: ```text 4 1 2 ``` Explanation: `storage = [4, 2, 1, 3, 1, 1, 2]` and `k = 3`. The cut `[[4, 2, 1, 3], [1], [1, 2]]` leaves every block already a permutation, so `minOp = 0`. A first block of length 1, 2 or 3 would force at least one replacement, so `4` really is the smallest possible first length here — lexicographic minimality is applied only among the cuts that cost `minOp`. **Example 3** Input: ```text 4 1 2 3 4 4 ``` Output: ```text 1 1 1 1 ``` Explanation: `k = n`, so the only cut is into four single units. Blocks `[2]`, `[3]` and `[4]` each need one replacement and `minOp = 3`. **Example 4** Input: ```text 5 5 5 5 5 5 3 ``` Output: ```text 1 1 3 ``` Explanation: every unit has capacity `5`. A block shorter than five units can keep nothing, and a block of length five can keep a single `5`, so every cut of these five units into three blocks costs `5` replacements. All cuts tie, and `[1, 1, 3]` is the lexicographically smallest list of three positive lengths summing to `5`. ## Notes - The blocks are contiguous and in order: block `1` starts at `storage[0]`, and each later block starts right where the previous one ended. The lengths therefore sum to `n`. - Every block must be non-empty, so a cut into `k` blocks exists exactly when `k <= n`. - Duplicate capacities are allowed and are common; two units with the same capacity cannot both survive inside one block, since a permutation has no repeats. - A block of length `m` can keep a unit only if its capacity lies in `[1, m]`; a capacity above `m` is useless there no matter what the rest of the block looks like. - `modelCap` lists **lengths**, not capacities of individual units. Comparison is the usual list order: compare the first entries, then the second, and so on. - Lexicographic minimality is a tie-break *inside* the set of cuts of cost `minOp`. A shorter first block that raises the total replacement count is never allowed, as Example 2 shows. - `storage[i]` may exceed `n`; such a unit is unusable in every block and always has to be replaced. 2a:T10a4,# Editorial — Partition Computational Units ## What the problem really asks The row of `n` capacities is cut into `k` consecutive non-empty blocks. Two numbers come out of a cut: its total replacement cost, and its list of block lengths. Cost is minimised first; the length list is only a tie-break among the cheapest cuts. Reading it the other way round — smallest first block, then worry about cost — is wrong, and Example 2 is the witness: `storage = [4, 2, 1, 3, 1, 1, 2]` with `k = 3` answers `[4, 1, 2]`, not `[1, ...]`. ## Step 1 — the cost of one block Take a block of length `m`. It has to end up as a permutation of `1..m`. You may overwrite any position with any capacity, so the only question is how many positions you can *leave alone*. A kept position must carry a capacity in `[1, m]` — a bigger capacity has no place in a permutation of `1..m` — and no two kept positions may carry the same capacity, because a permutation has no repeats. Conversely, any set of positions whose capacities are distinct and inside `[1, m]` can be kept: the values they miss are exactly as numerous as the remaining positions, so write the missing values into them in any order. So the largest keepable set has size ``` keep(i, j) = #{ distinct values v with 1 <= v <= m that occur in storage[i..j] }, m = j - i + 1 ``` and the block cost is ``` cost(i, j) = m - keep(i, j) ``` A duplicate never helps: a second `2` in a block is dead weight, exactly like a capacity of `97` in a block of length `5`. Both facts are easy to get wrong, and both are worth a test. Computing `cost` for all `O(n^2)` blocks by a straight scan is `O(n^3)` — with `n <= 100` that is a million operations, instantly fast. (An `O(n^2)` version exists: extend `j` by one, which both adds one value and widens the acceptance window by one, and update a multiplicity table. It is not needed here.) ## Step 2 — the minimum number of replacements Let `dp[t][i]` be the cheapest way to cut the suffix `storage[i..n-1]` into exactly `t` blocks: ``` dp[0][n] = 0 dp[t][i] = min over j in [i, n-t] of cost(i, j) + dp[t-1][j+1] ``` The bound `j <= n - t` is what forces every one of the remaining `t - 1` blocks to be non-empty. The answer is `minOp = dp[k][0]`, and the table is `O(n^2 k)` to fill, at most a million steps. ## Step 3 — the lexicographically smallest length list Lexicographic minimality decomposes greedily, and the DP table is exactly what makes the greedy step legal. Standing at position `curr` with `t` blocks left to place, scan `j` upward from `curr` and stop at the **first** `j` with ``` cost(curr, j) + dp[t-1][j+1] == dp[t][curr] ``` That first hit is the shortest first block that still leaves an optimal remainder, which is precisely what a lexicographically smallest list needs at that position. Because the remainder is again an optimal sub-problem of the same shape, repeating the step from `j + 1` with `t - 1` blocks keeps the invariant, and after `k` steps the list is complete. No comparison of whole lists is ever required. Total complexity: `O(n^3 + n^2 k)` time, `O(n^2 + nk)` memory. ## Worked check on Example 1 `storage = [2, 3, 1, 5, 6, 2]`, `k = 2`. The single-block costs from position `0` are `1, 1, 0, 1, 1, 2` for lengths `1..6`, and the cheapest way to finish the suffix with one block is `1` from index `1`. So `dp[2][0] = min(1 + 1, ...) = 2`, and the very first `j` that attains it is `j = 0` — a block of length `1`. The remaining `[3, 1, 5, 6, 2]` is forced, giving `[1, 5]`. ## Traps - **Optimise cost first.** The greedy "shortest block that is itself cheap" answer is wrong; the block length is chosen only among cuts already known to reach `minOp`. - **Duplicates.** Count *distinct* values in range, not occurrences. - **The upper bound.** A capacity is usable in a block of length `m` only when it is at most `m`. The same unit can be usable in a longer block and useless in a shorter one, which is why the cost table is per-block and not per-position. - **Capacities above `n`.** They are legal input and are simply never keepable. - **Off-by-one on the block budget.** Forgetting `j <= n - t` lets a later block come out empty, and the reconstruction then returns fewer than `k` numbers. 1c:[["$","script",null,{"type":"application/ld+json","dangerouslySetInnerHTML":{"__html":"{\"@context\":\"https://schema.org\",\"@type\":\"LearningResource\",\"learningResourceType\":\"Coding Question\",\"name\":\"Partition Computational Units\",\"description\":\"Partition Computational Units A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i] . The units must be handed out to exactly k models, and a model always receives a contiguous block of the row, so the row is cut into k consecutive non-empty blocks that together cover all n units. A model that receives a block of length m only runs if the capacities inside that block are exactly 1, 2, ..., m in some order — a permutation of 1..m . Any unit inside a\",\"educationalLevel\":\"medium\",\"about\":{\"@type\":\"Organization\",\"name\":\"AT&T_12thjuly\"},\"provider\":{\"@type\":\"Organization\",\"name\":\"OAHelper\",\"url\":\"https://oahelper.in\"},\"isPartOf\":{\"@type\":\"WebSite\",\"name\":\"OAHelper\",\"url\":\"https://oahelper.in\"},\"url\":\"https://oahelper.in/problems/MzU5M3ww/partition-computational-units\"}"}}],["$","script",null,{"type":"application/ld+json","dangerouslySetInnerHTML":{"__html":"{\"@context\":\"https://schema.org\",\"@type\":\"BreadcrumbList\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https://oahelper.in/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Problems\",\"item\":\"https://oahelper.in/problems\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Partition Computational Units\",\"item\":\"https://oahelper.in/problems/MzU5M3ww/partition-computational-units\"}]}"}}],["$","section",null,{"className":"sr-only","aria-hidden":"true","children":[["$","p",null,{"children":["Company: ","AT&T_12thjuly"]}],["$","p",null,{"children":["Difficulty: ","medium"]}],false,["$","div",null,{"children":[["$","h2",null,{"children":"Problem Statement"}],["$","p",null,{"children":"Partition Computational Units A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i] . The units must be handed out to exactly k models, and a model always receives a contiguous block of the row, so the row is cut into k consecutive non-empty blocks that together cover all n units. A model that receives a block of length m only runs if the capacities inside that block are exactly 1, 2, ..., m in some order — a permutation of 1..m . Any unit inside a block may be replaced by a unit of any capacity you like; one replaced unit costs one operation. Let minOp be the smallest total number of replacements over all ways of cutting the row into k blocks. Report the block lengths of a cut that achieves minOp . If several cuts achieve minOp , report the lexicographically smallest list of lengths modelCap . Input Format The first line contains an integer n , the number of computational units. Each of the next n lines contains an integer storage[i] . Th"}]]}],false,["$","nav",null,{"aria-label":"Related company pages","children":[["$","$Lb",null,{"href":"/company-questions/att12thjuly","children":["More ","AT&T_12thjuly"," OA questions"]}],["$","$Lb",null,{"href":"/interview-experiences","children":"Interview experiences"}]]}]]}],["$","$L23",null,{"id":"MzU5M3ww","initialQuestion":{"id":"MzU5M3ww","title":"Partition Computational Units","google_doc_link":null,"problem_statement":"$24","solution_cpp":"$25","solution_python":"$26","solution_java":"$27","pregiven_code_cpp":"#include \nusing namespace std;\n\n// Return the lexicographically smallest list of k block lengths\n// that needs the minimum number of replacements.\nvector getModelCapacities(vector storage, int k) {\n // Write your code here\n return {};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n;\n if (!(cin >> n)) return 0;\n vector storage(n);\n for (int i = 0; i < n; ++i) cin >> storage[i];\n int k;\n if (!(cin >> k)) return 0;\n vector res = getModelCapacities(storage, k);\n for (int v : res) cout << v << \"\\n\";\n return 0;\n}\n","pregiven_code_python":"import sys\n\n\ndef getModelCapacities(storage, k):\n \"\"\"Return the lexicographically smallest list of k block lengths\n that needs the minimum number of replacements.\"\"\"\n # Write your code here\n return []\n\n\ndef main():\n data = sys.stdin.buffer.read().split()\n if not data:\n return\n n = int(data[0])\n storage = [int(v) for v in data[1:1 + n]]\n k = int(data[1 + n])\n sys.stdout.write(\"\".join(str(v) + \"\\n\" for v in getModelCapacities(storage, k)))\n\n\nif __name__ == \"__main__\":\n main()\n","pregiven_code_java":"$28","difficulty":"medium","question_type":"coding","premium_required":0,"created_at":"2026-03-05T10:26:30.66715+00:00","updated_at":"2026-08-19T08:19:26.54667+00:00","solution_code":null,"solution":null,"pregiven_code":"#include \nusing namespace std;\n\n// Return the lexicographically smallest list of k block lengths\n// that needs the minimum number of replacements.\nvector getModelCapacities(vector storage, int k) {\n // Write your code here\n return {};\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n int n;\n if (!(cin >> n)) return 0;\n vector storage(n);\n for (int i = 0; i < n; ++i) cin >> storage[i];\n int k;\n if (!(cin >> k)) return 0;\n vector res = getModelCapacities(storage, k);\n for (int v : res) cout << v << \"\\n\";\n return 0;\n}\n","input_test_case":"[\"6\\n2\\n3\\n1\\n5\\n6\\n2\\n2\\n\", \"7\\n4\\n2\\n1\\n3\\n1\\n1\\n2\\n3\\n\"]","output_test_case":"[\"1\\n5\\n\", \"4\\n1\\n2\\n\"]","lc_tags":"[\"Dynamic Programming\", \"Array\", \"Greedy\", \"Hash Table\"]","visual_animation":null,"difficulty_score":55,"md_problem_statement":"$29","unique_company_name":"at&t","sql_solution":null,"bash_solution":null,"js_solution":null,"editorial":"$2a","hidden_test_cases_blob_count":80,"youtube_tutorial":null,"prompt_solution":null,"campus_type":null,"college_name":null,"role":null,"hidden_test_cases_ref":null,"is_mock_oa":false,"publication_status":"published","has_image":true,"company_name":"AT&T_12thjuly","is_first_in_company":true,"company_ref":"MTI5MXww","total_test_cases":15,"hidden_test_cases_count":13},"isQotdToday":false,"qotdReward":5}]] 1e:null 22:[["$","title","0",{"children":"Partition Computational Units - AT&T_12thjuly OA Question | OAHelper"}],["$","meta","1",{"name":"description","content":"Partition Computational Units (AT&T_12thjuly OA) - medium: Partition Computational Units A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i] . The units must be handed ou…"}],["$","meta","2",{"name":"author","content":"OAHelper Team"}],["$","meta","3",{"name":"keywords","content":"AT&T_12thjuly OA question, AT&T_12thjuly online assessment, Partition Computational Units, medium, online assessment, coding question, OA practice, interview preparation"}],["$","meta","4",{"name":"robots","content":"index, follow"}],["$","meta","5",{"name":"googlebot","content":"index, follow, max-video-preview:-1, max-image-preview:large, max-snippet:-1"}],["$","link","6",{"rel":"canonical","href":"https://oahelper.in/problems/MzU5M3ww/partition-computational-units"}],["$","meta","7",{"name":"google-site-verification","content":"MCxApq58khiH0y4KRigRUpoTS3ckefkhoCSHRIRLiXo"}],["$","meta","8",{"property":"og:title","content":"Partition Computational Units - AT&T_12thjuly OA Question | OAHelper"}],["$","meta","9",{"property":"og:description","content":"Partition Computational Units (AT&T_12thjuly OA) - medium: Partition Computational Units A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i] . The units must be handed ou…"}],["$","meta","10",{"property":"og:url","content":"https://oahelper.in/problems/MzU5M3ww/partition-computational-units"}],["$","meta","11",{"property":"og:site_name","content":"OAHelper"}],["$","meta","12",{"property":"og:image","content":"https://oahelper.in/campus-ceo-favicon.png?v=11"}],["$","meta","13",{"property":"og:image:width","content":"256"}],["$","meta","14",{"property":"og:image:height","content":"256"}],["$","meta","15",{"property":"og:image:alt","content":"Partition Computational Units - AT&T_12thjuly OA Question"}],["$","meta","16",{"property":"og:type","content":"website"}],["$","meta","17",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","18",{"name":"twitter:title","content":"Partition Computational Units - AT&T_12thjuly OA Question | OAHelper"}],["$","meta","19",{"name":"twitter:description","content":"Partition Computational Units (AT&T_12thjuly OA) - medium: Partition Computational Units A machine learning cluster owns n computational units in a fixed row. Unit i has capacity storage[i] . The units must be handed ou…"}],["$","meta","20",{"name":"twitter:image","content":"https://oahelper.in/campus-ceo-favicon.png?v=11"}],["$","link","21",{"rel":"shortcut icon","href":"/campus-ceo-favicon.png?v=11"}],["$","link","22",{"rel":"icon","href":"/campus-ceo-favicon-128.png?v=11","sizes":"128x128","type":"image/png"}],["$","link","23",{"rel":"icon","href":"/campus-ceo-favicon.png?v=11","sizes":"256x256","type":"image/png"}],["$","link","24",{"rel":"icon","href":"/campus-ceo-favicon-512.png?v=11","sizes":"512x512","type":"image/png"}],["$","link","25",{"rel":"apple-touch-icon","href":"/campus-ceo-favicon-512.png?v=11","sizes":"180x180","type":"image/png"}],["$","$L2b","26",{}]]