Reward Top K Students - Practice Coding Problems

Reward Top K Students - Problem

Array Hash Table String Sorting Heap (Priority Queue) Medium

Imagine you're building a student evaluation system for a coding bootcamp! 🎓

You have feedback reports from instructors about students, and you need to automatically rank students based on their performance to reward the top performers.

Here's how the scoring works:

Each positive word in a feedback report gives +3 points
Each negative word in a feedback report gives -1 point
Students start with 0 points

Your task: Given feedback reports and student IDs, return the top K students ranked by their total points. If students have the same points, the one with the lower student ID ranks higher.

Input: Arrays of positive/negative words, feedback reports, student IDs, and K

Output: Array of top K student IDs in descending order by points

Input & Output

example_1.py — Basic Case

$ Input: positive_feedback = ["smart","brilliant","studious"] negative_feedback = ["not"] report = ["this student is studious","the student is smart"] student_id = [1,2] k = 2

› Output: [1,2]

💡 Note: Student 1: 'studious' (+3) = 3 points. Student 2: 'smart' (+3) = 3 points. Both have same score, so lower ID (1) ranks higher.

example_2.py — Mixed Feedback

$ Input: positive_feedback = ["smart","brilliant","studious"] negative_feedback = ["not"] report = ["this student is not studious","the student is smart"] student_id = [1,2] k = 2

› Output: [2,1]

💡 Note: Student 1: 'not' (-1) + 'studious' (+3) = 2 points. Student 2: 'smart' (+3) = 3 points. Student 2 has higher score.

example_3.py — Neutral Words

$ Input: positive_feedback = ["smart","brilliant"] negative_feedback = ["not","poor"] report = ["the student works hard","this student is brilliant"] student_id = [3,1] k = 1

› Output: [1]

💡 Note: Student 3: 'works' and 'hard' are neutral words = 0 points. Student 1: 'brilliant' (+3) = 3 points. Return top 1 student.

Time & Space Complexity

Time Complexity

⏱️

O(n*m + s*log(s))

n reports × m words for scoring + s students × log(s) for sorting

⚡ Linearithmic

Space Complexity

O(p + s)

p positive/negative words in hash sets + s students in score map

✓ Linear Space

Constraints

1 ≤ positive_feedback.length, negative_feedback.length ≤ 10⁴
1 ≤ positive_feedback[i].length, negative_feedback[i].length ≤ 100
1 ≤ report.length ≤ 10⁴
1 ≤ report[i].length ≤ 100
1 ≤ student_id.length ≤ 10⁴
1 ≤ k ≤ student_id.length
No word appears in both positive_feedback and negative_feedback
All strings consist of lowercase English letters and spaces
Each student_id[i] is unique

Asked in

The optimal solution uses hash sets for O(1) word lookup and sorts students by score. For small K values, a min-heap approach can be more space-efficient by maintaining only the top K students instead of sorting all students.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set + Min-Heap (Space Optimized)	O(nm + slog K + K*log K)	O(p + K)	Use hash sets for word lookup and min-heap to maintain top K students
Brute Force (Linear Search)	O(n * m * p)	O(s)	Check each word against positive/negative arrays for every report
Hash Set + Sorting (Optimal)	O(nm + slog(s))	O(p + s)	Use hash sets for O(1) word lookup, then sort students by score

Hash Set + Min-Heap (Space Optimized) — Algorithm Steps

Convert positive_feedback and negative_feedback to hash sets
Initialize a min-heap to store top K students
For each report, calculate student score using hash set lookup
Add/update student in min-heap, maintaining size K
Extract all students from heap and sort by score desc, ID asc

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Scores

Process reports and calculate student scores using hash sets

Maintain Min-Heap

Keep only top K students in a min-heap of size K

Extract & Sort

Extract K students and sort them properly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_WORDS 1000
#define MAX_WORD_LEN 100

typedef struct {
    char word[MAX_WORD_LEN];
} WordSet;

typedef struct {
    int id;
    int score;
} Student;

// Simple heap implementation for top K
typedef struct {
    Student* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->data = (Student*)malloc(capacity * sizeof(Student));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        Student* curr = &heap->data[index];
        Student* par = &heap->data[parent];
        
        if (curr->score > par->score || (curr->score == par->score && curr->id < par->id)) {
            break;
        }
        
        Student temp = *curr;
        *curr = *par;
        *par = temp;
        index = parent;
    }
}

void heapifyDown(MinHeap* heap, int index) {
    while (1) {
        int minIndex = index;
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        
        if (left < heap->size) {
            Student* leftChild = &heap->data[left];
            Student* minChild = &heap->data[minIndex];
            if (leftChild->score < minChild->score || 
                (leftChild->score == minChild->score && leftChild->id > minChild->id)) {
                minIndex = left;
            }
        }
        
        if (right < heap->size) {
            Student* rightChild = &heap->data[right];
            Student* minChild = &heap->data[minIndex];
            if (rightChild->score < minChild->score || 
                (rightChild->score == minChild->score && rightChild->id > minChild->id)) {
                minIndex = right;
            }
        }
        
        if (minIndex == index) break;
        
        Student temp = heap->data[index];
        heap->data[index] = heap->data[minIndex];
        heap->data[minIndex] = temp;
        index = minIndex;
    }
}

void pushHeap(MinHeap* heap, Student student) {
    if (heap->size < heap->capacity) {
        heap->data[heap->size] = student;
        heapifyUp(heap, heap->size);
        heap->size++;
    } else {
        Student* top = &heap->data[0];
        if (student.score > top->score || (student.score == top->score && student.id < top->id)) {
            heap->data[0] = student;
            heapifyDown(heap, 0);
        }
    }
}

int findInSet(WordSet* set, int size, const char* word) {
    for (int i = 0; i < size; i++) {
        if (strcmp(set[i].word, word) == 0) {
            return 1;
        }
    }
    return 0;
}

int compare(const void* a, const void* b) {
    Student* sa = (Student*)a;
    Student* sb = (Student*)b;
    if (sa->score == sb->score) {
        return sa->id - sb->id;
    }
    return sb->score - sa->score;
}

int* topKStudents(char** positive_feedback, int positive_size, char** negative_feedback, int negative_size, 
                  char** report, int* student_id, int report_size, int k, int* returnSize) {
    // Create word sets
    WordSet* positive_set = (WordSet*)malloc(positive_size * sizeof(WordSet));
    WordSet* negative_set = (WordSet*)malloc(negative_size * sizeof(WordSet));
    
    for (int i = 0; i < positive_size; i++) {
        strcpy(positive_set[i].word, positive_feedback[i]);
    }
    for (int i = 0; i < negative_size; i++) {
        strcpy(negative_set[i].word, negative_feedback[i]);
    }
    
    // Calculate student scores
    Student* all_students = (Student*)malloc(report_size * sizeof(Student));
    
    for (int i = 0; i < report_size; i++) {
        int score = 0;
        char* report_copy = strdup(report[i]);
        char* word = strtok(report_copy, " ");
        
        while (word != NULL) {
            if (findInSet(positive_set, positive_size, word)) {
                score += 3;
            } else if (findInSet(negative_set, negative_size, word)) {
                score -= 1;
            }
            word = strtok(NULL, " ");
        }
        
        all_students[i].id = student_id[i];
        all_students[i].score = score;
        free(report_copy);
    }
    
    // Use min-heap to find top K
    MinHeap* heap = createHeap(k);
    
    for (int i = 0; i < report_size; i++) {
        pushHeap(heap, all_students[i]);
    }
    
    // Extract from heap and sort
    Student* top_students = (Student*)malloc(k * sizeof(Student));
    for (int i = 0; i < k; i++) {
        top_students[i] = heap->data[i];
    }
    
    qsort(top_students, k, sizeof(Student), compare);
    
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        result[i] = top_students[i].id;
    }
    
    *returnSize = k;
    
    // Cleanup
    free(positive_set);
    free(negative_set);
    free(all_students);
    free(heap->data);
    free(heap);
    free(top_students);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m + s*log K + K*log K)

n reports × m words + s students × log K heap ops + K log K final sort

⚡ Linearithmic

Space Complexity

O(p + K)

p words in hash sets + K students in min-heap

✓ Linear Space

Constraints

1 ≤ positive_feedback.length, negative_feedback.length ≤ 10⁴
1 ≤ positive_feedback[i].length, negative_feedback[i].length ≤ 100
1 ≤ report.length ≤ 10⁴
1 ≤ report[i].length ≤ 100
1 ≤ student_id.length ≤ 10⁴
1 ≤ k ≤ student_id.length
No word appears in both positive_feedback and negative_feedback
All strings consist of lowercase English letters and spaces
Each student_id[i] is unique

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Set + Min-Heap (Space Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler