Last Stone Weight - Practice Coding Problems

Last Stone Weight - Problem

Imagine you're playing an ancient stone-smashing game! You have a collection of stones, each with a specific weight, and you need to repeatedly smash the two heaviest stones together until at most one stone remains.

Here's how the game works:

🎯 Choose the two heaviest stones (let's call their weights x and y where x ≤ y)
💥 Smash them together:
- If x == y: Both stones are completely destroyed
- If x < y: The lighter stone is destroyed, and the heavier stone becomes a new stone with weight y - x
🔄 Repeat until there's at most one stone left

Goal: Return the weight of the last remaining stone, or 0 if no stones are left.

Example: Stones [2,7,4,1,8,1] → After all smashing → Last stone weighs 1

Input & Output

example_1.py — Standard Case

$ Input: [2,7,4,1,8,1]

› Output: 1

💡 Note: Step by step: [2,7,4,1,8,1] → smash 8,7 → [2,4,1,1,1] → smash 4,2 → [2,1,1,1] → smash 2,1 → [1,1,1] → smash 1,1 → [1] → final answer: 1

example_2.py — Single Stone

$ Input: [1]

› Output: 1

💡 Note: Only one stone exists, so no smashing occurs. The weight of the last (and only) stone is 1.

example_3.py — All Stones Destroyed

$ Input: [3,3]

› Output: 0

💡 Note: Both stones have equal weight (3), so when they smash together, both are completely destroyed. No stones remain, so return 0.

Visualization

Tap to expand

Understanding the Visualization

Tournament Setup

All fighters (stones) enter the tournament bracket, arranged by strength

Championship Match

The two strongest fighters face off in the center ring

Battle Result

Either both are eliminated (equal strength) or winner continues with reduced power

New Champion

The surviving fighter rejoins the tournament, and the process repeats

Key Takeaway

🎯 Key Insight: A max heap maintains the tournament bracket automatically, always keeping the strongest fighters (heaviest stones) ready for the next battle without expensive reorganization.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Building heap takes O(n log n), and each of the n operations takes O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

The heap stores all stones, requiring O(n) extra space

⚡ Linearithmic Space

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 1000
All stone weights are positive integers

Asked in

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

The optimal solution uses a max heap to efficiently manage stones by weight. Instead of repeatedly sorting the entire array (O(n² log n)), we maintain a heap that gives us the heaviest stones in O(log n) time. This reduces the overall complexity to O(n log n), making it much more efficient for larger inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Max Heap (Optimal)	O(n log n)	O(n)	Use a max heap to efficiently get the two heaviest stones
Brute Force (Repeated Sorting)	O(n² log n)	O(1)	Sort the array repeatedly to find the two heaviest stones

Max Heap (Optimal) — Algorithm Steps

Create a max heap and insert all stones
While heap has more than one stone:
Extract the two heaviest stones from the heap
If stones have different weights, insert their difference back
Return the last remaining stone or 0 if heap is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Heap

Insert all stones into max heap: root=8

Extract Max

Pop 8 and 7, calculate difference: 1

Insert Result

Push result back into heap

Continue

Repeat until one or no stones remain

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} MaxHeap;

MaxHeap* createHeap(int capacity) {
    MaxHeap* heap = malloc(sizeof(MaxHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MaxHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->data[parent] >= heap->data[index]) break;
        int temp = heap->data[parent];
        heap->data[parent] = heap->data[index];
        heap->data[index] = temp;
        index = parent;
    }
}

void heapifyDown(MaxHeap* heap, int index) {
    while (1) {
        int maxIndex = index;
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        
        if (left < heap->size && heap->data[left] > heap->data[maxIndex]) {
            maxIndex = left;
        }
        if (right < heap->size && heap->data[right] > heap->data[maxIndex]) {
            maxIndex = right;
        }
        
        if (maxIndex == index) break;
        int temp = heap->data[index];
        heap->data[index] = heap->data[maxIndex];
        heap->data[maxIndex] = temp;
        index = maxIndex;
    }
}

void push(MaxHeap* heap, int val) {
    heap->data[heap->size] = val;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MaxHeap* heap) {
    if (heap->size == 0) return 0;
    int max = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return max;
}

int lastStoneWeight(int* stones, int stonesSize) {
    MaxHeap* heap = createHeap(stonesSize);
    
    for (int i = 0; i < stonesSize; i++) {
        push(heap, stones[i]);
    }
    
    while (heap->size > 1) {
        int first = pop(heap);
        int second = pop(heap);
        
        if (first != second) {
            push(heap, first - second);
        }
    }
    
    int result = heap->size == 0 ? 0 : pop(heap);
    free(heap->data);
    free(heap);
    return result;
}

int main() {
    int stones[] = {2, 7, 4, 1, 8, 1};
    int size = 6;
    printf("%d\n", lastStoneWeight(stones, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Building heap takes O(n log n), and each of the n operations takes O(log n) time

⚡ Linearithmic

Space Complexity

O(n)

The heap stores all stones, requiring O(n) extra space

⚡ Linearithmic Space

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 1000
All stone weights are positive integers

89.4K Views

High Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Max Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler