Valid Triangle Number

Valid Triangle Number - Problem

Given an integer array nums, return the number of triplets chosen from the array that can make triangles if we take them as side lengths of a triangle.

Triangle Validity Rule: For three sides a, b, and c to form a valid triangle, they must satisfy: a + b > c, a + c > b, and b + c > a.

Note: The triangle inequality states that the sum of any two sides must be greater than the third side for all three combinations.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,2,3,4]

› Output: 3

💡 Note: Valid triangles are: (2,2,3) since 2+2=4>3, 2+3=5>2, 2+3=5>2; (2,3,4) since 2+3=5>4, 2+4=6>3, 3+4=7>2; (2,3,4) with the other 2. Total: 3 triangles.

Example 2 — No Valid Triangles

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

› Output: 0

💡 Note: The only triplet is (1,2,3). Check: 1+2=3, which is not greater than 3, so this cannot form a triangle.

Example 3 — All Valid

$ Input: nums = [4,2,3,4]

› Output: 4

💡 Note: After sorting [2,3,4,4]: (2,3,4), (2,4,4), (3,4,4), (2,4,4) - all satisfy triangle inequality. Total: 4 triangles.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18 G Google 15 Apple 12

The key insight is that after sorting the array, we only need to check if the sum of two smaller sides is greater than the largest side. The optimal approach uses sorting with two pointers for O(n²) time complexity. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force - Check All Triplets

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

Generate all possible triplets from the array and for each triplet, verify if they satisfy the triangle inequality condition. A triangle is valid if the sum of any two sides is greater than the third side for all three combinations.

Sort + Binary Search

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

Sort the array first, then for each pair of elements (i,j), use binary search to find the largest element k such that nums[i] + nums[j] > nums[k]. All elements from j+1 to k can form valid triangles with nums[i] and nums[j].

Sort + Two Pointers

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

After sorting, we can optimize the triangle check. For a sorted array, if we fix the largest side, we only need to check if the sum of the two smaller sides is greater than it. This allows us to use two pointers to count multiple valid triangles efficiently.

Brute Force - Check All Triplets — Algorithm Steps

Step 1: Use three nested loops to generate all possible triplets
Step 2: For each triplet (a,b,c), check if a+b>c, a+c>b, and b+c>a
Step 3: Count the valid triangles

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Triplets

Use three nested loops to create all combinations

Check Triangle Rule

Verify a+b>c, a+c>b, b+c>a for each triplet

Count Valid

Increment counter for each valid triangle

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                int a = nums[i], b = nums[j], c = nums[k];
                // Check triangle inequality for all three combinations
                if (a + b > c && a + c > b && b + c > a) {
                    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];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array input
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterate through all possible triplets

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

82.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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 Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler