0246MediumArrayHash TableStringTrieSortingHeap (Priority Queue)Bucket SortCounting

Most Drawn Part Codes

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 repair bay logs the code of every part it lifts off the shelf. The log arrives as draws, the part codes in the order they were lifted, one entry per part, so a code drawn four times appears four times.

Return the k codes drawn the most, listed from the most drawn down to the least drawn among them.

Codes drawn the same number of times are listed in dictionary order, which keeps the answer unambiguous. Dictionary order compares two codes letter by letter from the front and settles them at the first letter that differs; when one code is a prefix of the other, the shorter code comes first.

Examples

Example 1

Input: draws = ["ratchet", "clamp", "ratchet", "shim", "clamp", "ratchet"], k = 2
Output: ["ratchet", "clamp"]

The bay drew ratchet three times, clamp twice and shim once, so the two most drawn codes are ratchet then clamp.

Example 2

Input: draws = ["shim", "bolt", "shim", "bolt", "nut"], k = 2
Output: ["bolt", "shim"]

Both shim and bolt were drawn twice, so they are listed in dictionary order, which puts bolt first; nut was drawn once and misses out.

Example 3

Input: draws = ["ab", "b", "ab", "b", "cd"], k = 3
Output: ["ab", "b", "cd"]

Codes ab and b were each drawn twice and ab is earlier in dictionary order, since a comes before b at the first letter. Code cd was drawn once and takes the last place.

Constraints

1 <= draws.length <= 500
1 <= draws[i].length <= 10
draws[i] consists of lowercase English letters
1 <= k <= the number of distinct codes in draws

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 busiest_codes(draws: list[str], k: int) -> list[str]:

Java

public List<String> busiestCodes(String[] draws, int k)

The intended approach

Time O(n * L + m * L * log m) for n draws, m distinct codes and code length L <= 10.Space O(m * L) for the tally and the ordering, plus the k codes returned.

Tally the draws in a hash map keyed by code. Then order the distinct codes by a single compound key, the negated tally followed by the code itself, so the descending count and the dictionary tie-break fall out of one sort, and hand back the first k.

Pythonentry point: busiest_codes

def busiest_codes(draws, k):
    tally = {}
    for code in draws:
        tally[code] = tally.get(code, 0) + 1
    ranked = sorted(tally, key=lambda code: (-tally[code], code))
    return ranked[:k]

The obvious version

Tally the draws, then run k selection rounds: each round scans every code still available and keeps the one with the larger tally, or the earlier code in dictionary order when the tallies match. O(k * m * L).

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_busiest_codes(draws, k):
    tally = {}
    for code in draws:
        tally[code] = tally.get(code, 0) + 1
    left = list(tally)
    picked = []
    for _ in range(k):
        best = None
        for code in left:
            if best is None:
                best = code
            elif tally[code] > tally[best]:
                best = code
            elif tally[code] == tally[best] and code < best:
                best = code
        left.remove(best)
        picked.append(best)
    return picked

How this problem was checked

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