0830MediumArrayHash TableStringSortingHeap (Priority Queue)

Top Reviewers by Note Score

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 workshop scores its reviewers on the notes they leave. positive_feedback lists the words counted as praise and negative_feedback lists the words counted as criticism. No word appears in both lists.

report[i] is the note left by the reviewer whose badge number is student_id[i]. A note is lowercase words separated by single spaces. Scoring a note starts at zero, adds 3 for each word of the note that appears in the praise list, and subtracts 1 for each word that appears in the criticism list. A word only counts when it matches a listed word exactly; a listed word appearing inside a longer word does not count. A word counts once for each time it appears in the note.

Rank the reviewers by score, highest first, and settle a tie in favour of the smaller badge number. Return the badge numbers of the top k reviewers, in that ranked order.

Examples

Example 1

Input: positive_feedback = ["neat", "sharp"], negative_feedback = ["messy", "late"], report = ["neat work sharp finish", "messy and late", "plain work"], student_id = [42, 7, 19], k = 2
Output: [42, 19]

Badge 42 leaves two praise words for a score of 6. Badge 19 leaves none of either, scoring 0. Badge 7 leaves two criticism words, scoring -2. The top two in that order are 42 then 19.

Example 2

Input: positive_feedback = ["neat"], negative_feedback = ["messy"], report = ["neat", "neat"], student_id = [9, 4], k = 2
Output: [4, 9]

Both reviewers score 3. The tie is settled in favour of the smaller badge number, so badge 4 is ranked ahead of badge 9.

Example 3

Input: positive_feedback = ["neat"], negative_feedback = ["messy"], report = ["neatly done", "neat"], student_id = [3, 8], k = 2
Output: [8, 3]

The word "neatly" is not the listed word "neat", so badge 3 scores 0 while badge 8 scores 3.

Constraints

1 <= positive_feedback.length <= 10^4
1 <= negative_feedback.length <= 10^4
1 <= positive_feedback[i].length <= 100
1 <= negative_feedback[i].length <= 100
No word appears in both positive_feedback and negative_feedback
1 <= report.length <= 10^4
report.length == student_id.length
1 <= report[i].length <= 100
report[i] is lowercase words separated by single spaces
1 <= student_id[i] <= 10^9
All badge numbers are distinct
1 <= k <= 10^4
k <= report.length

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 top_reviewers(positive_feedback: list[str], negative_feedback: list[str], report: list[str], student_id: list[int], k: int) -> list[int]:

Java

public List<Integer> topReviewers(String[] positiveFeedback, String[] negativeFeedback, String[] report, int[] studentId, int k)

The intended approach

Time O(P + N + S + n log n) for total word lengths P and N, total note length S and n reviewers.Space O(P + N + n) for the two sets and the scored pairs.

Put both word lists into sets so a lookup is constant time, then split each note on spaces and total its marks, treating a word as praise or criticism but never both since the lists are disjoint. Pair each total with its badge number, negating the total so that one ordinary ascending sort puts the highest score first and, within an equal score, the smaller badge number first. Take the leading k pairs.

Pythonentry point: top_reviewers

def top_reviewers(positive_feedback, negative_feedback, report, student_id, k):
    good = set(positive_feedback)
    bad = set(negative_feedback)
    scored = []
    for note, who in zip(report, student_id):
        marks = 0
        for word in note.split():
            if word in good:
                marks += 3
            elif word in bad:
                marks -= 1
        # a higher score wins; on a tie the smaller id wins, so sort on the
        # negated score and then the id
        scored.append((-marks, who))
    scored.sort()
    return [who for _marks, who in scored[:k]]

The obvious version

Score every note by scanning the raw word lists for each of its words, then pick the leading reviewer k times by walking the whole scored list and taking the best not yet picked. No sorting and no sets.

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_top_reviewers(positive_feedback, negative_feedback, report, student_id, k):
    rows = []
    for i in range(len(report)):
        marks = 0
        for word in report[i].split(" "):
            if word == "":
                continue
            if word in positive_feedback:
                marks += 3
            if word in negative_feedback:
                marks -= 1
        rows.append([student_id[i], marks])
    picked = []
    for _ in range(k):
        best = None
        for row in rows:
            if row in picked:
                continue
            if best is None:
                best = row
                continue
            if row[1] > best[1] or (row[1] == best[1] and row[0] < best[0]):
                best = row
        picked.append(best)
    return [row[0] for row in picked]

How this problem was checked

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