Cutting Ribbons - Practice Coding Problems

Cutting Ribbons - Problem

Imagine you're a craft store owner with various ribbons of different lengths, and a customer needs k ribbons of identical length for a special project. Your job is to find the maximum possible length you can cut to satisfy their request!

Given an array ribbons where ribbons[i] represents the length of the i-th ribbon, and an integer k, you need to determine the maximum length x such that you can cut at least k ribbons each of length x.

Key Rules:

You can cut any ribbon into smaller pieces of positive integer lengths
You can discard leftover pieces from cuts
If it's impossible to get k ribbons of the same length, return 0

Example: With a ribbon of length 4, you could cut it into: one piece of length 4, or one of length 3 + one of length 1, or two pieces of length 2, etc.

Input & Output

example_1.py — Basic Case

$ Input: ribbons = [9,7,5], k = 3

› Output: 5

💡 Note: We can cut the ribbons into: ribbon 9 → one piece of length 5 (discard 4), ribbon 7 → one piece of length 5 (discard 2), ribbon 5 → one piece of length 5. Total: 3 pieces of length 5.

example_2.py — Multiple Cuts Per Ribbon

$ Input: ribbons = [7,5,9], k = 4

› Output: 4

💡 Note: We can cut: ribbon 7 → one piece of length 4, ribbon 5 → one piece of length 4, ribbon 9 → two pieces of length 4. Total: 4 pieces of length 4.

example_3.py — Impossible Case

$ Input: ribbons = [5,7,9], k = 22

› Output: 0

💡 Note: Even if we cut all ribbons into pieces of length 1, we get 5+7+9 = 21 pieces, which is less than 22. Therefore, it's impossible.

Constraints

1 ≤ ribbons.length ≤ 10⁵
1 ≤ ribbons[i] ≤ 10⁵
1 ≤ k ≤ 10⁹
All ribbon lengths are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify the search space

The answer must be between 1 and the longest ribbon

Use binary search property

If length X works, all smaller lengths also work

Count efficiently

For each candidate length, count total pieces possible

Converge to optimum

Binary search finds the maximum valid length

Key Takeaway

🎯 Key Insight: Binary search works because of the monotonic property - if we can create k ribbons of length X, we can definitely create k ribbons of any length smaller than X!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses binary search on the answer space. Since the problem has a monotonic property (if we can create k ribbons of length X, we can create k ribbons of any smaller length), we can binary search for the maximum valid length in O(n log max_length) time instead of the brute force O(n × max_length) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search (Brute Force)	O(n * max_length)	O(1)	Try every possible ribbon length from 1 to maximum ribbon length
Binary Search (Optimal)	O(n * log(max_length))	O(1)	Binary search on the answer space to find maximum valid ribbon length

Linear Search (Brute Force) — Algorithm Steps

Find the maximum ribbon length in the array
For each possible length from max down to 1:
Count how many ribbons of this length we can cut from all ribbons
If count >= k, return this length
If no valid length found, return 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with max length

Begin checking from the longest ribbon

Count possible cuts

For each ribbon, calculate how many pieces of current length we can get

Check if sufficient

If total pieces >= k, we found our answer

Decrease length

If not enough pieces, try next smaller length

Code -

solution.c — C

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

int canCut(int* ribbons, int size, int k, int length) {
    int count = 0;
    for (int i = 0; i < size; i++) {
        count += ribbons[i] / length;
    }
    return count >= k;
}

int cutRibbons(int* ribbons, int size, int k) {
    int maxLength = 0;
    for (int i = 0; i < size; i++) {
        if (ribbons[i] > maxLength) {
            maxLength = ribbons[i];
        }
    }
    
    for (int length = maxLength; length >= 1; length--) {
        if (canCut(ribbons, size, k, length)) {
            return length;
        }
    }
    return 0;
}

int main() {
    int ribbons[] = {9, 7, 5};
    int k = 3;
    printf("%d\n", cutRibbons(ribbons, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * max_length)

For each possible length (up to max_length), we iterate through all n ribbons

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

52.0K Views

Medium-High Frequency

~15 min Avg. Time

1.9K 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

Linear Search (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler