Happy Students

Happy Students - Problem

You are given a 0-indexed integer array nums of length n where n is the total number of students in the class. The class teacher tries to select a group of students so that all the students remain happy.

The i^th student will become happy if one of these two conditions is met:

The student is selected and the total number of selected students is strictly greater than nums[i].
The student is not selected and the total number of selected students is strictly less than nums[i].

Return the number of ways to select a group of students so that everyone remains happy.

Input & Output

Example 1 — Simple Case

$ Input: nums = [1,1]

› Output: 1

💡 Note: Only one way works: select no students. Both students are happy because 0 < 1, so they're satisfied being unselected.

Example 2 — Multiple Options

$ Input: nums = [6,0,3,3,6,7,2,3]

› Output: 3

💡 Note: Three valid selection sizes work: selecting 0 students, 4 students, or 7 students can make everyone happy.

Example 3 — No Solution

$ Input: nums = [1,2,3]

› Output: 0

💡 Note: No selection size can satisfy all students simultaneously due to conflicting requirements.

Constraints

1 ≤ nums.length ≤ 50
0 ≤ nums[i] < nums.length

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6

The key insight is that student happiness depends on the total selection count, not specific individuals selected. We can enumerate each possible selection size k and check if all constraints can be satisfied. Best approach uses mathematical categorization to count valid arrangements efficiently. Time: O(n²), Space: O(1)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Three Pointers

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(n × 2^n) Space: O(1)

For each of the 2^n possible subsets, check if all students (both selected and unselected) are happy based on the subset size.

Optimized Enumeration with Early Pruning

⏱️ Time: O(n²) Space: O(1)

Instead of checking every subset, we focus on the key insight that only certain selection sizes can work. We enumerate these sizes and count valid arrangements mathematically.

Sort and Enumerate Valid Sizes

⏱️ Time: O(n²) Space: O(1)

Sort students by their happiness requirements, then for each possible selection size k, check if we can find k students that would be happy being selected while others are happy being unselected.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseInt(char* str, int* arr, int maxSize) {
    int count = 0;
    char* token;
    char* copy = strdup(str);
    
    // Remove brackets and spaces
    char* start = strchr(copy, '[');
    char* end = strchr(copy, ']');
    if (start && end) {
        start++;
        *end = '\0';
        if (strlen(start) > 0) {
            token = strtok(start, ",");
            while (token != NULL && count < maxSize) {
                arr[count++] = atoi(token);
                token = strtok(NULL, ",");
            }
        }
    }
    
    free(copy);
    return count;
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* solution(int* arr1, int arr1Size, int* arr2, int arr2Size, int* arr3, int arr3Size, int* returnSize) {
    int* result = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    // For each element in arr1, check if it's in arr2 and arr3
    for (int i = 0; i < arr1Size; i++) {
        int num = arr1[i];
        int foundInArr2 = 0, foundInArr3 = 0;
        
        for (int j = 0; j < arr2Size; j++) {
            if (arr2[j] == num) {
                foundInArr2 = 1;
                break;
            }
        }
        
        if (foundInArr2) {
            for (int k = 0; k < arr3Size; k++) {
                if (arr3[k] == num) {
                    foundInArr3 = 1;
                    break;
                }
            }
        }
        
        if (foundInArr2 && foundInArr3) {
            result[(*returnSize)++] = num;
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[10000], line2[10000], line3[10000];
    int arr1[1000], arr2[1000], arr3[1000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    int arr1Size = parseInt(line1, arr1, 1000);
    int arr2Size = parseInt(line2, arr2, 1000);
    int arr3Size = parseInt(line3, arr3, 1000);
    
    int returnSize;
    int* result = solution(arr1, arr1Size, arr2, arr2Size, arr3, arr3Size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

8.9K Views

Medium Frequency

~25 min Avg. Time

234 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