[프로그래머스 1단계] 문제풀이 #5

1. 두 개 뽑아서 더하기

[프로그래머스 1단계 - 두 개 뽑아서 더하기]

프로그래머스

1-1. 내 풀이

for 문을 사용하여 모든 결과의 경우를 만들고 오름차순으로 정렬한 후, Set 을 사용하여 중복을 제거하였다.

function solution(numbers) {
    let arr = []
    for(i=0; i<numbers.length - 1; i++) {
        for (j=i+1; j<numbers.length; j++) {
            arr.push(numbers[i] + numbers[j]);
        }
    }
    const result = new Set(arr.sort((a,b)=> a - b));
    return [...result];
}

1-2. 다른 사람 풀이

다른 사람도 나와 같은 방법으로 풀었다.

function solution(numbers) {
    const temp = []

    for (let i = 0; i < numbers.length; i++) {
        for (let j = i + 1; j < numbers.length; j++) {
            temp.push(numbers[i] + numbers[j])
        }
    }

    const answer = [...new Set(temp)]

    return answer.sort((a, b) => a - b)
}

 

2. K번째 수

[프로그래머스 1단계 - K번째 수]

프로그래머스

2-1. 내 풀이

array 를 slice 를 사용하여 자르고 sort 를 사용해 정렬한 후 알맞은 위치에 있는 수를 반환한다.

function solution(array, commands) {
    const result = commands.map((item)=>{
        return array.slice(item[0] - 1, item[1]).sort((a,b)=>a-b)[item[2] -1 ];
    })
    return result;
}

2-2. 다른 사람 풀이

commands 배열에 있는 내용을 구조분해할당해서 풀었다. 이게 인상 깊어서 가져왔고 이 사람은 filter 를 사용하였는데 slice 가 더 유용한 것 같다.

function solution(array, commands) {
    return commands.map(command => {
        const [sPosition, ePosition, position] = command
        const newArray = array
            .filter((value, fIndex) => fIndex >= sPosition - 1 && fIndex <= ePosition - 1)
            .sort((a,b) => a - b)    

        return newArray[position - 1]
    })
}

 

3. 푸드 파이터 대회

[프로그래머스 1단계 - 푸드 파이터 대회]

프로그래머스

3-1. 내 풀이

음식 개수에 2를 나눈 값을 내림하여 반복해서 더해주고, 결과에서 0 을 붙이고 결과의 역순을 더했다.

function solution(food) {
    let result = '';
    for(i=1; i<food.length; i++) {
        const cnt = Math.floor(food[i] / 2);
        result += i.toString().repeat(cnt);
    }
    return result + 0 + result.split('').reverse().join('');
}

 

3-2. 다른 사람 풀이

나랑 똑같은 방법으로 풀었지만 split('') 대신 스프레드 연산자를 사용하였다.

function solution(food) {
    let res = '';
    for (let i = 1; i < food.length; i++) {
        res += String(i).repeat(Math.floor(food[i]/2));
    }

    return res + '0' + [...res].reverse().join('');
}

 

4. 문자열 내 마음대로 정렬하기

[프로그래머스 1단계 - 문자열 내 마음대로 정렬하기]

프로그래머스

4-1. 내 풀이

n 번째에 위치한 알파벳을 비교하고, 만약 같다면 두 문자중 사전상 앞에 있는 걸 먼저 배치한다.

function solution(strings, n) {
    strings.sort((a,b)=>{
        if(a[n] > b[n]) return 1;
        else if (a[n] < b[n]) return -1;
        else return a > b ? 1 : -1;
    })
    return strings;
}

4-2. 다른 사람 풀이

localeCompare 라는 메서드를 사용해서 n 번째 위치한 알파벳이 같을 때 s1 이 먼저 오면 1을 반환하고 그렇지 않으면 -1 을 반환했고 다른 경우 n 번째 위치를 비교했다. localeCompare 라는 메서드를 처음 들어보았는데 이렇게도 사용할 수 있구나

function solution(strings, n) {
    // strings 배열
    // n 번째 문자열 비교
    return strings.sort((s1, s2) => s1[n] === s2[n] ? s1.localeCompare(s2) : s1[n].localeCompare(s2[n]));
}

 

5. [1차] 비밀지도

[프로그래머스 1단계 - [1차] 비밀지도]

프로그래머스

5-1. 내 풀이

비트 연산자를 한 후 2진수로 바꾸고, 앞에 0 을 채워 자리수를 맞춰주었다. 그리고 1 -> '#', 0 -> ' ' 으로 변경하여 리턴했다.

function solution(n, arr1, arr2) {
    const result = arr1.map((item, idx)=>{
        let answer = (item | arr2[idx]).toString(2).padStart(n,'0');
        return answer.replaceAll(1,'#').replaceAll(0,' ');
    })
    return result;
}

 

6. 콜라 문제

[프로그래머스 1단계 - 콜라문제]

프로그래머스

6-1. 내 풀이

b 의 값이 1인 경우만 생각해서 테스트 케이스는 통과하는데 채점에서 계속 실패했다가 힌트를 보고 b 의 값도 생각하게 되었다. 거의 수학문제라서 계산 결과를 log 로 찍어보면서 답을 구했다.

function solution(a1, b1 , n1) {
    let result = 0;
    while(n1 >= a1) {
        const newItem = Math.floor(n1 / a1) * a1;
        const exchange = newItem / a1 * b1;
        result += exchange,
        n1 = n1 - newItem + exchange;
    }
    return result;
}

 

7. 명예의 전당(1)

[프로그래머스 1단계 - 명예의 전당(1)]

프로그래머스

7-1. 내 풀이

명예의 전당 배열을 만들어 값을 넣어 정렬하고 k 개 만큼 잘라 뒤집어 제일 첫번째 걸 가져왔다.

function solution(k, score) {
    let list = [];
    
    return score.map((item)=>{
        list.push(item);
        list.sort((a,b)=>b-a);
        return list.slice(0, k).reverse()[0];
    })
}

7-2. 다른 사람 풀이

나는 배열에서 제일 작은 수를 가져올려고 reverse 하고 맨 앞에 있는 걸 가져왔는데 Math.min 으로 간단히 할 수 있는 걸 까먹었다.

function solution(k, score) {
    var answer = [];

    return score.reduce((acc, cur) => {
        answer.push(cur);
        answer = answer.sort((a, b) => b - a).slice(0, k);
        return [...acc, Math.min(...answer)];
    }, []);
}

 

8. 추억 점수

[프로그래머스 1단계 - 추억 점수]

프로그래머스

8-1. 내 풀이

indexOf 를 사용하여 추억 점수가 있는 사람이면 그 점수를 더하고 그렇지 않으면 0 점을 더하도록 했다.

function solution(name, yearning, photo) {
    return photo.map((item)=>{
        return item.reduce((acc,cur)=>{
            const index = name.indexOf(cur);
            return acc += index === -1 ? 0 : yearning[index];
        },0)
    })
}

8-2. 다른 사람 풀이

나랑 같은 방법인데 한 줄에 풀었다. 그리고 ?? 연산자를 사용해서 추억점수가 없어 undefined 인 경우 0을 반환하도록 했다.

function solution(name, yearning, photo) {
    return photo.map((v)=> v.reduce((a, c)=> a += yearning[name.indexOf(c)] ?? 0, 0))
}

 

9. 카드 뭉치

[프로그래머스 1단계 - 카드 뭉치]

프로그래머스

9-1. 내 풀이

for 문을 이용하여 문제를 풀었다.

function solution(cards1, cards2, goal) {
    let secondIdx = 0;
    for(i=0; i<goal.length; i++) {
        if (goal[i] === cards1[i - secondIdx]) continue;
        else {
            if (goal[i] === cards2[secondIdx]) {
                secondIdx += 1;
                continue;
            } else return "No";
        }
    }
    return "Yes";
}

9-2. 다른 사람 풀이

shift 를 사용해서 풀었다. 그런데 댓글을 보니 만약 배열의 길이가 길 경우 비효율적이라고 해서 index 를 이용하는 것이 좋다고 한다.

function solution(cards1, cards2, goal) {
    for(const s of goal) {
        if(cards1[0] == s) {
            cards1.shift();
        } else if(cards2[0] == s) {
            cards2.shift();
        } else {
            return "No"
        }
    }
    return "Yes";
}

 

10. 폰켓몬

[프로그래머스 1단계 - 폰켓몬]

프로그래머스

10-1. 내 풀이

Set 을 사용하여 중복된 값을 없애고, 전체의 절반 보다 작으면 중복을 제거한 값의 길이를 반환했다.

function solution(nums) {
    const newSet = new Set(nums);
    const result = [...newSet].length;
    const count = nums.length / 2
    return result < count ? result : count;
}

10-2. 다른 사람 풀이

나랑 같은 방법인데 나는 set 의 길이를 구하기 위해 배열로 만들었는데 set.size 메서드로 길이를 구할 수 있는 걸 새롭게 알게 되었다.

function solution(nums) {
    const noDuplicatePokemon = new Set(nums);
    const pokemonVarietyCount = noDuplicatePokemon.size;
    const pokemonCounts = nums.length;
    return pokemonVarietyCount > pokemonCounts/2 ? pokemonCounts/2 : pokemonVarietyCount;
}