Friends Of Appropriate Ages - Practice Coding Problems

Friends Of Appropriate Ages - Problem

Friends Of Appropriate Ages

You're building a social media platform where users can send friend requests to each other. However, you need to implement an age-appropriate friend matching system to ensure meaningful connections.

Given an array ages where ages[i] represents the age of the i-th person, you need to determine how many friend requests will be sent in total.

Friend Request Rules:
Person x will NOT send a friend request to person y if any of these conditions are true:
• age[y] <= 0.5 * age[x] + 7 (y is too young for x)
• age[y] > age[x] (y is older than x)
• age[y] > 100 && age[x] < 100 (special rule for users over 100)

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

Important: Friend requests are unidirectional (x sending to y doesn't mean y sends to x), and people don't send requests to themselves.

Return the total number of friend requests that will be sent.

Input & Output

example_1.py — Basic Case

$ Input: [16,16]

› Output: 2

💡 Note: Both 16-year-olds can send friend requests to each other. Person 0 sends to Person 1, and Person 1 sends to Person 0. For age 16: valid range is (15.5, 16] = 16, so they can send requests to each other.

example_2.py — Mixed Ages

$ Input: [16,17,18]

› Output: 2

💡 Note: Age 17 can send to 16 (17 > 15.5), Age 18 can send to both 16 and 17. Age 16 cannot send to anyone (16 ≤ 15 for 17, 16 ≤ 16 for 18 but 16 < 17 and 16 < 18). Total: 0 + 1 + 1 = 2 requests.

example_3.py — No Valid Requests

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

› Output: 3

💡 Note: Age 20: can't send to anyone (all others too old). Age 30: can send to 20. Age 100: can send to 20 and 30. Ages 110,120: can send to everyone except those over 100 when sender < 100. Total: 0 + 1 + 2 + 0 + 0 = 3.

Constraints

n == ages.length
1 ≤ n ≤ 2 × 10⁴
1 ≤ ages[i] ≤ 120
All ages are positive integers between 1 and 120

Visualization

Tap to expand

Key Insight: Group by age + math beats checking every pair!

Understanding the Visualization

Understand the Rules

Each person has three age-based restrictions that determine who they won't send requests to

Brute Force Check

The naive approach checks every possible sender-receiver pair individually

Optimize with Grouping

Group people by age and calculate valid ranges mathematically

Use Prefix Sums

Build cumulative counts to quickly determine how many people fall in any age range

Key Takeaway

🎯 Key Insight: By grouping people by age and using mathematical range calculations with prefix sums, we reduce complexity from O(n²) to O(A²) where A=120, making the solution much more efficient for large datasets with duplicate ages.

Asked in

f Facebook 35 G Google 28 a Amazon 22 ⊞ Microsoft 15

The optimal solution uses frequency counting and prefix sums to achieve O(A²) time complexity where A=120 (age range). Instead of checking every pair individually (O(n²)), we group people by age and use mathematical range calculations to count valid requests efficiently. This approach scales much better when there are many people with duplicate ages.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(1)	Check every possible pair of people to see if a friend request would be sent
Optimized with Frequency Counting	O(A²)	O(A)	Count frequency of each age and use mathematical range calculations to avoid redundant work
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort ages and use two pointers to efficiently find valid age ranges for each person

Brute Force (Check All Pairs) — Algorithm Steps

Iterate through each person x in the ages array
For each person x, iterate through all other people y
Skip if x equals y (same person)
Check the three rejection conditions
If none of the rejection conditions are met, increment the friend request count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the first person as sender

Check All Recipients

For each sender, check all possible recipients

Apply Rules

Apply the three age-based rejection rules

Count Valid Requests

Increment counter for valid friend requests

Code -

solution.c — C

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

int numFriendRequests(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 ageX = ages[i];
            int ageY = ages[j];
            
            // Check the three rejection conditions
            if (ageY <= 0.5 * ageX + 7) continue;
            if (ageY > ageX) continue;
            if (ageY > 100 && ageX < 100) continue;
            
            // If none of the conditions are met, send friend request
            count++;
        }
    }
    
    return count;
}

int main() {
    int ages[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d", &ages[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%d\n", numFriendRequests(ages, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every pair of people, resulting in n × (n-1) comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store counts and loop indices

✓ Linear Space

28.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler