Reducing Dishes - Practice Coding Problems

Reducing Dishes - Problem

You're a world-renowned chef who has collected satisfaction ratings for your n signature dishes. Each dish takes exactly 1 unit of time to prepare, and you want to maximize your restaurant's success by strategically selecting and ordering your dishes.

The like-time coefficient of each dish is calculated as: cooking_time × satisfaction_level, where cooking_time includes the time for all previously prepared dishes plus the current dish.

Goal: Return the maximum possible sum of like-time coefficients by choosing which dishes to prepare and in what order.

Key Rules:

You can discard any dishes you don't want to prepare
You can prepare the selected dishes in any order
Each dish takes 1 time unit, so the first dish has time=1, second has time=2, etc.

Example: If you prepare dishes with satisfaction [4, 3, 2] in that order, you get: 1×4 + 2×3 + 3×2 = 16

Input & Output

example_1.py — Basic Case

$ Input: satisfaction = [-1, -8, 0, 5, -9]

› Output: 14

💡 Note: After sorting by satisfaction: [5, 0, -1, -8, -9]. We select dishes [5, 0, -1] and cook in that order. Like-time coefficient = 1×5 + 2×0 + 3×(-1) = 5 + 0 - 3 = 2. Wait, let me recalculate: we should cook in reverse order [−1, 0, 5] to get 1×(-1) + 2×0 + 3×5 = -1 + 0 + 15 = 14.

example_2.py — All Positive

$ Input: satisfaction = [4, 3, 2]

› Output: 20

💡 Note: All dishes have positive satisfaction, so we cook all of them. Optimal order is [2, 3, 4] to get 1×2 + 2×3 + 3×4 = 2 + 6 + 12 = 20.

example_3.py — All Negative

$ Input: satisfaction = [-1, -4, -5]

› Output: 0

💡 Note: All dishes have negative satisfaction. No matter what order or combination we choose, the result will be negative. It's better to cook no dishes at all and get 0.

Constraints

1 ≤ satisfaction.length ≤ 500
-1000 ≤ satisfaction[i] ≤ 1000
Each dish takes exactly 1 time unit to prepare
You can choose to prepare any subset of dishes in any order

Visualization

Tap to expand

Understanding the Visualization

Rate Your Dishes

Each dish has a satisfaction level - some customers love, some they hate

Plan the Order

Dishes served later have higher impact (multiply by position)

Choose Wisely

Only include dishes that improve the overall experience

Maximize Impact

Higher satisfaction dishes should come later in the meal

Key Takeaway

🎯 Key Insight: The greedy approach works because we always want higher satisfaction dishes to have higher time coefficients, and we only include dishes that make a positive contribution to the total satisfaction.

Asked in

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

The optimal approach uses a greedy strategy after sorting dishes by satisfaction in descending order. The key insight is that higher satisfaction dishes should be cooked later (with higher time coefficients) and we should only include dishes that contribute positively to the total sum. This achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log n)	O(1)	Sort dishes by satisfaction, then greedily select from highest satisfaction
Brute Force (Try All Combinations)	O(n! × 2^n)	O(n × 2^n)	Generate all possible subsets and try all permutations of each subset

Greedy Approach (Optimal) — Algorithm Steps

Sort the satisfaction array in descending order
Use two pointers: one for tracking current sum, one for total sum
For each dish, add its satisfaction to current sum
If current sum is positive, add it to total sum (this dish contributes positively)
Continue until current sum becomes non-positive

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Descending

Sort dishes by satisfaction level (highest first)

Track Current Sum

Add each dish's satisfaction to running sum

Check Contribution

If current sum > 0, it contributes positively

Add to Total

Add positive contributions to final answer

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int maxSatisfaction(int* satisfaction, int n) {
    // Sort in descending order
    qsort(satisfaction, n, sizeof(int), compare);
    
    int currentSum = 0;
    int totalSum = 0;
    
    // Greedily add dishes from highest satisfaction
    for (int i = 0; i < n; i++) {
        currentSum += satisfaction[i];
        if (currentSum > 0) {
            totalSum += currentSum;
        } else {
            break;
        }
    }
    
    return totalSum;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int satisfaction[500];
    for (int i = 0; i < n; i++) {
        scanf("%d", &satisfaction[i]);
    }
    
    printf("%d\n", maxSatisfaction(satisfaction, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting, O(n) for the greedy selection

⚡ Linearithmic

Space Complexity

O(1)

Only uses a few variables, sorting can be done in-place

✓ Linear Space

89.2K Views

Medium Frequency

~15 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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler