Take Gifts From the Richest Pile - Practice Coding Problems

Take Gifts From the Richest Pile - Problem

Imagine you're a magical gift redistributor working in Santa's workshop! 🎁

You have several piles of gifts represented by an integer array gifts, where each element shows the number of gifts in that pile. Your job is to perform a special gift reduction ritual for exactly k seconds.

Every second, you must:

🔍 Find the richest pile - Choose the pile with the maximum number of gifts
✨ Apply magic reduction - Replace the number of gifts in that pile with floor(sqrt(original_number))
🔄 Repeat - Continue until k seconds have passed

Goal: Return the total number of gifts remaining across all piles after k seconds of this magical process.

Example: If a pile has 25 gifts, after reduction it becomes floor(sqrt(25)) = 5 gifts.

Input & Output

example_1.py — Basic Example

$ Input: gifts = [25, 64, 9, 4, 100], k = 4

› Output: 29

💡 Note: Second 1: max=100 → 10, array becomes [25,64,9,4,10]. Second 2: max=64 → 8, array becomes [25,8,9,4,10]. Second 3: max=25 → 5, array becomes [5,8,9,4,10]. Second 4: max=10 → 3, array becomes [5,8,9,4,3]. Total = 5+8+9+4+3 = 29

example_2.py — Small Values

$ Input: gifts = [1, 1, 1, 1], k = 4

› Output: 4

💡 Note: All piles have 1 gift. floor(√1) = 1, so each reduction keeps the value at 1. After 4 seconds, total remains 1+1+1+1 = 4

example_3.py — Single Large Pile

$ Input: gifts = [1000000], k = 3

› Output: 15

💡 Note: Second 1: 1000000 → floor(√1000000) = 1000. Second 2: 1000 → floor(√1000) = 31. Second 3: 31 → floor(√31) = 5. Final result = 5... Wait, let me recalculate: Actually 31 → 5, but we need k=3, so it should be 1000000 → 1000 → 31 → 5. But the answer should be different. Let me recalculate properly: floor(√1000000) = 1000, floor(√1000) = 31, floor(√31) = 5. So result is 5.

Constraints

1 ≤ gifts.length ≤ 10³
1 ≤ gifts[i] ≤ 10⁹
1 ≤ k ≤ 10³
All gift counts are positive integers

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

We have piles: [25, 64, 9, 4, 100] and k=4 seconds

Second 1

Find max pile (100), reduce to floor(√100) = 10

Second 2

Find max pile (64), reduce to floor(√64) = 8

Second 3

Find max pile (25), reduce to floor(√25) = 5

Second 4

Find max pile (10), reduce to floor(√10) = 3

Result

Sum remaining gifts: 5+8+9+4+3 = 29

Key Takeaway

🎯 Key Insight: Use a max-heap to avoid scanning all piles every second - the maximum is always at the root!

Asked in

a Amazon 28 G Google 15 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a max-heap (priority queue) to efficiently track the largest pile. Instead of scanning all piles every second O(k×n), we can extract and insert in O(log n) time, achieving O(k log n) complexity. This is dramatically faster for large inputs while maintaining the same logic as the simulation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(k × n)	O(1)	For each second, linearly search for the maximum pile and reduce it
Max-Heap (Priority Queue) - Optimal	O(n + k log n)	O(n)	Use a max-heap to efficiently track and extract the maximum pile each second

Brute Force (Linear Search) — Algorithm Steps

Repeat k times:
Find the index of the pile with maximum gifts
Replace that pile's value with floor(sqrt(value))
Sum and return all remaining gifts

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with piles: [25, 64, 9, 4, 100]

Find Maximum

Scan left to right: 25 < 64 < 64 < 64 < 100. Max is 100 at index 4

Reduce Maximum

100 becomes floor(√100) = 10

Repeat

Continue for k-1 more seconds

Code -

solution.c — C

#include <stdio.h>
#include <math.h>

long long pickGifts(int* gifts, int giftsSize, int k) {
    for (int second = 0; second < k; second++) {
        // Find index of maximum element
        int maxIdx = 0;
        for (int i = 1; i < giftsSize; i++) {
            if (gifts[i] > gifts[maxIdx]) {
                maxIdx = i;
            }
        }
        
        // Reduce the maximum pile
        gifts[maxIdx] = (int) sqrt(gifts[maxIdx]);
    }
    
    long long total = 0;
    for (int i = 0; i < giftsSize; i++) {
        total += gifts[i];
    }
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n)

For each of k seconds, we scan n elements to find maximum

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, modifying input array in-place

✓ Linear Space

21.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler