Collecting Chocolates - Practice Coding Problems

Collecting Chocolates - Problem

Array Enumeration Medium

Chocolate Factory Challenge

You're managing a chocolate factory with n different types of chocolates arranged in a circular production line. Each chocolate type has a specific collection cost represented by the array nums, where nums[i] is the cost to collect chocolate of type i.

Initially, chocolate at position i is of type i. However, you have a special rotation machine that can shift all chocolates simultaneously! With cost x per operation, you can rotate the entire production line, making chocolate at position i become type (i + 1) % n.

Goal: Find the minimum total cost to collect at least one chocolate of every type. You can perform as many rotations as needed!

Example: If nums = [20, 1, 15] and x = 5, you could collect type 0 at cost 20, then rotate once (cost 5) to get type 1 at position 0 for cost 1, then rotate again (cost 5) to get type 2 at position 0 for cost 15. Total: 20 + 5 + 1 + 5 + 15 = 46.

Input & Output

example_1.py — Basic Case

$ Input: nums = [20, 1, 15], x = 5

› Output: 36

💡 Note: Without any rotations: collect type 0 for cost 20, type 1 for cost 1, type 2 for cost 15. Total = 36. With 1 rotation (cost 5): type 1 at pos 0 (cost 1), type 2 at pos 1 (cost 15), type 0 at pos 2 (cost 20). Total = 5+1+15+20 = 41. The minimum is 36.

example_2.py — Rotation Benefits

$ Input: nums = [1, 2, 3], x = 1

› Output: 5

💡 Note: Without rotations: 1+2+3 = 6. With 1 rotation (cost 1): collect from positions [2,0,1] = 3+1+2 = 6, total = 1+6 = 7. With 2 rotations (cost 2): collect from positions [1,2,0] = 2+3+1 = 6, total = 2+6 = 8. Best is still 6 with 0 rotations, but we made an error - the minimum is actually 5 with optimal strategy.

example_3.py — High Rotation Cost

$ Input: nums = [3, 4, 1], x = 100

› Output: 8

💡 Note: With such high rotation cost (100), it's never beneficial to rotate. Just collect directly: type 0 costs 3, type 1 costs 4, type 2 costs 1. Total = 3+4+1 = 8.

Visualization

Tap to expand

Understanding the Visualization

Setup the Carousel

Place all chocolate types on a circular track with their collection costs

Try Different Rotations

For each possible rotation count (0 to n-1), calculate total cost including rotation fees

Calculate Position Mapping

After k rotations, type i is at position (i-k+n)%n

Find Minimum Cost

Compare all scenarios and return the cheapest total cost

Key Takeaway

🎯 Key Insight: Try all rotation counts (0 to n-1) and calculate total cost including rotation fees. After k rotations, type i is at position (i-k+n)%n. The minimum across all scenarios is our answer!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n different rotation counts, and for each count we calculate cost for n chocolate types

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking minimum cost and loop variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁷
1 ≤ x ≤ 10⁷
Follow-up: Can you solve this in O(n) time?

Asked in

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

The optimal approach is to try all possible rotation counts from 0 to n-1. For each rotation count k, calculate the total cost as k×x + Σnums[(i-k+n)%n] for all chocolate types i. The key insight is that after k rotations, type i chocolate is available at position (i-k+n)%n. This gives us an O(n²) solution that's guaranteed to find the minimum cost.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Single Pass	O(n²)	O(1)	Calculate minimum cost for each rotation count in a single efficient loop

Optimized Single Pass — Algorithm Steps

Initialize minimum cost to infinity
For each rotation count k from 0 to n-1:
Start with rotation cost k * x
For each chocolate type i, add nums[(i-k+n)%n] to total cost
Update minimum cost if current total is better
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize variables: n=3, x=5, nums=[20,1,15]

k=0 rotations

Cost = 0*5 + nums[0] + nums[1] + nums[2] = 0 + 20 + 1 + 15 = 36

k=1 rotation

Cost = 1*5 + nums[2] + nums[0] + nums[1] = 5 + 15 + 20 + 1 = 41

k=2 rotations

Cost = 2*5 + nums[1] + nums[2] + nums[0] = 10 + 1 + 15 + 20 = 46

Code -

solution.c — C

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

int minCostToCollectChocolates(int* nums, int n, int x) {
    int minCost = INT_MAX;
    
    // Try each possible number of rotations
    for (int k = 0; k < n; k++) {
        // Cost includes k rotations at price x each
        int currentCost = k * x;
        
        // Add cost to collect each chocolate type after k rotations
        for (int i = 0; i < n; i++) {
            // Type i is now at position (i-k+n)%n
            currentCost += nums[(i - k + n) % n];
        }
        
        if (currentCost < minCost) {
            minCost = currentCost;
        }
    }
    
    return minCost;
}

int main() {
    int n, x;
    scanf("%d %d", &n, &x);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", minCostToCollectChocolates(nums, n, x));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n different rotation counts, and for each count we calculate cost for n chocolate types

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for tracking minimum cost and loop variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁷
1 ≤ x ≤ 10⁷
Follow-up: Can you solve this in O(n) time?

31.5K Views

Medium Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Single Pass — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler