Skip to content
Related Articles

Related Articles

Count Triplets such that one of the numbers can be written as sum of the other two

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 30 Jun, 2021

Given an array A[] of N integers. The task is to find the number of triples (i, j, k) , where i, j, k are indices and (1 <= i < j < k <= N), such that in the set { A_i , A_j , A_k } at least one of the numbers can be written as the sum of the other two.
Examples: 
 

Input : A[] = {1, 2, 3, 4, 5}
Output : 4
The valid triplets are:
(1, 2, 3), (1, 3, 4), (1, 4, 5), (2, 3, 5)

Input : A[] = {1, 1, 1, 2, 2}
Output : 6

 

This is a counting problem. Let’s say f(x) represents the frequency of number x in our array.
There exist four cases: 
 

  1. All three numbers are equal to 0. The number of ways = f(0)C3 (where pCq is the number of ways of choosing q numbers from p numbers).
  2. One number is equal to 0, the other two are equal to some x > 0: f(0) * f(x)C2.
  3. Two numbers are equal to some x>0, the third is 2*x: f(x)C2 * f(2 * x).
  4. The three numbers are x, y and x + y, 0 < x, y: f(x) * f(y) * f(x + y).

Below is the implementation of the above approach: 
 

C++




// C++ program to count Triplets such that at
// least one of the numbers can be written
// as sum of the other two
#include<bits/stdc++.h>
using namespace std;
 
    // Function to count the number of ways
    // to choose the triples
    int countWays(int arr[], int n)
    {
        // compute the max value in the array
        // and create frequency array of size
        // max_val + 1.
        // We can also use HashMap to store
        // frequencies. We have used an array
        // to keep remaining code simple.
        int max_val = 0;
        for (int i = 0; i < n; i++)
            max_val = max(max_val, arr[i]);
        int freq[max_val + 1]={0};
        for (int i = 0; i < n; i++)
            freq[arr[i]]++;
 
        int ans = 0; // stores the number of ways
 
        // Case 1: 0, 0, 0
        ans += freq[0] * (freq[0] - 1) * (freq[0] - 2) / 6;
 
        // Case 2: 0, x, x
        for (int i = 1; i <= max_val; i++)
            ans += freq[0] * freq[i] * (freq[i] - 1) / 2;
 
        // Case 3: x, x, 2*x
        for (int i = 1; 2 * i <= max_val; i++)
            ans += freq[i] * (freq[i] - 1) / 2 * freq[2 * i];
 
        // Case 4: x, y, x + y
        // iterate through all pairs (x, y)
        for (int i = 1; i <= max_val; i++) {
            for (int j = i + 1; i + j <= max_val; j++)
                ans += freq[i] * freq[j] * freq[i + j];
        }
 
        return ans;
    }
 
    // Driver code
    int main()
    {
        int arr[]={ 1, 2, 3, 4, 5 };
        int n = sizeof(arr)/sizeof(int);
        cout<<(countWays(arr, n));
        return 0;
    }
 
//contributed by Arnab Kundu

Java



// Java program to count Triplets such that at
// least one of the numbers can be written
// as a sum of the other two
 
class GFG {
 
    // Function to count the number of ways
    // to choose the triples
    static int countWays(int[] arr, int n)
    {
        // compute the max value in the array
        // and create frequency array of size
        // max_val + 1.
        // We can also use HashMap to store
        // frequencies. We have used an array
        // to keep remaining code simple.
        int max_val = 0;
        for (int i = 0; i < n; i++)
            max_val = Math.max(max_val, arr[i]);
        int[] freq = new int[max_val + 1];
        for (int i = 0; i < n; i++)
            freq[arr[i]]++;
 
        int ans = 0; // stores the number of ways
 
        // Case 1: 0, 0, 0
        ans += freq[0] * (freq[0] - 1) * (freq[0] - 2) / 6;
 
        // Case 2: 0, x, x
        for (int i = 1; i <= max_val; i++)
            ans += freq[0] * freq[i] * (freq[i] - 1) / 2;
 
        // Case 3: x, x, 2*x
        for (int i = 1; 2 * i <= max_val; i++)
            ans += freq[i] * (freq[i] - 1) / 2 * freq[2 * i];
 
        // Case 4: x, y, x + y
        // iterate through all pairs (x, y)
        for (int i = 1; i <= max_val; i++) {
            for (int j = i + 1; i + j <= max_val; j++)
                ans += freq[i] * freq[j] * freq[i + j];
        }
 
        return ans;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = new int[] { 1, 2, 3, 4, 5 };
        int n = arr.length;
        System.out.println(countWays(arr, n));
    }
}
Python3



# Python3 program to count Triplets such
# that at least one of the numbers can be
# written as sum of the other two
import math as mt
 
# Function to count the number of ways
# to choose the triples
def countWays(arr, n):
 
    # compute the max value in the array
    # and create frequency array of size
    # max_val + 1.
    # We can also use HashMap to store
    # frequencies. We have used an array
    # to keep remaining code simple.
    max_val = 0
    for i in range(n):
        max_val = max(max_val, arr[i])
 
    freq = [0 for i in range(max_val + 1)]
 
    for i in range(n):
        freq[arr[i]] += 1
 
    ans = 0 # stores the number of ways
 
    # Case 1: 0, 0, 0
    ans += (freq[0] * (freq[0] - 1) *
           (freq[0] - 2) // 6)
 
    # Case 2: 0, x, x
    for i in range(1, max_val + 1):
        ans += (freq[0] * freq[i] *
               (freq[i] - 1) // 2)
 
    # Case 3: x, x, 2*x
    for i in range(1, (max_val + 1) // 2):
        ans += (freq[i] *
               (freq[i] - 1) // 2 * freq[2 * i])
 
    # Case 4: x, y, x + y
    # iterate through all pairs (x, y)
    for i in range(1, max_val + 1):
        for j in range(i + 1, max_val - i + 1):
            ans += freq[i] * freq[j] * freq[i + j]
 
    return ans
 
# Driver code
arr = [ 1, 2, 3, 4, 5]
n = len(arr)
print(countWays(arr, n))
 
# This code is contributed by
# mohit kumar 29
C#



// C# program to count Triplets
// such that at least one of the
// numbers can be written as sum
// of the other two
using System;
 
class GFG
{
 
// Function to count the number
// of ways to choose the triples
static int countWays(int[] arr, int n)
{
    // compute the max value in the array
    // and create frequency array of size
    // max_val + 1.
    // We can also use HashMap to store
    // frequencies. We have used an array
    // to keep remaining code simple.
    int max_val = 0;
    for (int i = 0; i < n; i++)
        max_val = Math.Max(max_val, arr[i]);
         
    int[] freq = new int[max_val + 1];
    for (int i = 0; i < n; i++)
        freq[arr[i]]++;
 
    int ans = 0; // stores the number of ways
 
    // Case 1: 0, 0, 0
    ans += freq[0] * (freq[0] - 1) *
                     (freq[0] - 2) / 6;
 
    // Case 2: 0, x, x
    for (int i = 1; i <= max_val; i++)
        ans += freq[0] * freq[i] *
                        (freq[i] - 1) / 2;
 
    // Case 3: x, x, 2*x
    for (int i = 1;
             2 * i <= max_val; i++)
        ans += freq[i] * (freq[i] - 1) /
                      2 * freq[2 * i];
 
    // Case 4: x, y, x + y
    // iterate through all pairs (x, y)
    for (int i = 1; i <= max_val; i++)
    {
        for (int j = i + 1;
                 i + j <= max_val; j++)
            ans += freq[i] * freq[j] *
                             freq[i + j];
    }
 
    return ans;
}
 
// Driver code
public static void Main()
{
    int[] arr = { 1, 2, 3, 4, 5 };
    int n = arr.Length;
    Console.WriteLine(countWays(arr, n));
}
}
 
// This code is contributed by shs..
PHP



<?php
// PHP program to count Triplets such that at
// least one of the numbers can be written
// as sum of the other two
 
// Function to count the number of ways
// to choose the triples
function countWays($arr, $n)
{
    // compute the max value in the array
    // and create frequency array of size
    // max_val + 1.
    // We can also use HashMap to store
    // frequencies. We have used an array
    // to keep remaining code simple.
    $max_val = 0;
    for ($i = 0; $i < $n; $i++)
        $max_val = max($max_val, $arr[$i]);
    $freq = array_fill(0, $max_val + 1, 0);
    for ($i = 0; $i < $n; $i++)
        $freq[$arr[$i]]++;
 
    $ans = 0; // stores the number of ways
 
    // Case 1: 0, 0, 0
    $ans += (int)($freq[0] * ($freq[0] - 1) *
                             ($freq[0] - 2) / 6);
 
    // Case 2: 0, x, x
    for ($i = 1; $i <= $max_val; $i++)
        $ans += (int)($freq[0] * $freq[$i] *
                     ($freq[$i] - 1) / 2);
 
    // Case 3: x, x, 2*x
    for ($i = 1; 2 * $i <= $max_val; $i++)
        $ans += (int)($freq[$i] * ($freq[$i] - 1) / 2 *
                                   $freq[2 * $i]);
 
    // Case 4: x, y, x + y
    // iterate through all pairs (x, y)
    for ($i = 1; $i <= $max_val; $i++)
    {
        for ($j = $i + 1; $i + $j <= $max_val; $j++)
            $ans += $freq[$i] * $freq[$j] *
                                $freq[$i + $j];
    }
 
    return $ans;
}
 
// Driver code
$arr = array( 1, 2, 3, 4, 5 );
$n = count($arr);
echo countWays($arr, $n);
 
// This code is contributed by mits
?>
Javascript



<script>
 
// JavaScript program to count Triplets such that at
// least one of the numbers can be written
// as a sum of the other two   
     
    // Function to count the number of ways
    // to choose the triples
    function countWays(arr,n)
    {
        // compute the max value in the array
        // and create frequency array of size
        // max_val + 1.
        // We can also use HashMap to store
        // frequencies. We have used an array
        // to keep remaining code simple.
        let max_val = 0;
        for (let i = 0; i < n; i++)
            max_val = Math.max(max_val, arr[i]);
        let freq = new Array(max_val + 1);
        for(let i=0;i<freq.length;i++)
        {
            freq[i]=0;
        }
        for (let i = 0; i < n; i++)
            freq[arr[i]]++;
   
        let ans = 0; // stores the number of ways
   
        // Case 1: 0, 0, 0
        ans += freq[0] * (freq[0] - 1) * (freq[0] - 2) / 6;
   
        // Case 2: 0, x, x
        for (let i = 1; i <= max_val; i++)
            ans += freq[0] * freq[i] * (freq[i] - 1) / 2;
   
        // Case 3: x, x, 2*x
        for (let i = 1; 2 * i <= max_val; i++)
            ans += freq[i] * (freq[i] - 1) / 2 * freq[2 * i];
   
        // Case 4: x, y, x + y
        // iterate through all pairs (x, y)
        for (let i = 1; i <= max_val; i++) {
            for (let j = i + 1; i + j <= max_val; j++)
                ans += freq[i] * freq[j] * freq[i + j];
        }
   
        return ans;
    }
     
    // Driver code
    let arr=[1, 2, 3, 4, 5];
    let n = arr.length;
    document.write(countWays(arr, n));
 
     
 
// This code is contributed by patel2127
 
</script>
Output: 
4
 

My Personal Notes
arrow_drop_up
Next

Largest Sum Contiguous Subarray
Recommended Articles
Page :
Check if a string can be split into 3 substrings such that one of them is a substring of the other two
05, Apr 21
Check if a string can be split into two substrings such that one substring is a substring of the other
23, Dec 20
Count of triplets from the given Array such that sum of any two elements is the third element
27, Feb 20
Count triplets such that sum of any two number is equal to third | Set 2
30, Mar 20
Count of triplets having sum of product of any two numbers with the third number equal to N
26, Jul 21
Count of triplets of numbers 1 to N such that middle element is always largest
31, May 20
Count number of triplets (a, b, c) from first N natural numbers such that a * b + c = N
29, Dec 20
Partition a set into two subsets such that difference between max of one and min of other is minimized
16, Jun 20
Count pairs in an array such that frequency of one is at least value of other
15, Nov 18
Minimize swap of elements such that one Array has greater sum than other
21, Mar 22
Count ways to obtain triplets with positive product consisting of at most one negative element
18, Jan 21
Count prime triplets upto N having sum of first two elements equal to the third number
31, Jan 21
Count of triplets that can be removed without changing Mean of given Array
23, Dec 21
Check if characters of one string can be swapped to form other
31, Mar 18
Count triplets in an array such that i<j<k and a[j] - a[i] = a[k] - a[j] = D
19, Apr 20
Count of triplets in an Array (i, j, k) such that i < j < k and a[k] < a[i] < a[j]
29, Jun 20
Count of triplets in an Array such that A[i] * A[j] = A[k] and i < j < k
16, Jul 20
Count triplets (a, b, c) such that a + b, b + c and a + c are all divisible by K | Set 2
05, Apr 21
Count triplets (i, j, k) in an array of distinct elements such that a[i] < a[j] > a[k] and i < j < k
12, Apr 21
Count triplets from an array such that a[j] - a[i] ≤ a[k] - a[j] ≤ 2 * (a[j] - a[i])
17, Jun 21
Count of index triplets (i, j, k) in given Array such that i<j<k and a[j]<a[k]<a[i]
24, Nov 21
Count of triplets (a, b, c) in the Array such that a divides b and b divides c
13, May 20
Count the triplets such that A[i] < B[j] < C[k]
22, May 19
Rearrange array to maximize count of triplets (i, j, k) such that arr[i] > arr[j] < arr[k] and i < j < k
30, Sep 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
AmanKumarSingh
@AmanKumarSingh
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!