https://leetcode.com/problems/3sum/description/

class Solution {
    public List<List<Integer>> threeSum(int[] arr) {
        int n=arr.length;
        Set<List<Integer>> ans=new HashSet<>();
        //Brute force approach
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                for(int k=j+1;k<n;k++){
                   List<Integer> al=new ArrayList<>();
                    if(arr[i]+arr[j]+arr[k]==0){
                       al=Arrays.asList(arr[i],arr[j],arr[k]);
                       Collections.sort(al);
                       ans.add(al);
                    }
                }
            }
        }
        List<List<Integer>> fin=new ArrayList<>(ans);
        return fin;
    }
}
==========================================================
What is time complexity of this Program O(n^3)

Will go for Hashing Approach
=====================================================
Map 

0   1
1   1
2   1
-1  1
-4  1
====================================================


0-(-1+0)=1
0-(-1+1)=0
0-(-1+2)=
0-(-1-1)=2

arr= [-1,0,1,2,-1,-4]

target-(arr[i]+arr[j])
==================================================
class Solution {
    public List<List<Integer>> threeSum(int[] arr) {
        int n=arr.length;
        Set<List<Integer>> ans=new HashSet<>();
        //Brute force approach
        
        for(int i=0;i<n;i++){
            HashSet<Integer> hs=new HashSet<>();
            for(int j=i+1;j<n;j++){
                 int complement=-(arr[i]+arr[j]);
                 if(hs.contains(complement)){
                    List<Integer> ll=Arrays.asList(arr[i],arr[j],complement);
                    Collections.sort(ll);
                    ans.add(ll);
                 
                  }
                 hs.add(arr[j]);
            }
        }
        List<List<Integer>> fin=new ArrayList<>(ans);
        return fin;
    }
}
======================================================
2 Pointer approach :
=======================
Sort the Array 

you fix the arr[i]

j=i+1;
k=arr.length-1;
while(j<k)
{
  if(sum>0)
  {
     k--;
  }
  if(sum<0)
  {
    j++;
  }
}
=========================================
for(int i=0;i<n;i++){
            HashSet<Integer> hs=new HashSet<>();
            for(int j=i+1;j<n;j++){
                 int complement=-(arr[i]+arr[j]);
                 if(hs.contains(complement)){
                    List<Integer> ll=Arrays.asList(arr[i],arr[j],complement);
                    Collections.sort(ll);
                    ans.add(ll);
                 
                  }
                 hs.add(arr[j]);
            }
        }
=======================================
class Solution {
    public List<List<Integer>> threeSum(int[] arr) {
        int n=arr.length;
        Set<List<Integer>> ans=new HashSet<>();
        //Brute force approach
        
        Arrays.sort(arr);
        for(int i=0;i<n;i++){
            int j=i+1;
            int k=arr.length-1;

            while(j<k){
                if(arr[i]+arr[j]+arr[k]==0){
                    List ll=Arrays.asList(arr[i],arr[j],arr[k]);
                    Collections.sort(ll);
                    ans.add(ll);
                    j++;
                    k--;
                }
                else if(arr[i]+arr[j]+arr[k]>0){
                    k--;
                }else{
                    j++;
                }
            }
        }
        List<List<Integer>> fin=new ArrayList<>(ans);
        return fin;
    }
}