Divide Chocolate - Practice Coding Problems

Divide Chocolate - Problem

The Great Chocolate Distribution Challenge!

You've got a delicious chocolate bar made up of consecutive chunks, where each chunk has its own sweetness value. Here's the challenge: you want to share this chocolate with k friends, so you need to make k cuts to create k+1 pieces.

🍫 The Twist: Being the generous person you are, you'll take the piece with the minimum total sweetness and give all the better pieces to your friends!

Your Goal: Find the optimal way to cut the chocolate so that your piece (the minimum one) has the maximum possible sweetness. In other words, make the worst piece as good as possible!

Key Rules:
• Each piece must consist of consecutive chunks
• You get the piece with minimum total sweetness
• You want to maximize your piece's sweetness

Example: If sweetness = [1,2,3,4,5,6,7,8,9] and k = 5, you need to find 5 cuts to create 6 pieces where your minimum piece is as sweet as possible!

Input & Output

example_1.py — Basic Case

$ Input: sweetness = [1,2,3,4,5,6,7,8,9], k = 5

› Output: 6

💡 Note: We need to make 5 cuts to create 6 pieces. One optimal way is to cut at positions [1,2,3,4,5] creating pieces: [1],[2],[3],[4],[5],[6,7,8,9]. The minimum sweetness is 1. But we can do better by cutting at [5,6,7,8] to get pieces with sweetness [15,6,7,8,9], where minimum is 6.

example_2.py — Small Array

$ Input: sweetness = [5,6,7,8,9,1,2,3,4], k = 8

› Output: 1

💡 Note: With k=8 cuts, we need 9 pieces from 9 chunks. Each piece must be exactly one chunk, so the minimum sweetness is min(array) = 1.

example_3.py — Two Pieces

$ Input: sweetness = [1,2,2,1,2,2,1,2,2], k = 2

› Output: 5

💡 Note: We make 2 cuts to create 3 pieces. One optimal way: [1,2,2,1,2], [2], [1,2,2] with sweetness [8,2,5]. The minimum is 2. Better way: [1,2,2], [1,2,2], [1,2,2] with sweetness [5,5,5]. The minimum is 5.

Constraints

1 ≤ k ≤ sweetness.length - 1
1 ≤ sweetness.length ≤ 10⁴
1 ≤ sweetness[i] ≤ 10⁵
Each piece must consist of consecutive chunks
You must make exactly k cuts to create k+1 pieces

Visualization

Tap to expand

Understanding the Visualization

Understand the Problem

You need exactly k cuts to create k+1 pieces, and you'll get the piece with minimum total sweetness

Binary Search Setup

Instead of trying all cuts, ask: 'What's the maximum minimum sweetness I can guarantee?'

Greedy Validation

For each candidate minimum, greedily try to form k+1 pieces by accumulating sweetness until reaching the target

Narrow the Range

If achievable, try a higher minimum; if not, try a lower minimum

Key Takeaway

🎯 Key Insight: Binary search on the answer is powerful when you can efficiently validate if a target value is achievable. Instead of searching through all possible solutions, search through all possible answer values!

Asked in

G Google 42 f Facebook 35 a Amazon 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses binary search on the answer. Instead of trying all possible cuts, we binary search on the minimum sweetness value we want to achieve. For each candidate value, we greedily check if we can create k+1 pieces where each has at least that sweetness. This reduces the time complexity from exponential to O(n log(sum)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Cut Combinations)	O(C(n-1,k) * k)	O(k)	Generate all possible ways to place k cuts and find the maximum minimum piece
Binary Search on Answer (Optimal)	O(n log(sum))	O(1)	Binary search on the minimum sweetness value and check if it's achievable with k cuts

Brute Force (Try All Cut Combinations) — Algorithm Steps

Generate all possible combinations of k cut positions
For each combination, calculate sweetness of all k+1 pieces
Find the minimum sweetness among the k+1 pieces
Keep track of the maximum minimum found so far
Return the best maximum minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Cuts

Create every possible combination of k cut positions

Calculate Pieces

For each cut combination, sum up sweetness of resulting pieces

Find Minimum

Identify the minimum piece sweetness for each combination

Track Maximum

Keep the best (maximum) minimum sweetness found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int maxMinSweetness = 0;

void generateCombinations(int* sweetness, int n, int start, int end, int k, int* current, int currentSize) {
    if (k == 0) {
        // Create boundaries array
        int* boundaries = (int*)malloc((currentSize + 2) * sizeof(int));
        boundaries[0] = 0;
        for (int i = 0; i < currentSize; i++) {
            boundaries[i + 1] = current[i];
        }
        boundaries[currentSize + 1] = n;
        
        int minPieceSweetness = INT_MAX;
        
        // Calculate sweetness for each piece
        for (int i = 0; i < currentSize + 1; i++) {
            int pieceSweetness = 0;
            for (int j = boundaries[i]; j < boundaries[i + 1]; j++) {
                pieceSweetness += sweetness[j];
            }
            if (pieceSweetness < minPieceSweetness) {
                minPieceSweetness = pieceSweetness;
            }
        }
        
        if (minPieceSweetness > maxMinSweetness) {
            maxMinSweetness = minPieceSweetness;
        }
        
        free(boundaries);
        return;
    }
    
    for (int i = start; i <= end - k + 1; i++) {
        current[currentSize] = i;
        generateCombinations(sweetness, n, i + 1, end, k - 1, current, currentSize + 1);
    }
}

int maximizeSweetness(int* sweetness, int sweetnessSize, int k) {
    maxMinSweetness = 0;
    int* current = (int*)malloc(k * sizeof(int));
    generateCombinations(sweetness, sweetnessSize, 1, sweetnessSize - 1, k, current, 0);
    free(current);
    return maxMinSweetness;
}

int main() {
    // Implementation for input parsing
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n-1,k) * k)

We need to choose k positions from n-1 possible cut positions, then for each combination calculate k+1 piece sums

✓ Linear Growth

Space Complexity

O(k)

Space needed to store the current combination of cuts and piece calculations

✓ Linear Space

43.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Cut Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler