function triplet(n, arr) {
  // First, we will declare a set data structure as we want unique triplets.
    let st = new Set();
    let ans = []

// check all possible triplets:
// Then we will use the first loop(say i) that will run from 0 to n-1.
    for (let i = 0; i < n; i++) {
// Inside it, there will be the second loop(say j)
// that will run from i+1 to n-1.
        for (let j = i + 1; j < n; j++) {
// Then there will be the third loop(say k) 
// that runs from j+1 to n-1.
            for (let k = j + 1; k < n; k++) {
// Now, inside these 3 nested loops, we will check the sum
// i.e. arr[i]+arr[j]+arr[k], and if it is equal to the target 
                if (arr[i] + arr[j] + arr[k] === 0) {
// i.e. 0 we will sort this triplet and insert it in the set data structure.
                    let temp = [arr[i], arr[j], arr[k]];
                    temp.sort((a, b) => a - b);
                    ans.push(temp);
                }
            }
        }
    }
// Finally, we will return the list of triplets stored
// in the set data structure.
//store the set in the answer:
    let set  = new Set(ans.map(JSON.stringify));
    ans = Array.from(set).map(JSON.parse);
    return ans;
}

let arr2 = [-1, 0, 1, 2, -1, -4];
let n2 = arr2.length;
let ans2 = triplet(n2, arr2);
for (let it of ans2) {
    process.stdout.write("[");
    for (let i of it) {
        process.stdout.write(i + " ");
    }
    process.stdout.write("] ");
}
console.log();


// New Approach


// In the previous approach, we utilized 3 loops, 
// but now our goal is to reduce it to 2 loops. 
// To achieve this, we need to find a way to calculate arr[k] 
// since we intend to eliminate the third loop (k loop). 
// To calculate arr[k], we can derive a formula as follows: 
// arr[k] = target – (arr[i]+arr[j]+arr[k]) 
// = 0-(arr[i]+arr[j]+arr[k]) = -(arr[i]+arr[j]+arr[k]) 
// So, we will first calculate arr[i] and arr[j]
// using 2 loops and for the third one i.e. arr[k] 
// we will not use another loop 
// and instead we will look up the value 0-(arr[i]+arr[j]+arr[k])
//in the set data structure.
//Thus we can remove the third loop from the algorithm.
// For implementing the search operation of the third element,
// we will store all the elements between the indices 
// i and j in a HashSet and then we will search
// for the third element in the HashSet.


// The Code starts here

function triplet(n, arr) {
// First, we will declare a set data structure as we want unique triplets.
    let st = new Set();
    let ans = [];
// Then we will use the first loop(say i) that will run from 0 to n-1.
    for (let i = 0; i < n; i++) {
// Before the second loop, we will declare another HashSet
// to store the array elements 
// as we intend to search for the third element using this HashSet.
        let hashset = new Set();
// Inside it, there will be the second loop(say j) 
// that will run from i+1 to n-1.
        for (let j = i + 1; j < n; j++) {
            //Calculate the 3rd element:
// Inside the second loop, we will calculate the value of the third element i.e. -(arr[i]+arr[j]).

            let third = -(arr[i] + arr[j]);
// If the third element exists in the HashSet, 
// we will sort these 3 values 
// i.e. arr[i], arr[j], and the third element,
// and insert it in the set data structure declared in step 1.
// Find the element in the set:
            if (hashset.has(third)) {
                let temp = [arr[i], arr[j], third];
                temp.sort((a, b) => a - b);
                ans.push(temp);
            }
// After that, we will insert the j-th element 
// i.e. arr[j] in the HashSet as we only want to insert
// those array elements that are in between indices i and j.
            hashset.add(arr[j]);
        }
    }

    //store the set in the answer:
    let set  = new Set(ans.map(JSON.stringify));
    // Finally, we will return a list of triplets 
    // stored in the set data structure.
    ans = Array.from(set).map(JSON.parse);
    return ans;
}

let arr = [-1, 0, 1, 2, -1, -4];
let n = arr.length;
let ans = triplet(n, arr);
for (let it of ans) {
    process.stdout.write("[");
    for (let i of it) {
        process.stdout.write(i + " ");
    }
    process.stdout.write("] ");
}
console.log();