Largest Perimeter Triangle - Practice Coding Problems

Largest Perimeter Triangle - Problem

Given an integer array nums of positive integers, your task is to find three numbers that can form a valid triangle with the largest possible perimeter.

A valid triangle must satisfy the triangle inequality theorem: the sum of any two sides must be greater than the third side. For three sides a, b, and c, we need:

a + b > c
a + c > b
b + c > a

Return the largest perimeter of such a triangle. If no valid triangle can be formed, return 0.

Example: Given [2, 1, 2], we can form a triangle with sides 2, 1, 2 having perimeter = 5. Given [1, 2, 1], we can form the same triangle. But given [3, 2, 3, 4], the best triangle uses sides 2, 3, 4 with perimeter = 9.

Input & Output

example_1.py — Basic Triangle

$ Input: [2,1,2]

› Output: 5

💡 Note: The only possible triangle uses all three sides: 2, 1, 2. We verify: 2+1>2 ✓, 2+2>1 ✓, 1+2>2 ✓. Perimeter = 2+1+2 = 5.

example_2.py — Multiple Triangles

$ Input: [1,2,1,10]

› Output: 0

💡 Note: No valid triangle can be formed. The sides 1,2,1 don't satisfy triangle inequality (1+1 = 2, not > 2), and any combination with 10 fails because 10 is too large compared to other sides.

example_3.py — Optimal Selection

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

› Output: 10

💡 Note: Multiple triangles possible: (3,2,3) with perimeter 8, (2,3,4) with perimeter 9, and (3,3,4) with perimeter 10. The maximum is 10.

Constraints

3 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁶
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Arrange planks by length

Sort all available planks from longest to shortest

Try largest combinations first

Start with the three longest planks and check if they form a valid triangle

Apply triangle rule

For sorted planks a≥b≥c, only check if b+c>a (other inequalities are automatically satisfied)

First valid = optimal

The first valid triangle found has maximum perimeter

Key Takeaway

🎯 Key Insight: By sorting in descending order and checking consecutive triplets, we guarantee that the first valid triangle found has the maximum possible perimeter, eliminating the need to check all combinations.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal approach uses a greedy strategy with sorting. Sort the array in descending order, then check consecutive triplets for valid triangles. The first valid triangle found will have the maximum perimeter because we're examining the largest possible combinations first. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach with Sorting (Optimal)	O(n log n)	O(1)	Sort in descending order and greedily check largest combinations first
Brute Force (Check All Combinations)	O(n³)	O(1)	Check every possible combination of 3 elements

Greedy Approach with Sorting (Optimal) — Algorithm Steps

Sort the array in descending order (largest to smallest)
Iterate through the array with index i from 0 to n-3
For each i, check if nums[i], nums[i+1], nums[i+2] form a valid triangle
Only need to check if nums[i+1] + nums[i+2] > nums[i] (other inequalities are automatically satisfied)
Return the perimeter of the first valid triangle found, or 0 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort in descending order

Arrange elements from largest to smallest

Check consecutive triplets

Start with largest elements and work downward

First valid triangle is optimal

Return immediately when valid triangle is found

Code -

solution.c — C

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

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

int largestPerimeter(int* nums, int numsSize) {
    // Sort in descending order
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Check consecutive triplets for valid triangles
    for (int i = 0; i < numsSize - 2; i++) {
        int a = nums[i], b = nums[i + 1], c = nums[i + 2];
        
        // Since a >= b >= c, we only need to check if b + c > a
        if (b + c > a) {
            return a + b + c;
        }
    }
    
    return 0;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[,]");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", largestPerimeter(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting dominates the time complexity, iteration is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Sorting can be done in-place, only constant extra space needed

✓ Linear Space

28.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Approach with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler