Apply Discount to Prices

Apply Discount to Prices - Problem

String Medium

A sentence is a string of single-space separated words where each word can contain digits, lowercase letters, and the dollar sign '$'. A word represents a price if it is a sequence of digits preceded by a dollar sign.

For example, "$100", "$23", and "$6" represent prices while "100", "$", and "$1e5" do not.

You are given a string sentence representing a sentence and an integer discount. For each word representing a price, apply a discount of discount% on the price and update the word in the sentence. All updated prices should be represented with exactly two decimal places.

Return a string representing the modified sentence.

Note: All prices will contain at most 10 digits.

Input & Output

Example 1 — Basic Case

$ Input: sentence = "there are $1 $2 and 5$ candies", discount = 10

› Output: "there are $0.90 $1.80 and 5$ candies"

💡 Note: $1 becomes $0.90 (90% of $1), $2 becomes $1.80 (90% of $2). 5$ is invalid ($ at end) so unchanged.

Example 2 — No Valid Prices

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

› Output: "1 2 3 4 5 6 7 8 9 10"

💡 Note: No words start with $, so sentence remains unchanged.

Example 3 — Edge Cases

$ Input: sentence = "$ $1e5 $100", discount = 20

› Output: "$ $1e5 $80.00"

💡 Note: $ (only $) and $1e5 (contains 'e') are invalid. Only $100 → $80.00 (80% of $100).

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to identify valid prices ($ followed by digits only) and apply the discount formula: new_price = original_price × (100 - discount) / 100. Best approach uses string splitting and validation. Time: O(n), Space: O(n)

Common Approaches

✓ String Processing with Word Iteration

⏱️ Time: O(n) Space: O(n)

Iterate through each word in the sentence. For each word, check if it starts with '$' and contains only digits after. If valid, parse the price, apply discount, format to 2 decimal places, and replace in result.

String Processing with Word Iteration — Algorithm Steps

Split sentence into words
For each word, validate if it's a price format
If valid price, parse number and apply discount formula
Format result to 2 decimal places and reconstruct sentence

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Break sentence into individual words

Validate Price

Check if word starts with $ and has only digits after

Apply Discount

Calculate discounted price and format to 2 decimals

Code -

solution.c — C

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

int isValidPrice(char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    for (int i = 0; i < len; i++) {
        if (!isdigit(s[i])) return 0;
    }
    return 1;
}

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

int main() {
    char sentence[10000];
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;
    
    int discount;
    scanf("%d", &discount);
    
    char* result = solution(sentence, discount);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all characters in the sentence to split and process words

✓ Linear Growth

Space Complexity

O(n)

Store array of words and build result string

⚡ Linearithmic Space

32.3K Views

Medium Frequency

~15 min Avg. Time

850 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

String Processing with Word Iteration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler