Portfolio

풀이

김영준


function solution(number) {
    var answer = 0;
    for(let i = 0; i < number.length; i ++){
        for(let j = i + 1; j < number.length; j ++){
            for(let k =  j + 1; k < number.length; k++){
                if(number[i] + number[j] + number[k] === 0) answer++;
            }
        }
    }
    return answer;
}

이종현


// 완전탐색 문제로 모든 경우의 수를 구해 문제해결
function solution(number) {
    let answer = 0;
    
    for (let i = 0; i < number.length; i++) {
        for (let j = i + 1; j < number.length; j++) {
            for (let k = j + 1; k < number.length; k++) {
                if (number[i] + number[j] + number[k] === 0) answer++;
            }
        }
    }
    
    return answer;
}
/* 3총사가 아닌 4, 5, 6...총사가 되면 단순히 반복문만으로 
 * 해결하기 어려울 것이라 생각해 다른 방법을 생각해보았지만
 * 문제해결을 위한 다른 로직을 작성 하지 못하고 검색을 통해 알게된
 * 재귀를 이용하여 해결 할 수 있는 로직을 가지고 와봤습니다 
 */
function solution(number) {
    let result = 0;

    const combination = (current, start) => {
        if (current.length === 3) {
            result += current.reduce((acc, cur) => acc + cur, 0) === 0 ? 1 : 0;
            return;
        }

        for (let i = start; i < number.length; i++) {
            combination([...current, number[i]], i + 1);
        }
    }
    combination([], 0);
    return result;
}

박노철


function solution(number) {
    
   //number 길이가 13이다 . 완전탐색 가능
    let count=0;
    for(let i =0; i<number.length; i++){
        for(let j=i+1; j<number.length; j++ ){
            for(let k=j+1; k<number.length; k++){
                if(number[i]+ number[j]+ number[k] === 0)count++ ;
            }
        }
    }
    return count
}

이민희


// 가능한 조합의 배열을 모두 담은 배열을 리턴 [[-2, 3, 0], [-2, 3, 2], ...]
// cnt: 조합할 개수
function getCombinationArrs(arr, cnt) {
    if (cnt === 1) return arr.map(number => [number]); // 하나씩 조합할 거면 그냥 하나씩 배열에 담아 리턴
    const results = [];
    arr.forEach((number, idx) => {
        const rest = arr.slice(idx + 1); // 현재 인덱스 이후의 원소에 대해서 cnt - 1개의 조합을 다시 구함.
        const attachedArrs = getCombinationArrs(rest, cnt - 1).map(restArr => [number, ...restArr]); // 해당 조합들 각각에 대해 현재 인덱스의 원소와 이어붙임.
        results.push(...attachedArrs);
    })
    return results;
}
function sum(arr) {
    return arr.reduce((acc, cur) => acc + cur, 0);
}
function solution(number) {
    return getCombinationArrs(number, 3).reduce((acc, combArr) => sum(combArr) === 0 ? acc + 1 : acc, 0)
}

조합 구현할 때 참고한 포스팅

박건우


function solution(number) {
    let answer = 0;
    
    function DFS(cnt, index, sum){
        if(cnt >= 3){
            if(sum === 0) answer++;
            return;
        }
        for(let i = index; i<number.length; i++){
            DFS(cnt + 1, i + 1, sum + number[i]);
        }
    }
    
    DFS(0, 0, 0);
    
    return answer;
}

// 전형적인 조합 완전 탐색 문제입니당
// 해당 문제 같은 경우는 3중 for문을 사용해도 전혀 문제가 없긴 합니다만
// 만약 3총사가 아니라 N총사인 경우 문제가 됩니다.
// 중첩 for문을 사용할 경우 여러 상황에 대해 유연하지 못합니다.
// 테스트 케이스마다 고르는 사람의 수가 달라질 경우를 생각해보는게 좋아용
// 따라서 이런 문제의 경우 재귀를 활용하는 것이 좀더 좋습니당

박주연


//조합 알고리즘을 구현하는 과정은 막혀서 인터넷을 참고했습니다😊

//매개변수 arr = 원본배열(문제에서 number), num = 부분집합 안 원소개수 즉 삼총사
function combination(arr,num=3) {
    const result = []; //조합 결과들을 담아줄 배열
    
    if(num === 1) return arr.map((n) => [n]); //nC1일때 바로 그 원소 배열을 리턴해줌
    
    //배열의 첫번째 원소부터 고정하고 나머지 원소들을 따로 배열로 만들어 조합한다(재귀)
    arr.forEach((fixed, index, originArr)=>{
        const rest = originArr.slice(index+1); 
        const restCombination = combination(rest, num-1);
        const fullCombination = restCombination.map((value) =>[fixed,...value]);
        result.push(...fullCombination);
    })
    
    return result;
}

function solution(number) {
//접근 방식: 조합을 만드는 알고리즘을 구현해서 만들어진 부분집합들의 합 계산하기

let answer = 0;
const cbResult = combination(number);

//조합 결과 속 배열들의 합을 각각 구하기
cbResult.forEach((arr)=>{
    if(arr.reduce((acc,cur) => acc+cur,0) === 0) answer++;
})

return answer;
}