Count Number of Teams - Practice Coding Problems

Count Number of Teams - Problem

In a military formation, there are n soldiers standing in a line, each with a unique rating value that represents their skill level. Your mission is to form special reconnaissance teams of exactly 3 soldiers each.

A valid team must follow strict formation rules:

Choose 3 soldiers at positions i < j < k
Their ratings must form either an ascending sequence (rating[i] < rating[j] < rating[k]) or a descending sequence (rating[i] > rating[j] > rating[k])

For example, with ratings [2, 5, 3, 4, 1], you can form teams like:

Ascending: positions (0,2,3) → ratings (2,3,4)
Descending: positions (1,2,4) → ratings (5,3,1)

Goal: Count the total number of valid teams that can be formed. Note that soldiers can participate in multiple teams.

Input & Output

example_1.py — Basic Case

$ Input: [2,5,3,4,1]

› Output: 3

💡 Note: Valid teams: (0,2,3) with ratings (2,3,4) ascending, (0,1,2) with ratings (2,5,3) descending, and (1,2,4) with ratings (5,3,1) descending

example_2.py — All Ascending

$ Input: [1,2,3,4,5]

› Output: 10

💡 Note: All possible triplets form ascending teams: C(5,3) = 10 teams total. Examples: (1,2,3), (1,2,4), (1,2,5), (1,3,4), etc.

example_3.py — Minimum Length

$ Input: [1,4,2]

› Output: 1

💡 Note: Only one valid team: positions (0,2,1) but indices must be in order, so (0,1,2) gives ratings (1,4,2) which forms a descending team after reordering

Constraints

3 ≤ n ≤ 1000
1 ≤ rating[i] ≤ 10⁵
All ratings are unique
Need to count teams, not find them

Visualization

Tap to expand

Understanding the Visualization

Pick the Middle

Choose the middle person in each potential group

Count Left Partners

Count people to the left who are shorter/taller

Count Right Partners

Count people to the right who are taller/shorter

Multiply Combinations

Multiply left and right counts to get total valid groups

Key Takeaway

🎯 Key Insight: Fix the middle element and count valid partners on both sides - this transforms a complex combinatorial problem into simple counting and multiplication.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal approach uses the middle element strategy: for each soldier as the middle one, count how many on the left are smaller/larger and how many on the right are larger/smaller, then multiply these counts. This reduces complexity from O(n³) brute force to O(n²), or even O(n log n) with advanced data structures like Binary Indexed Trees.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Indexed Tree (Advanced Optimal)	O(n log n)	O(n)	Use Binary Indexed Tree for efficient counting of smaller/larger elements
Two-Pass Counting (Optimized)	O(n²)	O(1)	Fix middle soldier and count valid left/right partners separately
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets (i,j,k) and count valid teams

Binary Indexed Tree (Advanced Optimal) — Algorithm Steps

Coordinate compression: map ratings to indices 1 to n
For each position j, use BIT to count elements smaller/larger on the left
Update BIT with current element
For ascending teams: multiply left_smaller with (total_right - processed_right - greater_right)
For descending teams: use similar logic with larger elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Coordinate Compression

Map ratings to ranks 1 to n

BIT Operations

Use BIT to count elements efficiently

Update & Query

Update BIT and query prefix sums in O(log n)

Code -

solution.c — C

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

int numTeams(int* rating, int n) {
    int count = 0;
    
    for (int j = 1; j < n - 1; j++) {
        int leftSmaller = 0, leftLarger = 0;
        int rightSmaller = 0, rightLarger = 0;
        
        for (int i = 0; i < j; i++) {
            if (rating[i] < rating[j]) {
                leftSmaller++;
            } else if (rating[i] > rating[j]) {
                leftLarger++;
            }
        }
        
        for (int k = j + 1; k < n; k++) {
            if (rating[k] > rating[j]) {
                rightLarger++;
            } else if (rating[k] < rating[j]) {
                rightSmaller++;
            }
        }
        
        count += leftSmaller * rightLarger + leftLarger * rightSmaller;
    }
    
    return count;
}

int main() {
    int rating[] = {2, 5, 3, 4, 1};
    int n = sizeof(rating) / sizeof(rating[0]);
    printf("%d\n", numTeams(rating, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for coordinate compression + O(n log n) for BIT operations

⚡ Linearithmic

Space Complexity

O(n)

Space for BIT array and coordinate compression mapping

⚡ Linearithmic Space

52.8K Views

Medium-High Frequency

~18 min Avg. Time

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

Binary Indexed Tree (Advanced Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler