0724EasyArrayStringSimulation

Hand Tally Reading After The Log

Tracked in this browser only

Trains the technique from

LeetCode 2011Final Value of Variable After Performing Operations

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 stock clerk carries a hand tally whose reading starts at 0. Every adjustment is written into a log as one of four three-character tokens naming the tally n:

"++n" and "n++" each raise the reading by one;
"--n" and "n--" each lower it by one.

Whether the clerk wrote the pair of signs before or after the letter makes no difference to what happens to the reading.

taps holds the log entries in the order they were made. Return the reading once every entry has been applied. The reading may end up negative.

Examples

Example 1

Input: taps = ["--n", "n++", "n++"]
Output: 1

The reading starts at 0, drops to -1, then rises to 0 and to 1.

Example 2

Input: taps = ["n--", "n--", "--n"]
Output: -3

All three entries lower the reading, so it runs 0, -1, -2, -3.

Example 3

Input: taps = ["++n"]
Output: 1

A single rise takes the reading from 0 to 1.

Constraints

1 <= taps.length <= 100
taps[i].length == 3
Every entry of taps is one of "++n", "n++", "--n" or "n--".

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 counter_reading(taps: list[str]) -> int:

Java

public int counterReading(String[] taps)

The intended approach

Time O(L) for L log entries.Space O(1)

Only the pair of signs in a token matters, not where it was written, so walk the log once and move the reading up by one for a token that carries plus signs and down by one for a token that carries minus signs.

Pythonentry point: counter_reading

def counter_reading(taps):
    # A token raises the reading exactly when it carries plus signs, whichever side
    # of the letter they were written on, so one test per token is enough.
    # Time O(L) for L log entries.  Space O(1).
    reading = 0
    for token in taps:
        if "+" in token:
            reading += 1
        else:
            reading -= 1
    return reading

The obvious version

Spell out all four tokens in a lookup table mapping each to its change, then add up the change for every entry of the log in order.

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_counter_reading(taps):
    table = {"++n": 1, "n++": 1, "--n": -1, "n--": -1}
    reading = 0
    for token in taps:
        reading = reading + table[token]
    return reading

How this problem was checked

Reference solution executed against 10 test cases — 10 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