//  A=A.sort((a,b)=>a-b);

   for(let i =1; i<=A.length-1;i++){
        for(let j=0; j<A.length-(i); j++){
            if(A[j]>A[j+1]){
                let temp = A[j]
                A[j] = A[j+1]
                A[j+1] = temp
            }
        }
    }
    for(let i =0; i<A.length-2; i++){
        if(A[i]+A[i+1]>A[i+2]) return 1;
     }
 return 0;

function solution(A) {
    // write your code in JavaScript (Node.js 8.9.4)
 

// mergeSort -> 

// 분할
const divided = []

const divideArr = (arr)=>{
    if(arr.length===1){
        divided.push(arr);
        return arr;
    } 
    const mid = parseInt(arr.length/2)
    const first = arr.slice(0,mid)
    const second = arr.slice(mid)
    divideArr(first)
    divideArr(second)
}
divideArr(A)

console.log(divided)
let merged = divided.slice(0)

const mergeAB = (a,b)=> {
    debugger;
    if(b===undefined) return a;
    let length = a.length+b.length
    let mergeArr = []
    let aCompare = a[0]
    let bCompare = b[0]
    let bIndex = 0;
    let aIndex = 0;
    for(let i =0; i<length; i++){
        if(aCompare>bCompare){
            mergeArr[i]=bCompare
            bIndex +=1
            if(bIndex===b.length){
                return mergeArr = mergeArr.concat(a.slice(aIndex))
            }
            else{
                bCompare=b[bIndex]
            }            
        }
        else{
            mergeArr[i]=aCompare
            aIndex +=1
            if(aIndex===a.length){
                return mergeArr = mergeArr.concat(b.slice(bIndex))
            }
            else{
                aCompare=a[aIndex]
            }   
        }
    }
    return mergeArr
}
console.log(merged.length);

const mergeArr = (mergedArr)=> {
    debugger;
    if(mergedArr.length===1) return mergedArr
    let newMergeArr = []
    for(let i =0; i<mergedArr.length; i+=2){
        newMergeArr.push(mergeAB(mergedArr[i], mergedArr[i+1]))
    }
    return mergeArr(newMergeArr)
}
const findalMerged = mergeArr(merged)
}

console.log(solution([10,20,5,3,8,1]));
만도가 한 것이랑 비교해보기 ...

const dicA = {} 
  A.reduce((ac,c)=>{
      ac[c]=c
      return ac;
  }
  ,dicA)
  return Object.values(dicA).length;

  // set.size

function solution(A) {
    A = A.sort((a,b)=>a-b);
    const lastIdx = A.length-1
    const tripletsA = A[lastIdx]*A[lastIdx-1]*A[lastIdx-2]
    let tripletsB;
    if(A[0]<0&&A[1]<0) tripletsB = A[0]*A[1]*A[lastIdx]
    const tripletsMax = tripletsB ? Math.max(tripletsA, tripletsB) : tripletsA
    return tripletsMax
}