Final Prices With a Special Discount in a Shop

Final Prices With a Special Discount in a Shop - Problem

You're shopping at a special store where each item has a smart discount system! The store offers an innovative discount policy: when you buy any item, you'll receive a discount equal to the price of the next cheaper or equally-priced item that appears later in the store.

Given an integer array prices where prices[i] represents the price of the i-th item, your task is to calculate the final discounted price for each item.

Discount Rules:

For item at position i, find the first item at position j where j > i and prices[j] ≤ prices[i]
The discount amount equals prices[j]
If no such item exists, no discount is applied

Return an array where each element represents the final price after applying the discount (original price minus discount).

Example: If prices = [8, 4, 6, 2, 3], then:
• Item $8 gets $4 discount (next cheaper item) → Final: $4
• Item $4 gets $2 discount → Final: $2
• Item $6 gets $2 discount → Final: $4
• Item $2 gets no discount → Final: $2
• Item $3 gets no discount → Final: $3

Input & Output

example_1.py — Basic Case

$ Input: [8,4,6,2,3]

› Output: [4,2,4,2,3]

💡 Note: Item $8 gets $4 discount (next cheaper), item $4 gets $2 discount, item $6 gets $2 discount, items $2 and $3 get no discount as no cheaper items follow them.

example_2.py — No Discounts

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

› Output: [1,2,3,4,5]

💡 Note: Prices are in increasing order, so no item has a cheaper item after it. All items keep their original prices.

example_3.py — All Discounts

$ Input: [10,1,1,6]

› Output: [9,1,1,6]

💡 Note: Only the first item $10 gets a discount of $1 from the next item. The remaining items don't have cheaper items following them.

Visualization

Tap to expand

Understanding the Visualization

Enter the mall

Start with a special tracker (stack) that remembers expensive stores you've visited

Visit each store

At each store, check if it can provide discounts to previously visited expensive stores

Apply discounts

When you find a cheaper store, it provides discounts to all applicable expensive stores in your tracker

Update tracker

Add current store to your tracker for future discount opportunities

Key Takeaway

🎯 Key Insight: The monotonic stack efficiently maintains a decreasing sequence of prices, allowing us to instantly identify when a cheaper item can provide discounts to multiple previous expensive items in O(1) time per discount application.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n items, we potentially scan through all remaining n-1 items in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the input and output arrays

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 500
1 ≤ prices[i] ≤ 10³
All prices are positive integers

Asked in

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

The optimal solution uses a monotonic stack to efficiently track items waiting for discounts. As we iterate through prices, we use the stack to maintain items in decreasing price order, allowing us to quickly find which previous items can receive discounts from the current item. This achieves O(n) time complexity compared to the O(n²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each item, scan all subsequent items to find the first cheaper one
Monotonic Stack (Optimal)	O(n)	O(n)	Use a stack to efficiently track items waiting for discounts

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array with same length as prices
For each item at position i, start searching from position i+1
Find the first item j where prices[j] ≤ prices[i]
If found, set result[i] = prices[i] - prices[j]
If not found, set result[i] = prices[i] (no discount)
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first item

Begin scanning from position 0, looking at all items to the right

Linear search

For each item, scan through all remaining items one by one

Find first discount

Stop at the first item that's cheaper or equal in price

Apply discount

Calculate final price by subtracting the discount amount

Code -

solution.c — C

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

int* finalPrices(int* prices, int pricesSize, int* returnSize) {
    *returnSize = pricesSize;
    int* result = (int*)malloc(pricesSize * sizeof(int));
    
    for (int i = 0; i < pricesSize; i++) {
        result[i] = prices[i]; // Default: no discount
        
        // Look for next cheaper or equal item
        for (int j = i + 1; j < pricesSize; j++) {
            if (prices[j] <= prices[i]) {
                result[i] = prices[i] - prices[j];
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input (simple implementation)
    int prices[1000];
    int count = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            prices[count++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = finalPrices(prices, count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n items, we potentially scan through all remaining n-1 items in the worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the input and output arrays

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 500
1 ≤ prices[i] ≤ 10³
All prices are positive integers

89.5K Views

Medium 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler