Sum of Two Elements Equals the Third.

import java.util.* ;
import java.io.*; 
public class Solution 
{
	public static  ArrayList<Integer> findTriplets(int[] arr, int n) 
    {
	    //Write your code here.
		ArrayList<Integer> list = new ArrayList<>();
		Arrays.sort(arr);
		for(int i = n-1 ; i >= 0 ; i--){
			int j = 0;
			int k = i-1;
			while(j < k){
				int sum = arr[j]+arr[k];
				if(sum == arr[i]){
					list.add(arr[i]);
					list.add(arr[j]);
					list.add(arr[k]);
					return list;
				}else if(sum > arr[i])k--;
				else j++;
			}
		}
		return list;
	}
}

#include <bits/stdc++.h> 

vector<int> findTriplets(vector<int> &arr, int n) 

{     //Write your code here.

     vector<int> result;

     sort(arr.begin(),arr.end());

     for(int i=n-1;i>=0;i--){

         int j=0;

         int k=i-1;

         while(j<k){

             if(arr[i]==arr[j]+arr[k]){

                 result.push_back(arr[i]);

                 result.push_back(arr[j]);

                 result.push_back(arr[k]);

                 return result;

             }else if(arr[i]>arr[j]+arr[k]){

                 j=j+1;

             }else{

                 k=k-1;

             }

         }

     }

     return result;

}

import java.util.* ;

import java.io.*; 

public class Solution 

{

    public static  ArrayList<Integer> findTriplets(int[] arr, int n) 

    {

        //Write your code here.

        Arrays.sort(arr);

        ArrayList<Integer> res = new ArrayList<>();

        for (int i = arr.length - 1; i >= 0; i--) {

            int left = 0;

            int right = i - 1;

            while (left < right) {

                int sm = arr[left] + arr[right];

                if (sm == arr[i]) {

                    res.add(arr[left]);

                    res.add(arr[right]);

                    res.add(arr[i]);

                    return res;

                } else if (sm < arr[i]) {

                    left++;

                } else {

                    right--;

                }

            }

        }

        return new ArrayList<>();

    }

}

public class Solution 

{

    public static  ArrayList<Integer> findTriplets(int[] arr, int n) 

    {

        int sum = 0;

        ArrayList<Integer> ans = new ArrayList<>();

        ArrayList<Integer> soln = new ArrayList<>();

        for(int i = 0 ; i < arr.length ; i++){

            ans.add(i,arr[i]);

        }

        for(int i = 0 ; i < ans.size()-1 ; i++){

            if(ans.get(i) <= ans.get(i+1)){

                sum = ans.get(i) + ans.get(i+1);

            }

            else{

                sum = ans.get(i) - ans.get(i+1);

            }

            if(ans.contains(sum)){

                soln.add(ans.get(i));

                soln.add(ans.get(i+1));

                soln.add(sum);

                break;

            }

        }

        return soln;

    }

}

#include <bits/stdc++.h> 

vector<int> findTriplets(vector<int> &arr, int n) 

{

    //Write your code here.

    vector<int> ans;

    sort(arr.begin(), arr.end());

    for(int i=n-1; i>=0; i--) {

        int j = 0;

        int k = i-1;

        while(j<k) {

            if(arr[i] == arr[j]+arr[k]) {

                ans.push_back(arr[i]);

                ans.push_back(arr[j]);

                ans.push_back(arr[k]);

                return ans;

            }

            else if(arr[i] > arr[j]+arr[k]) {

                j++;

            }

            else {

                k--;

            }

        }

    }

    return ans;

}

1. `findTriplets` function takes an array `arr` and its size `n` as input.

2. It sorts the array using `Arrays.sort`, which takes O(n*log(n)) time.

3. It iterates through the sorted array:   - Calls `getTriplet` function with the current element and its index.   - `getTriplet` searches for a pair that sums to the negative of the current element.   - If found, it returns the triplet as an ArrayList.

4. Inside `getTriplet`:   - It iterates through the array from the beginning to the current index.   - Calls `check` function to search for a pair that sums to the target value.   - If found, returns the triplet; otherwise, continues the search.

5. The `check` function searches for a value in the array and returns its index or -1 if not found.

6. Overall time complexity:   - Sorting: O(n*log(n))   - Iterating through the array: O(n)   - Search within `getTriplet` and `check`: O(n) each, but nested.  

7. The dominant factor is sorting, so the overall time complexity is O(n*log(n)).

import java.util.* ;
import java.io.*; 
public class Solution 
{

     public static int check(int arr[], int sum, int index ){
   int i = 0;
 //   System.out.println("finding pair for "+ sum);
   while(i < index){
    if(arr[i] > sum){
   //   System.out.println("Not found");
     return -1;
    }
    if(arr[i] == sum){
     return i;
    }
    i++;
   }
   return -1;
  }
public static ArrayList<Integer> getTriplet(int arr[], int index, int sum){

 int i = 0;
 // System.out.println("finding MAIN pair for "+ sum);
       ArrayList<Integer> ans = new ArrayList<Integer>();
 int otherIndex = -1;
 while(i < index){
                
    if(arr[i] > sum){
    //  System.out.println("not found");
     ans.clear();
     return ans;
    }
  otherIndex = check(arr,sum-arr[i], i);
  if(otherIndex != -1){
   // System.out.println("Found");
   ans.add(arr[i]);
   ans.add(arr[otherIndex]);
   return ans;
  }
  else{
   // System.out.println("not found for "+ sum);
  }
  i++;
 }
 
 ans.clear();
 return ans;
}
public static  ArrayList<Integer> findTriplets(int[] arr, int n) 
   {
    //Write your code here.
 ArrayList<Integer> triplet = new ArrayList<>();
 Arrays.sort(arr);
       int i= 0;
     try{
   while(i < arr.length){
  triplet = getTriplet(arr,i, arr[i]);
  if(triplet.size() == 2 ){
   triplet.add(arr[i]);
   return triplet;
  }
  i++;
 }
  }
  catch(Exception e){
   System.out.println(e);
  }
       
 return triplet;
}
}

import java.util.* ;
import java.io.*; 
public class Solution 
{
	public static ArrayList<Integer> findTriplets(int[] arr, int n) 
    {
	    //Write your code here.
        ArrayList<Integer> a=new ArrayList<>();
    Arrays.sort(arr);
    int i=0;
    while(i<n){
      int l=0,r=n-1;
      while(l<r){
      if(arr[i]==arr[l]+arr[r]){
        a.add(arr[i]);
        a.add(arr[l]);
        a.add(arr[r]);
       return a;
      
      }else if(arr[i]<arr[l]+arr[r]) r--;
      else l++;
     }
       i++;
      }
    return a;
	}
}

from os import *

from sys import *

from collections import *

from math import *

def findTriplet(arr,n):

    arr.sort()

    for i in range(len(arr)-1,-1,-1):

        left = 0

        right = i-1

        while left<right:

            sum = arr[left] + arr[right]

            if sum == arr[i]:

                return [arr[left],arr[right],arr[i]]

            elif sum < arr[i]:  

                left+=1

            else:

                right-=1

    return []

#include <bits/stdc++.h> 
vector<int> findTriplets(vector<int> &arr, int n) 
{
    //Write your code here.
    sort(arr.begin(),arr.end());
     int i= 0;
     int j = 1;

    while(i<j && j<n){
        
        int find = arr[i]+arr[j];

        for(int k = j+1 ; k<n ;k++){
            if(arr[k] == find){
                return {arr[i],arr[j],arr[k]};
            }
            else if(arr[k] > find){
               break;
            }
            
           
            }
            if(j==n-1){
                i++;
                j = i+1;
            } else {
                j++;
            }
        }

    

    return {0};
}
*/



#include <bits/stdc++.h>
vector<int> findTriplets(vector<int> &arr, int n) {

 sort(arr.begin(),arr.end());

 for(int k = n-1 ;k>1 ;k--){
     int i = 0;
     int j = k-1;

     while(i<j){
         int sum = arr[i]+arr[j];

         if(sum == arr[k]){
             return {arr[i],arr[j],arr[k]};
         }
         if(sum > arr[k]){
             j--;
         }
         else{
             i++;
         }
     }

 }

return {0};


// Hashing
map<int,int>mp;
    for(int i= 0; i<n; i++) mp[arr[i]]++;

    for(int i=0; i<n; i++){
        bool f = false;
        for(int j = i+1; j<n; j++){
            if(mp[arr[i]+arr[j]] != 0){
                ans.push_back(arr[i]);
                ans.push_back(arr[j]);
                ans.push_back(arr[i]+arr[j]);
                f= true;
                break;
            }
        }

        if(f) break;
    }

    return ans;
}



}

public static ArrayList<Integer> findTriplets(int[] arr, int n) {
        ArrayList<Integer> currArr = new ArrayList<>();
        for (int index1 = 0; index1 < n; index1++) {
            for (int index2 = index1 + 1; index2 < n; index2++) {
                for (int index3 = index2 + 1; index3 < n; index3++) {
                    if ((arr[index1] + arr[index2] == arr[index3]) || (arr[index2] + arr[index3] == arr[index1]) || (arr[index3] + arr[index1] == arr[index2])) {
                        currArr.add(arr[index1]);
                        currArr.add(arr[index2]);
                        currArr.add(arr[index3]);

                        return currArr;
                    }
                }
            }
        }
        return currArr;
    }