Valid Triangle Number - Practice Coding Problems

Valid Triangle Number - Problem

Imagine you have a collection of sticks with different lengths, and you want to know how many ways you can pick three sticks to form a valid triangle!

Given an integer array nums representing the lengths of sticks, return the number of triplets that can form valid triangles. Remember the triangle inequality theorem: for any triangle with sides a, b, and c, the sum of any two sides must be greater than the third side.

Examples:

Sides [2, 2, 3] → Valid triangle (2+2 > 3, 2+3 > 2, 2+3 > 2) ✅
Sides [1, 2, 3] → Invalid triangle (1+2 = 3, not greater than 3) ❌

Your goal is to count all possible combinations of three elements that satisfy the triangle inequality.

Input & Output

example_1.py — Basic Triangle Formation

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

› Output: 3

💡 Note: Valid triangles are: [2,2,3], [2,3,4], [2,2,4]. Each satisfies the triangle inequality: sum of any two sides > third side.

example_2.py — Single Valid Triangle

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

› Output: 4

💡 Note: After sorting [2,3,4,4], valid triangles are: [2,3,4], [2,4,4], [3,4,4], [2,4,4]. All combinations where sum of smaller sides exceeds the largest side.

example_3.py — No Valid Triangles

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

› Output: 0

💡 Note: The only possible triangle [1,1,2] is invalid because 1+1 = 2, which is not greater than 2. Triangle inequality requires strict inequality.

Visualization

Tap to expand

Understanding the Visualization

Sort the Sticks

Arrange all sticks from shortest to longest for systematic checking

Pick the Longest

Choose the longest stick as one side of the triangle

Two-Pointer Search

Use two pointers to find all valid pairs for the remaining two sides

Count Efficiently

When a valid combination is found, count all possibilities at once

Key Takeaway

🎯 Key Insight: Sorting enables efficient triangle counting - when two smaller sides sum exceeds the largest, all intermediate combinations work too!

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting + O(n²) for nested loops * O(log n) for binary search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, sorting can be done in-place

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000
Triangle inequality: For sides a, b, c, need a+b>c, b+c>a, and a+c>b

Asked in

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

The optimal solution uses the two-pointers technique after sorting the array. Key insight: in a sorted array, if the sum of two smaller sides exceeds the largest side, then all elements between the left pointer and right pointer can form valid triangles. This reduces the time complexity from O(n³) brute force to O(n²) while maintaining O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n² log n)	O(1)	Sort array, then use binary search to find valid third sides efficiently
Two Pointers (Optimal)	O(n²)	O(1)	Sort array and use two pointers to efficiently count valid triangles
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible triplet and verify triangle inequality

Sorting + Binary Search — Algorithm Steps

Sort the array in ascending order
Use two nested loops to fix the first two sides (smaller sides)
For each pair nums[i] and nums[j], calculate their sum
Use binary search to find the rightmost position where nums[k] < nums[i] + nums[j]
Add the count of valid third sides to the result
Continue until all pairs are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort to enable binary search

Fix Two Sides

Choose first two elements as sides a and b

Binary Search

Find largest c where a + b > c

Count Valid

Count all valid third sides found

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int binarySearchRight(int* arr, int left, int right, int target) {
    // Find rightmost position where arr[pos] < target
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return right;
}

int triangleNumber(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    int count = 0;
    
    // Fix first two sides
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            // Find largest possible third side
            int sumTwo = nums[i] + nums[j];
            // Find rightmost position where nums[k] < sumTwo
            int rightPos = binarySearchRight(nums, j + 1, numsSize - 1, sumTwo);
            if (rightPos >= j + 1) {
                count += rightPos - j;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char ch;
    
    // Simple input parsing
    while (scanf("%d%c", &nums[size], &ch) >= 1) {
        size++;
        if (ch == ']') break;
    }
    
    printf("%d\n", triangleNumber(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting + O(n²) for nested loops * O(log n) for binary search

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, sorting can be done in-place

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000
Triangle inequality: For sides a, b, c, need a+b>c, b+c>a, and a+c>b

89.3K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler