0663EasyArrayHash TableCounting

Face Values Held Only Once

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 stamp album lists the face value of every stamp mounted in it, in mounting order, as the list faces. A face value is called a singleton when exactly one stamp in the album carries it.

Return the total of the singleton face values. A face value carried by two or more stamps contributes nothing at all, not even one copy. Return 0 when the album holds no singleton.

Examples

Example 1

Input: faces = [8, 3, 8, 5]
Output: 8

Face value 8 is carried by two stamps, so it drops out. The singletons are 3 and 5, which total 8.

Example 2

Input: faces = [7, 7, 7, 2]
Output: 2

Three stamps carry face value 7, so it is not a singleton. Only 2 is, and the total is 2.

Example 3

Input: faces = [6, 6, 6]
Output: 0

Every stamp in the album carries the same face value, so the album holds no singleton and the total is 0.

Constraints

1 <= faces.length <= 100
1 <= faces[i] <= 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 sum_singleton_values(faces: list[int]) -> int:

Java

public int sumSingletonValues(int[] faces)

The intended approach

Time O(n): one pass to tally and one pass over the distinct values.Space O(n) for the tally.

Walk the album once and tally how many stamps carry each face value. Then walk the tally and add up the values whose count came out at exactly one, which skips both the values held twice and the values held more often.

Pythonentry point: sum_singleton_values

def sum_singleton_values(faces):
    # Tally the face values, then add up the ones tallied exactly once.
    # O(n) time, O(n) space.
    tally = {}
    for v in faces:
        tally[v] = tally.get(v, 0) + 1
    total = 0
    for v in tally:
        if tally[v] == 1:
            total += v
    return total

The obvious version

For each mounted stamp, rescan the whole album counting how many stamps carry the same face value, and add that value in only when the count comes out at one.

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_sum_singleton_values(faces):
    n = len(faces)
    total = 0
    for i in range(n):
        hits = 0
        for j in range(n):
            if faces[j] == faces[i]:
                hits += 1
        if hits == 1:
            total += faces[i]
    return total

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