Eat Pizzas! - Practice Coding Problems

Eat Pizzas! - Problem

You are given an integer array pizzas of size n, where pizzas[i] represents the weight of the i-th pizza.

Every day, you eat exactly 4 pizzas. Due to your incredible metabolism, when you eat pizzas of weights W, X, Y, and Z, where W ≤ X ≤ Y ≤ Z, you gain the weight of only 1 pizza!

On odd-numbered days (1-indexed), you gain a weight of Z (the heaviest pizza).

On even-numbered days, you gain a weight of Y (the second heaviest pizza).

Find the maximum total weight you can gain by eating all pizzas optimally.

Note: It is guaranteed that n is a multiple of 4, and each pizza can be eaten only once.

Input & Output

Example 1 — Single Day

$ Input: pizzas = [3, 1, 4, 2]

› Output: 4

💡 Note: We have 4 pizzas, so exactly 1 day of eating. Day 1 is odd, so we gain the weight of the heaviest pizza. Sorting [3,1,4,2] gives [1,2,3,4], so we gain weight 4.

Example 2 — Multiple Days

$ Input: pizzas = [10, 8, 7, 6, 5, 4, 3, 2]

› Output: 25

💡 Note: We have 8 pizzas = 2 days. Day 1 (odd): gain heaviest from group = 10. Day 2 (even): gain second heaviest from group = 8. Optimal grouping gives us 10 + 8 + 7 = 25.

Example 3 — Equal Weights

$ Input: pizzas = [5, 5, 5, 5]

› Output: 5

💡 Note: All pizzas have equal weight. Day 1 (odd): any grouping will have Z = 5, so we gain 5. Total weight gained is 5.

Constraints

4 ≤ pizzas.length ≤ 1000
pizzas.length is a multiple of 4
1 ≤ pizzas[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input

Array of pizza weights, must eat 4 per day

Strategy

Group pizzas and assign to odd/even days optimally

Result

Maximum total weight gained

Key Takeaway

🎯 Key Insight: Sort pizzas and strategically assign the heaviest ones to positions that contribute to weight gain (Z on odd days, Y on even days)

Asked in

G Google 42 f Meta 38 a Amazon 35 M Microsoft 28

The key insight is that we want to maximize weight gained by strategically assigning our heaviest pizzas to positions that contribute to our total. Since odd days take the heaviest pizza (Z) and even days take second heaviest (Y), we should sort pizzas and assign the top pizzas to these contributing positions. Best approach uses greedy sorting. Time: O(n log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Sorting Approach	O(n log n)	O(1)	Sort pizzas and strategically assign heaviest to odd days, medium to even days
Brute Force - Try All Combinations	O(C(n,4) × 2^(n/4))	O(n/4)	Try every possible grouping of 4 pizzas and assignment to odd/even days

Greedy Sorting Approach — Algorithm Steps

Step 1: Sort pizzas in descending order
Step 2: Determine how many odd and even days we have
Step 3: Assign heaviest pizzas to Z positions on odd days and Y positions on even days
Step 4: Pair assigned pizzas with lightest remaining pizzas to complete groups

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Descending

Arrange pizzas from heaviest to lightest

Assign Strategically

Give heaviest to odd days (Z), medium to even days (Y)

Calculate Total

Sum all weight gains for maximum result

Code -

solution.c — C

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

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

int solution(int* pizzas, int n) {
    int days = n / 4;
    
    // Sort pizzas in descending order
    qsort(pizzas, n, sizeof(int), compare);
    
    int totalWeight = 0;
    int oddDays = (days + 1) / 2;
    int evenDays = days / 2;
    
    // Assign heaviest pizzas to odd days (Z positions)
    for (int i = 0; i < oddDays; i++) {
        totalWeight += pizzas[i];
    }
    
    // Assign next heaviest pizzas to even days (Y positions)
    for (int i = oddDays; i < oddDays + evenDays; i++) {
        totalWeight += pizzas[i];
    }
    
    return totalWeight;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int pizzas[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        pizzas[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(pizzas, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the pizza weights

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

847 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 Sorting Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler