Eat Pizzas! - Practice Coding Problems

Eat Pizzas! - Problem

🍕 Pizza Eating Challenge!

You're participating in a unique pizza eating contest! Given an array pizzas where pizzas[i] represents the weight of the i-th pizza, you must eat exactly 4 pizzas every day until all pizzas are consumed.

Here's the twist: due to your incredible metabolism, when you eat 4 pizzas with weights W ≤ X ≤ Y ≤ Z, you only gain weight from one pizza:

Odd-numbered days (1st, 3rd, 5th, ...): You gain weight equal to Z (heaviest pizza)
Even-numbered days (2nd, 4th, 6th, ...): You gain weight equal to Y (second heaviest pizza)

Goal: Arrange your pizza consumption optimally to maximize your total weight gain!

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

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We have 4 pizzas, so exactly 1 day. Day 1 is odd, so we gain weight of Z (maximum pizza). Sorting: [1,2,3,4], we gain weight 4.

example_2.py — Two Days

$ Input: [8, 6, 4, 2, 7, 5, 3, 1]

› Output: 14

💡 Note: 8 pizzas = 2 days. Day 1 (odd): gain Z, Day 2 (even): gain Y. Optimal assignment gives us 8 (heaviest for day 1) + 6 (second heaviest for day 2) = 14.

example_3.py — Three Days

$ Input: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 12]

› Output: 29

💡 Note: 12 pizzas = 3 days. Days 1,3 are odd (gain Z), Day 2 is even (gain Y). Sorted: [12,11,10,9,8,7,6,5,4,3,2,1]. We get 12+11 (for 2 odd days) + 10 (for 1 even day) = 33. Wait, let me recalculate: 2 odd days get the 2 heaviest pizzas (12,11), 1 even day gets the next heaviest (10). Total = 12+11+10 = 33.

Constraints

4 ≤ n ≤ 10⁵
n is a multiple of 4
1 ≤ pizzas[i] ≤ 10⁹
Each pizza can only be eaten once

Visualization

Tap to expand

Understanding the Visualization

Identify Resources

Count how many scoring positions you have: odd days need Z, even days need Y

Sort by Value

Arrange pizzas from heaviest to lightest to prioritize high-value assignments

Optimal Assignment

Place the heaviest pizzas in scoring positions to maximize total gain

Key Takeaway

🎯 Key Insight: By sorting pizzas in descending order and strategically assigning the heaviest ones to scoring positions (Z for odd days, Y for even days), we maximize our total weight gain with optimal O(n log n) time complexity.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a greedy approach: sort all pizzas in descending order, then strategically assign the heaviest pizzas to scoring positions. Since odd days use the maximum weight (Z) and even days use the second maximum (Y), we place the top pizzas in these positions to maximize our total weight gain. Time complexity: O(n log n) for sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n!)	O(n)	Generate all possible ways to group pizzas into sets of 4 and calculate maximum weight gain
Greedy Sorting Approach (Optimal)	O(n log n)	O(1)	Sort pizzas in descending order and optimally distribute them based on day types

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to partition n pizzas into groups of 4
For each partitioning, sort each group of 4 pizzas
Calculate weight gain: odd days take Z (max), even days take Y (second max)
Keep track of the maximum total weight gain across all partitionings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Create all possible ways to group pizzas into sets of 4

Calculate Each Score

For each grouping, calculate total weight gain using day rules

Find Maximum

Keep track of the best score found across all combinations

Code -

solution.c — C

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

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

int backtrack(int* remaining, int remSize, int groups[][4], int groupCount) {
    if (remSize == 0) {
        int total = 0;
        for (int i = 0; i < groupCount; i++) {
            int group[4];
            memcpy(group, groups[i], 4 * sizeof(int));
            qsort(group, 4, sizeof(int), compare);
            if ((i + 1) % 2 == 1) {
                total += group[3]; // odd day
            } else {
                total += group[2]; // even day
            }
        }
        return total;
    }
    
    if (remSize < 4) return 0;
    
    // Simplified: take first 4
    int combo[4] = {remaining[0], remaining[1], remaining[2], remaining[3]};
    memcpy(groups[groupCount], combo, 4 * sizeof(int));
    
    return backtrack(remaining + 4, remSize - 4, groups, groupCount + 1);
}

int solution(int* pizzas, int n) {
    int groups[1000][4];
    return backtrack(pizzas, n, groups, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n!)

We need to try all possible ways to partition n items into groups of 4, which is roughly n!/(4!)^(n/4)

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the current partitioning and recursion stack

⚡ Linearithmic Space

58.4K Views

Medium Frequency

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

🍕 Pizza Eating Challenge!

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler