Cutting Ribbons

Cutting Ribbons - Problem

You are given an integer array ribbons, where ribbons[i] represents the length of the i-th ribbon, and an integer k. You may cut any of the ribbons into any number of segments of positive integer lengths, or perform no cuts at all.

For example, if you have a ribbon of length 4, you can:

Keep the ribbon of length 4
Cut it into one ribbon of length 3 and one ribbon of length 1
Cut it into two ribbons of length 2
Cut it into one ribbon of length 2 and two ribbons of length 1
Cut it into four ribbons of length 1

Your task is to determine the maximum length of ribbon, x, that allows you to cut at least k ribbons, each of length x. You can discard any leftover ribbon from the cuts.

If it is impossible to cut k ribbons of the same length, return 0.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: We can cut the ribbons as follows: 9÷5=1 piece, 7÷5=1 piece, 5÷5=1 piece. Total = 3 pieces of length 5.

Example 2 — Multiple Cuts Per Ribbon

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

› Output: 4

💡 Note: Cut ribbons: 7÷4=1 piece, 5÷4=1 piece, 9÷4=2 pieces. Total = 4 pieces of length 4.

Example 3 — Impossible Case

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

› Output: 0

💡 Note: Even cutting all ribbons into pieces of length 1 gives us only 5+7+9=21 pieces, which is less than 22.

Constraints

1 ≤ ribbons.length ≤ 10⁵
1 ≤ ribbons[i] ≤ 10⁵
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Meta 15

The key insight is to use binary search on the answer space. If we can cut k ribbons of length x, we can also cut k ribbons of any smaller length. Best approach is binary search with Time: O(n × log(max_length)), Space: O(1).

Common Approaches

✓ Sliding Window

⏱️ Time: N/A Space: N/A

Binary Search on Answer

⏱️ Time: O(n × log(max_length)) Space: O(1)

Use binary search to efficiently find the maximum ribbon length that allows us to cut at least k pieces. Search space is from 1 to maximum ribbon length.

Brute Force Linear Search

⏱️ Time: O(n × max_length) Space: O(1)

Start from the maximum possible ribbon length and check each length to see if we can cut at least k ribbons of that size. Return the first length that works.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int* code, int codeSize, int k, int* returnSize) {
    *returnSize = codeSize;
    int* result = (int*)calloc(codeSize, sizeof(int));
    
    if (k == 0) {
        return result;
    }
    
    int windowSum = 0;
    if (k > 0) {
        for (int i = 1; i <= k; i++) {
            windowSum += code[i % codeSize];
        }
        
        for (int i = 0; i < codeSize; i++) {
            result[i] = windowSum;
            windowSum -= code[(i + 1) % codeSize];
            windowSum += code[(i + k + 1) % codeSize];
        }
    } else {
        int absK = abs(k);
        for (int i = 1; i <= absK; i++) {
            windowSum += code[(codeSize - i) % codeSize];
        }
        
        for (int i = 0; i < codeSize; i++) {
            result[i] = windowSum;
            windowSum -= code[(i - absK + codeSize) % codeSize];
            windowSum += code[i % codeSize];
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int code[100];
    int codeSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ' && token[0] != '\n') {
            code[codeSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(code, codeSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

845 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