Count Number of Teams

Count Number of Teams - Problem

There are n soldiers standing in a line. Each soldier is assigned a unique rating value.

You have to form a team of 3 soldiers amongst them under the following rules:

Choose 3 soldiers with index (i, j, k) with rating (rating[i], rating[j], rating[k]).
A team is valid if: (rating[i] < rating[j] < rating[k]) or (rating[i] > rating[j] > rating[k]) where (0 <= i < j < k < n).

Return the number of teams you can form given the conditions. (soldiers can be part of multiple teams).

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We can form teams: [2,3,4] (ascending), [5,4,1] (descending), [5,3,1] (descending). Total = 3 teams.

Example 2 — Minimum Size

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

› Output: 0

💡 Note: No valid teams can be formed. [2,1,3] is neither ascending (2>1) nor descending (1<3).

Example 3 — All Ascending

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

› Output: 10

💡 Note: All possible triplets form ascending teams: (1,2,3), (1,2,4), (1,2,5), (1,3,4), (1,3,5), (1,4,5), (2,3,4), (2,3,5), (2,4,5), (3,4,5).

Constraints

3 ≤ rating.length ≤ 1000
1 ≤ rating[i] ≤ 10⁵
All the integers in rating are unique.

Visualization

Tap to expand

Asked in

A Amazon 45 M Microsoft 32 G Google 28 F Facebook 21

The key insight is to fix the middle soldier and count valid combinations on both sides. For each middle element, count smaller/larger elements to the left and right, then multiply appropriate counts. Best approach uses Binary Indexed Tree for O(n log n) time complexity with O(n) space.

Common Approaches

✓ Hash Map

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

Binary Indexed Tree (Fenwick Tree)

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

Use coordinate compression and Binary Indexed Tree to count elements smaller/larger than current element in O(log n) time, reducing overall complexity to O(n log n).

Brute Force Triple Loop

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

Use three nested loops to examine every combination of three soldiers. For each triplet, check if ratings form ascending or descending order.

Dynamic Programming - Fix Middle Element

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

Fix each soldier as the middle element of a team. Count how many soldiers to the left are smaller/larger and how many to the right are larger/smaller. Multiply these counts to get valid teams.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int rating[1000];

int solution(int* ratings, int n) {
    int count = 0;
    
    // Check all possible triplets (i, j, k) where i < j < k
    for (int i = 0; i < n - 2; i++) {
        for (int j = i + 1; j < n - 1; j++) {
            for (int k = j + 1; k < n; k++) {
                // Check ascending: rating[i] < rating[j] < rating[k]
                if (ratings[i] < ratings[j] && ratings[j] < ratings[k]) {
                    count++;
                }
                // Check descending: rating[i] > rating[j] > rating[k]
                else if (ratings[i] > ratings[j] && ratings[j] > ratings[k]) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int n = 0;
    int i = 0;
    int len = strlen(line);
    
    // Skip opening bracket
    if (line[i] == '[') i++;
    
    while (i < len && line[i] != ']') {
        // Skip whitespace and commas
        while (i < len && (line[i] == ' ' || line[i] == ',')) i++;
        
        if (i < len && line[i] != ']') {
            // Parse number
            int num = 0;
            int negative = 0;
            if (line[i] == '-') {
                negative = 1;
                i++;
            }
            
            while (i < len && line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            
            if (negative) num = -num;
            rating[n++] = num;
        }
    }
    
    int result = solution(rating, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

38.0K Views

Medium Frequency

~25 min Avg. Time

892 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