Number of Employees Who Met the Target - Problem

Array Easy

There are n employees in a company, numbered from 0 to n - 1. Each employee i has worked for hours[i] hours in the company.

The company requires each employee to work for at least target hours.

You are given a 0-indexed array of non-negative integers hours of length n and a non-negative integer target.

Return the integer denoting the number of employees who worked at least target hours.

Input & Output

Example 1 — Basic Case

$ Input: hours = [0,1,2,3,4], target = 2

› Output: 3

💡 Note: Employees with indices 2, 3, and 4 worked at least 2 hours: hours[2] = 2, hours[3] = 3, hours[4] = 4

Example 2 — All Meet Target

$ Input: hours = [5,1,4,2,2], target = 1

› Output: 5

💡 Note: All employees worked at least 1 hour, so all 5 employees meet the target

Example 3 — None Meet Target

$ Input: hours = [1,2,3], target = 5

› Output: 0

💡 Note: No employee worked 5 or more hours, so 0 employees meet the target

Constraints

1 ≤ n ≤ 50
0 ≤ hours[i], target ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20

The key insight is to simply count how many array elements are greater than or equal to the target value. Best approach is a single linear scan. Time: O(n), Space: O(1)

Common Approaches

✓ Functional Approach

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

Many programming languages provide built-in functions to filter or count elements that meet a condition. This approach uses those functions for more concise code while maintaining the same O(n) time complexity.

Linear Scan

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

Check each employee's hours against the target requirement. If an employee worked at least the target hours, increment our counter. This is actually the optimal solution for this problem.

Functional Approach — Algorithm Steps

Use filter/count function with condition
Return the count directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Filter

Apply condition h >= target to all elements

Count

Count elements that pass the filter

Result

Return the count

Code -

solution.c — C

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

int solution(int* hours, int hoursSize, int target) {
    int count = 0;
    for (int i = 0; i < hoursSize; i++) {
        if (hours[i] >= target) {
            count++;
        }
    }
    return count;
}

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 line[10000];
    int hours[1000];
    
    // Read hours array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int hoursSize;
    parseArray(line, hours, &hoursSize);
    
    // Read target
    fgets(line, sizeof(line), stdin);
    int target = atoi(line);
    
    // Call solution and print result
    int result = solution(hours, hoursSize, target);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Still need to check every element once

✓ Linear Growth

Space Complexity

O(1)

Built-in functions use constant extra space

✓ Linear Space

25.0K Views

Medium Frequency

~5 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

Number of Employees Who Met the Target - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Functional Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler