0376EasyMathStringSimulation

Exposure Counter Sum

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.

An archival telescope keeps its shutter counters as decimal text, because the running totals outgrow every machine word the logger owns. You are handed two such counters, left and right, each a string of digits with no leading zeros unless the counter itself is "0".

Return the sum of the two counters, again as a digit string with no leading zeros.

The logger has no arbitrary-precision arithmetic available, so you must stay on the characters: do not convert left or right into a built-in big integer, do not call a library routine that parses a numeric string for you, and do not hand the work to a big-number package.

Examples

Example 1

Input: left = "907", right = "35"
Output: "942"

The two counters total 942, reported in the same digit-string form.

Example 2

Input: left = "6", right = "3994"
Output: "4000"

The total is 4000, which is as many digits as the longer counter.

Example 3

Input: left = "88", right = "12"
Output: "100"

The total is 100, one digit longer than either counter.

Example 4

Input: left = "40", right = "0"
Output: "40"

Adding the zero counter leaves the other counter unchanged.

Constraints

1 <= left.length, right.length <= 10^4
left and right consist of digits only.
left and right have no leading zeros except for the single digit 0 itself.

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 add_strings(left: str, right: str) -> str:

Java

public String addStrings(String left, String right)

The intended approach

Time O(max(m, n))Space O(max(m, n)) for the digit buffer that is returned

Walk both counters from their last character towards their first, adding the two digits plus whatever was carried out of the previous column and keeping the low digit of each column. A counter that has run out contributes 0, and the loop keeps going while a carry is still outstanding, so a wider answer than either input needs no special case. The digits come out least significant first, so reverse the buffer before joining it.

Pythonentry point: add_strings

def add_strings(left, right):
    # Time O(max(m, n)) -- one pass over the longer counter.
    # Space O(max(m, n)) for the digit buffer that becomes the answer.
    i = len(left) - 1
    j = len(right) - 1
    carry = 0
    out = []
    while i >= 0 or j >= 0 or carry:
        a = ord(left[i]) - 48 if i >= 0 else 0
        b = ord(right[j]) - 48 if j >= 0 else 0
        total = a + b + carry
        out.append(chr(48 + total % 10))
        carry = total // 10
        i -= 1
        j -= 1
    out.reverse()
    return "".join(out)

The obvious version

Fold each counter into a Python integer with Horner's rule, add the two integers, and format the result. Uses arbitrary-precision arithmetic that the statement denies the reference implementation, so it is a genuinely different route to the same value.

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_add_strings(left, right):
    a = 0
    for ch in left:
        a = a * 10 + (ord(ch) - 48)
    b = 0
    for ch in right:
        b = b * 10 + (ord(ch) - 48)
    return str(a + b)

How this problem was checked

Reference solution executed against 9 test cases — 9 passed
4 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