0318MediumHash TableStringCounting

Keypad Feedback Code

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 practice keypad holds a stored code and grades each attempt of the same length. Both are strings of digits, and digits may repeat in either of them.

The keypad grades an attempt with two counts:

locked: the number of positions where the attempt has the same digit as the code.
loose: how many of the attempt's remaining digits could be made to fit by moving them to another position. Formally, throw away the locked positions from both strings, and then for each digit value count how many times it survives in the attempt and how many times it survives in the code; the smaller of the two, summed over all ten digit values, is loose. Each surviving code digit can back at most one attempt digit.

Return the grade as the string "locked/loose", for example "2/1" for two locked and one loose. Both numbers are written in decimal with no padding.

Examples

Example 1

Input: code = "4506", attempt = "0456"
Output: "1/3"

Only the last position agrees, giving locked = 1. The leftover code digits are 4, 5, 0 and the leftover attempt digits are 0, 4, 5, which pair up completely, so loose = 3.

Example 2

Input: code = "2233", attempt = "3222"
Output: "1/2"

Position 1 agrees on the digit 2, so locked = 1. What is left of the code is 2, 3, 3 and what is left of the attempt is 3, 2, 2. One 2 and one 3 can be paired, and the attempt's spare 2 has no partner, so loose = 2.

Example 3

Input: code = "111", attempt = "123"
Output: "1/0"

Position 0 agrees, so locked = 1. The leftover code digits are 1, 1 and the leftover attempt digits are 2, 3, which share nothing, so loose = 0.

Example 4

Input: code = "77", attempt = "77"
Output: "2/0"

Both positions agree, so locked = 2 and nothing is left over.

Example 5

Input: code = "1234", attempt = "5678"
Output: "0/0"

No position agrees and no digit value appears in both strings.

Constraints

1 <= code.length, attempt.length <= 1000
code.length == attempt.length
code and attempt consist of digits only.

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 feedback(code: str, attempt: str) -> str:

Java

public String feedback(String code, String attempt)

The intended approach

Time O(n)Space O(1)

One pass over the positions gives `locked` directly and also fills a ten-slot tally for the code's digits and another for the attempt's digits. For each digit value, the smaller of the two tallies is how many copies could be paired anywhere in the string, whether in place or not, so summing those minima and subtracting `locked` leaves the digits that pair only after moving.

Pythonentry point: feedback

def feedback(code, attempt):
    # O(n) time: one pass to compare positions and tally digits, then a fixed
    # sweep over the ten digit buckets. O(1) space, two arrays of ten counters.
    code_counts = [0] * 10
    attempt_counts = [0] * 10
    locked = 0
    for i in range(len(code)):
        c = ord(code[i]) - 48
        a = ord(attempt[i]) - 48
        if c == a:
            locked += 1
        code_counts[c] += 1
        attempt_counts[a] += 1
    shared = 0
    for d in range(10):
        shared += min(code_counts[d], attempt_counts[d])
    return str(locked) + "/" + str(shared - locked)

The obvious version

Cross off the positions that already agree, then walk the leftover attempt digits and, for each one, scan the leftover code digits for the first copy and cross that off too.

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_feedback(code, attempt):
    left = list(code)
    right = list(attempt)
    locked = 0
    for i in range(len(left)):
        if left[i] == right[i]:
            locked += 1
            left[i] = None
            right[i] = None
    loose = 0
    for i in range(len(right)):
        if right[i] is None:
            continue
        for j in range(len(left)):
            if left[j] is not None and left[j] == right[i]:
                loose += 1
                left[j] = None
                break
    return str(locked) + "/" + str(loose)

How this problem was checked

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