0855MediumString

Marking Down the Priced Words

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A notice reads sentence, a run of words separated by single spaces with no space at either end.

A word is a price when it begins with '$' and every character after that is a digit, and there is at least one such digit. Any other word is left alone, including a bare "$" and anything with a non-digit after the '$'.

Every price is reduced by discount percent. Write the reduced amount with exactly two digits after a decimal point, keeping the leading '$'. Taking a whole number of percent off a whole amount always lands on an exact number of hundredths, so two digits is always enough and nothing has to be rounded.

Return the notice after every price has been marked down.

Examples

Example 1

Input: sentence = "there are $1 $2 and 5$ items", discount = 50
Output: "there are $0.50 $1.00 and 5$ items"

The words "$1" and "$2" are prices and halve to "$0.50" and "$1.00". The word "5$" does not begin with the marker, so it is left alone.

Example 2

Input: sentence = "$3", discount = 33
Output: "$2.01"

Taking 33 percent off 3 leaves 2.01, which written to two digits is "$2.01".

Example 3

Input: sentence = "$", discount = 25
Output: "$"

The word is the marker with no digits after it, so it is not a price and is left unchanged.

Constraints

1 <= sentence.length <= 10^5
sentence consists of lowercase English letters, digits, spaces and '$' only
sentence has no leading or trailing space, and words are separated by single spaces
Every price holds at most 10 digits and no leading zero
0 <= discount <= 100

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def mark_down_prices(sentence: str, discount: int) -> str:

Java

public String markDownPrices(String sentence, int discount)

The intended approach

Time O(L) for a notice of length L: one split, constant work per character, one join.Space O(L) for the rebuilt notice.

Split the notice on spaces and judge each word on its own. A word is a price only when it opens with the marker and everything after it is a digit, with at least one digit present, so the bare marker and anything carrying a letter are left untouched. For a price, work in hundredths of a unit using whole numbers throughout: the amount times a hundred, times what is left after the discount, divided by a hundred with the remainder thrown away. That gives the rounded-down amount in hundredths directly, so no floating point is involved and nothing drifts. Print the whole part and the two remaining digits, then join the words back with single spaces.

Pythonentry point: mark_down_prices

def mark_down_prices(sentence, discount):
    out = []
    for word in sentence.split(" "):
        if len(word) >= 2 and word[0] == "$" and word[1:].isdigit():
            amount = int(word[1:])
            # the reduced amount counted in hundredths, exactly, with no floats
            hundredths = amount * (100 - discount)
            out.append("$%d.%02d" % (hundredths // 100, hundredths % 100))
        else:
            out.append(word)
    return " ".join(out)

The obvious version

Walk the notice character by character to cut it into words, decide whether each word is a price by checking its characters one at a time, and build the reduced amount by string surgery on the digits of the product. Avoids the split-and-join helpers entirely.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_mark_down_prices(sentence, discount):
    words = []
    current = ""
    for ch in sentence:
        if ch == " ":
            words.append(current)
            current = ""
        else:
            current += ch
    words.append(current)
    out = []
    for word in words:
        priced = len(word) >= 2 and word[0] == "$"
        if priced:
            for ch in word[1:]:
                if ch < "0" or ch > "9":
                    priced = False
                    break
        if not priced:
            out.append(word)
            continue
        amount = 0
        for ch in word[1:]:
            amount = amount * 10 + (ord(ch) - 48)
        scaled = amount * (100 - discount)
        text = str(scaled)
        while len(text) < 3:
            text = "0" + text
        whole = text[:-2]
        rest = text[-2:]
        out.append("$" + whole + "." + rest)
    joined = ""
    for i, word in enumerate(out):
        if i:
            joined += " "
        joined += word
    return joined

How this problem was checked

Reference solution executed against 12 test cases — 12 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in