Friends Of Appropriate Ages

Friends Of Appropriate Ages - Problem

There are n people on a social media website. You are given an integer array ages where ages[i] is the age of the i^th person.

A person x will not send a friend request to person y (where x != y) if any of the following conditions is true:

age[y] <= 0.5 * age[x] + 7
age[y] > age[x]
age[y] > 100 && age[x] < 100

Otherwise, person x will send a friend request to person y.

Note that if x sends a request to y, y will not necessarily send a request to x. Also, a person will not send a friend request to themselves.

Return the total number of friend requests made.

Input & Output

Example 1 — Basic Case

$ Input: ages = [16,16]

› Output: 2

💡 Note: Both 16-year-olds can send requests to each other. Person 0 sends to person 1, and person 1 sends to person 0. Total: 2 requests.

Example 2 — Multiple Ages

$ Input: ages = [16,17,18]

› Output: 2

💡 Note: Person aged 17 can send to 16 (17 > 0.5×17+7=15.5). Person aged 18 can send to 17 (18 > 0.5×18+7=16). Total: 2 requests.

Example 3 — No Valid Requests

$ Input: ages = [20,30,100,110,120]

› Output: 3

💡 Note: Only age 100 people can send requests among themselves. With 1 person of age 100, no requests are possible between different people.

Constraints

1 ≤ ages.length ≤ 2 × 10⁴
1 ≤ ages[i] ≤ 120

Visualization

Tap to expand

Asked in

F Facebook 35 G Google 28 a Amazon 22

The key insight is that friend requests follow three age-based rules that can be optimized using sorting and binary search. The binary search approach sorts ages first, then for each person efficiently finds their valid age range using binary search. Time: O(n log n), Space: O(1).

Common Approaches

✓ Optimized

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

Binary Search Optimization

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

After sorting the ages array, for each person use binary search to efficiently find the range of valid ages they can send friend requests to, based on the three age conditions.

Brute Force

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

For each person x, iterate through all other people y and check if x would send a friend request to y based on the three age conditions. Count all valid requests.

Sort and Count

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

Sort the ages array and count frequencies of each age. For each unique age, calculate how many valid friend requests can be sent, then multiply by the frequency count to avoid redundant calculations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* parseIntArray(char* str, int* size) {
    *size = 0;
    if (strlen(str) <= 2) return NULL;
    
    // Count numbers
    for (int i = 1; i < strlen(str) - 1; i++) {
        if ((str[i] == ',' || str[i] == ']') && isdigit(str[i-1])) (*size)++;
    }
    
    int* arr = (int*)malloc(*size * sizeof(int));
    int idx = 0, num = 0, inNum = 0;
    
    for (int i = 1; i < strlen(str) - 1; i++) {
        if (isdigit(str[i])) {
            num = num * 10 + (str[i] - '0');
            inNum = 1;
        } else if (inNum) {
            arr[idx++] = num;
            num = 0;
            inNum = 0;
        }
    }
    return arr;
}

int solution(int* ages, int n) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                continue;
            }
            
            int x_age = ages[i];
            int y_age = ages[j];
            
            // Check the three conditions where x will NOT send request to y
            if (y_age <= 0.5 * x_age + 7) {
                continue;
            }
            if (y_age > x_age) {
                continue;
            }
            if (y_age > 100 && x_age < 100) {
                continue;
            }
            
            // If none of the blocking conditions are true, x sends request to y
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[100000];
    
    // Read ages array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int agesSize;
    int* ages = parseIntArray(line, &agesSize);
    
    int result = solution(ages, agesSize);
    printf("%d\n", result);
    
    free(ages);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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