0769EasyArrayString

Labels Carrying A Given Letter

Tracked in this browser only

Trains the technique from

LeetCode 2942Find Words Containing Character

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 shelf holds product labels in the order given by labels, where labels[i] is the text printed on the label at position i. You are also given mark, a single lowercase letter.

Find every position whose label has mark somewhere in its text, anywhere at all, not just at the start or the end. A label carrying mark several times still counts as one position.

Return those positions in increasing order. When no label carries mark, return an empty list.

Examples

Example 1

Input: labels = ["mango", "plum", "fig"], mark = "m"
Output: [0, 1]

"mango" opens with the letter and "plum" carries it as its third character, so positions 0 and 1 qualify. "fig" has no "m".

Example 2

Input: labels = ["pear", "plumb", "kale"], mark = "b"
Output: [1]

Only "plumb" carries a "b", and it is the last character of that label, so position 1 is the single answer.

Example 3

Input: labels = ["fig", "kiwi"], mark = "q"
Output: []

Neither label contains a "q", so the answer is empty.

Constraints

1 <= labels.length <= 50
1 <= labels[i].length <= 50
mark is a lowercase English letter.
labels[i] consists only of lowercase English letters.

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 labels_with_letter(labels: list[str], mark: str) -> list[int]:

Java

public List<Integer> labelsWithLetter(String[] labels, char mark)

The intended approach

Time O(T) for T characters across all labels.Space O(k) for the k positions returned.

Walk the shelf once from position 0 upwards and test each label for the letter, appending the position when it is present. Visiting positions in order means the result comes out sorted with no extra work, and appending at most once per label keeps repeats out.

Pythonentry point: labels_with_letter

def labels_with_letter(labels, mark):
    # Time O(T) for T characters across every label, space O(k) for the k hits.
    hits = []
    for i in range(len(labels)):
        if mark in labels[i]:
            hits.append(i)
    return hits

The obvious version

Build a full lookup the other way round: for each of the 26 lowercase letters, collect the positions of the labels whose distinct characters include it, then hand back the list stored against `mark`.

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_labels_with_letter(labels, mark):
    index = {}
    for ch in "abcdefghijklmnopqrstuvwxyz":
        index[ch] = []
    for i in range(len(labels)):
        seen = set()
        for ch in labels[i]:
            seen.add(ch)
        for ch in sorted(seen):
            index[ch].append(i)
    return index[mark]

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