Apply Discount to Prices - Practice Coding Problems

Apply Discount to Prices - Problem

String Medium

Apply Discount to Prices

Imagine you're building a price comparison website that automatically applies discount coupons to all prices found in product descriptions! Your task is to identify valid prices in a sentence and apply a discount to them.

Given a sentence (string of space-separated words) and a discount percentage, you need to:

1️⃣ Identify valid prices: A price is a word that starts with $ followed by only digits
• ✅ Valid: "$100", "$23", "$6"
• ❌ Invalid: "100" (no $), "$" (no digits), "$1e5" (contains 'e')

2️⃣ Apply discount: Reduce each valid price by the given discount percentage

3️⃣ Format result: Display all updated prices with exactly 2 decimal places

Goal: Return the modified sentence with discounted prices formatted to 2 decimal places.

Input & Output

example_1.py — Basic Price Discount

$ Input: sentence = "there are $1 items that cost $100 each", discount = 20

› Output: "there are $0.80 items that cost $80.00 each"

💡 Note: Valid prices $1 and $100 get 20% discount: $1 becomes $0.80, $100 becomes $80.00. Non-price words remain unchanged.

example_2.py — Mixed Valid and Invalid Prices

$ Input: sentence = "1 2 $3 4$ 5$ 6 7$ $8 $", discount = 0

› Output: "1 2 $3.00 4$ 5$ 6 7$ $8.00 $"

💡 Note: Only $3 and $8 are valid prices ($ followed by only digits). With 0% discount, they become $3.00 and $8.00. Invalid formats like '4$', '5$', '7$', '$' remain unchanged.

example_3.py — Edge Case with Large Price

$ Input: sentence = "buy $1000000000 worth of items", discount = 50

› Output: "buy $500000000.00 worth of items"

💡 Note: Large valid price $1000000000 gets 50% discount, becoming $500000000.00 formatted to exactly 2 decimal places.

Visualization

Tap to expand

Understanding the Visualization

Text Scanner

Split the sentence into individual words, like scanning each item

Price Validator

Check if each word is a valid price: starts with $ and contains only digits

Discount Engine

Apply the discount percentage to valid prices using the formula

Format & Rebuild

Format prices to 2 decimals and reconstruct the sentence

Key Takeaway

🎯 Key Insight: Leverage optimized built-in string methods like `startswith()` and `isdigit()` for clean, efficient price validation instead of manual character-by-character checking.

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

n words, m average word length, but optimized with built-in methods

✓ Linear Growth

Space Complexity

O(n)

Space for word array and result string construction

⚡ Linearithmic Space

Constraints

1 ≤ sentence.length ≤ 10⁵
sentence consists of lowercase English letters, digits, ' ', and '$'
sentence does not have leading or trailing spaces
All words in sentence are separated by a single space
0 ≤ discount ≤ 100
All prices will contain at most 10 digits

Asked in

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

The optimal solution uses built-in string methods to efficiently identify valid prices (words starting with '$' followed by only digits) and applies the discount formula: discounted_price = original × (100 - discount) / 100. Format the result to exactly 2 decimal places using language-specific formatting functions.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in String Methods (Optimal)	O(n*m)	O(n)	Use built-in string validation methods for efficient price detection

Built-in String Methods (Optimal) — Algorithm Steps

Split sentence into words using built-in split()
For each word, check if it starts with '$' and has more than 1 character
Use string slicing and isdigit() to validate numeric part
Convert to number, apply discount formula, format with 2 decimals
Join all processed words back into final sentence

Visualization

Tap to expand

Step-by-Step Walkthrough

Split & Map

Split sentence and map each word through validation

Pattern Match

Use optimized pattern matching for '$' + digits

Transform

Apply discount calculation and format in one step

Reconstruct

Join processed words back into final sentence

Code -

solution.c — C

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

int isAllDigits(const char* str) {
    if (strlen(str) == 0) return 0;
    for (int i = 0; i < strlen(str); i++) {
        if (!isdigit(str[i])) return 0;
    }
    return 1;
}

char* discountPrices(char* sentence, int discount) {
    char* result = malloc(strlen(sentence) * 2);
    char* copy = malloc(strlen(sentence) + 1);
    strcpy(copy, sentence);
    
    char* token = strtok(copy, " ");
    int first = 1;
    result[0] = '\0';
    
    while (token != NULL) {
        if (!first) strcat(result, " ");
        first = 0;
        
        if (strlen(token) > 1 && token[0] == '$' && isAllDigits(&token[1])) {
            long long price = atoll(&token[1]);
            double discountedPrice = price * (100.0 - discount) / 100.0;
            char temp[50];
            sprintf(temp, "$%.2f", discountedPrice);
            strcat(result, temp);
        } else {
            strcat(result, token);
        }
        
        token = strtok(NULL, " ");
    }
    
    free(copy);
    return result;
}

int main() {
    char sentence[10000];
    int discount;
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;
    
    if (sentence[0] == '"') {
        memmove(sentence, sentence + 1, strlen(sentence));
        sentence[strlen(sentence) - 1] = '\0';
    }
    
    scanf("%d", &discount);
    char* result = discountPrices(sentence, discount);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

n words, m average word length, but optimized with built-in methods

✓ Linear Growth

Space Complexity

O(n)

Space for word array and result string construction

⚡ Linearithmic Space

Constraints

1 ≤ sentence.length ≤ 10⁵
sentence consists of lowercase English letters, digits, ' ', and '$'
sentence does not have leading or trailing spaces
All words in sentence are separated by a single space
0 ≤ discount ≤ 100
All prices will contain at most 10 digits

28.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Built-in String Methods (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler