# Count number of triangles possible for the given sides range

• Last Updated : 15 Jun, 2022

Given four integers A, B, C, and D, the task is to find the number of distinct sets (X, Y, and Z) where X, Y and Z denotes the length of sides forming a valid triangle. A ≤ X ≤ B, B ≤ Y ≤ C, and C ≤ Z ≤ D.
Examples:

Input: A = 2, B = 3, C = 4, D = 5
Output:
Explanation:
Possible Length of Side of Triangles are –
{(2, 3, 4), (2, 4, 4), (2, 4, 5), (3, 3, 4), (3, 3, 5), (3, 4, 4) and (3, 4, 5)}
Input: A = 1, B = 1, C = 2, D = 2
Output:
Explanation:
Only possible length of sides we can choose triangle is (1, 2, 2)

Naive Approach: The key observation in the problem is that, If X, Y and Z are the valid sides of a triangle and X ≤ Y ≤ Z, then sufficient conditions for these sides to form a valid triangle will be X+Y > Z.
Finally, the count of the possible Z value for the given X and Y can be computed as –

1. If X+Y is greater than D, for this case Z can be chosen from [C, D], Total possible values of Z will be (D-C+1).
2. If X+Y is less than D and greater than C, then Z can be chosen from [C, X+Y-1].
3. If X+Y is less than or equal to C, then we cannot choose Z as these sides will not form a valid triangle.

Time Complexity: Efficient Approach: The idea is to iterate for all the possible values of A and then compute the number of possible Y and Z values possible for the given X using mathematical computations.
For a given X, the value of X+Y will be in the range of . If we compute the number of possible value greater than D, then the total number of possible values of Y and Z will be –

// Number of possible values of Y and Z
// If num_greater is the number of possible
// Y values which is greater than D Similarly, Let R and L is the upper bound and Lower Bound of the values of X+Y in the range of C and D. Then, total combinations for Y and Z will be – Below is the implementation of the above approach:

## C++

 // C++ implementation to count the// number of possible triangles// for the given sides ranges #include using namespace std; // Function to count the number of// possible triangles for the given// sides rangesint count_triangles(int a, int b,                    int c, int d){     int ans = 0;     // Iterate for every possible of x    for (int x = a; x <= b; ++x) {         // Range of y is [b, c]        // From this range First        // we will find the number        // of x + y greater than d        int num_greater_than_d = max(d, c + x) - max(d, b + x - 1);         // For x+y greater than d        // we can choose all z from [c, d]        // Total permutation will be        ans += num_greater_than_d * (d - c + 1);         // Now we will find the number        // of x+y in between the [c, d]        int r = min(max(c, c + x), d) - c;        int l = min(max(c, b + x - 1), d) - c;         // [l, r] will be the range        // from total [c, d] x+y belongs        // For any r such that r = x+y        // We can choose z, in the range        // [c, d] only less than r,        // Thus total permutation be        int x1 = (r * (r + 1)) / 2;        int x2 = (l * (l + 1)) / 2;         ans += x1 - x2;    }     return ans;} // Driver Codeint main(){    int a = 2, b = 3, c = 4, d = 5;     cout << count_triangles(a, b, c, d)         << endl;     return 0;}

## Java

 // Java implementation to count the// number of possible triangles// for the given sides rangesimport java.util.Scanner;import java.util.Arrays; class GFG{ // Function to count the number of// possible triangles for the given// sides rangespublic static int count_triangles(int a, int b,                                  int c, int d){    int ans = 0;     // Iterate for every possible of x    for(int x = a; x <= b; ++x)    {         // Range of y is [b, c]        // From this range First        // we will find the number        // of x + y greater than d        int num_greater_than_d = Math.max(d, c + x) -                                 Math.max(d, b + x - 1);         // For x+y greater than d        // we can choose all z from [c, d]        // Total permutation will be        ans += num_greater_than_d * (d - c + 1);         // Now we will find the number        // of x+y in between the [c, d]        int r = Math.min(Math.max(c, c + x), d) - c;        int l = Math.min(Math.max(c, b + x - 1), d) - c;         // [l, r] will be the range        // from total [c, d] x+y belongs        // For any r such that r = x+y        // We can choose z, in the range        // [c, d] only less than r,        // Thus total permutation be        int x1 = (r * (r + 1)) / 2;        int x2 = (l * (l + 1)) / 2;         ans += x1 - x2;    }    return ans;} // Driver Codepublic static void main(String args[]){    int a = 2, b = 3, c = 4, d = 5;     System.out.println(count_triangles(a, b, c, d));}} // This code is contributed by SoumikMondal

## Python3

 # Python3 implementation to count # the number of possible triangles# for the given sides ranges # Function to count the number of# possible triangles for the given# sides rangesdef count_triangles(a, b, c, d):     ans = 0     # Iterate for every possible of x    for x in range(a, b + 1):         # Range of y is [b, c]        # From this range First        # we will find the number        # of x + y greater than d        num_greater_than_d = (max(d, c + x) -                              max(d, b + x - 1))         # For x+y greater than d we        # can choose all z from [c, d]        # Total permutation will be        ans = (ans + num_greater_than_d *                             (d - c + 1))         # Now we will find the number        # of x+y in between the [c, d]        r = min(max(c, c + x), d) - c;        l = min(max(c, b + x - 1), d) - c;         # [l, r] will be the range        # from total [c, d] x+y belongs        # For any r such that r = x+y        # We can choose z, in the range        # [c, d] only less than r,        # Thus total permutation be        x1 = int((r * (r + 1)) / 2)        x2 = int((l * (l + 1)) / 2)         ans = ans + (x1 - x2)     return ans # Driver Codea = 2b = 3c = 4d = 5 print (count_triangles(a, b, c, d), end = '\n') # This code is contributed by PratikBasu

## C#

 // C# implementation to count the// number of possible triangles// for the given sides rangesusing System; class GFG{ // Function to count the number of// possible triangles for the given// sides rangespublic static int count_triangles(int a, int b,                                  int c, int d){    int ans = 0;     // Iterate for every possible of x    for(int x = a; x <= b; ++x)    {         // Range of y is [b, c]        // From this range First        // we will find the number        // of x + y greater than d        int num_greater_than_d = Math.Max(d, c + x) -                                 Math.Max(d, b + x - 1);         // For x+y greater than d        // we can choose all z from [c, d]        // Total permutation will be        ans += num_greater_than_d * (d - c + 1);         // Now we will find the number        // of x+y in between the [c, d]        int r = Math.Min(Math.Max(c, c + x), d) - c;        int l = Math.Min(Math.Max(c, b + x - 1), d) - c;         // [l, r] will be the range        // from total [c, d] x+y belongs        // For any r such that r = x+y        // We can choose z, in the range        // [c, d] only less than r,        // Thus total permutation be        int x1 = (r * (r + 1)) / 2;        int x2 = (l * (l + 1)) / 2;         ans += x1 - x2;    }    return ans;} // Driver Codepublic static void Main(String []args){    int a = 2, b = 3, c = 4, d = 5;     Console.WriteLine(count_triangles(a, b, c, d));}} // This code is contributed by gauravrajput1

## Javascript

 

Output:

7

Time Complexity : O(b-a)

Space Complexity : O(1) ,as we are not using any extra space

My Personal Notes arrow_drop_up