[2회차]

Programmers Level.1 크레인 인형뽑기

def solution(board, moves):
    stack = []
    answer = 0
    for j in moves:
        for i in range(len(board)):
            if board[i][j-1] != 0:
                stack.append(board[i][j - 1])
                board[i][j - 1] = 0
                if len(stack)>=2 and stack[-1] == stack[-2]:
                    stack.pop()
                    stack.pop()
                    answer += 2
                break
    return answer

 

 

 

Programmers Level.1 없는 숫자 더하기

def solution(numbers):
    lists = [0,1,2,3,4,5,6,7,8,9]
    answer = 0
    for i in lists:
        if i not in numbers:
            answer += i
    return answer

 

 

 

Programmers Level.1 음양 더하기

def solution(absolutes, signs):
    answer = 0
    for i in range(len(absolutes)):
        if signs[i]:
            answer += absolutes[i]
        else:
            answer -= absolutes[i]
    return answer

다른 풀이 보고 zip을 활용해서 새롭게 적어본다.

def solution(absolutes, signs):
    answer = 0
    for absolute, sign in zip(absolutes, signs):
        if sign:
            answer += absolute
        else:
            answer -= absolute
    return answer

 

 

 

Programmers Level.1 내적

def solution(a, b):
    answer = 0
    for A, B in zip(a, b):
        answer += A*B
    return answer

 

 

 

Programmers Level.1 소수 만들기

def solution(nums):
    array = [x for x in range(2, 3000)]
    for i in range(2, 56):
        for j in range(2, 3000//i):
            if i*j in array:
                array.remove(i*j)
    answer = 0
    l = len(nums)
    for i in range(l-2):
        for j in range(i+1, l-1):
            for k in range(j+1, l):
                if nums[i]+nums[j]+nums[k] in array:
                    answer += 1
    return answer

에라토스테네스의 체 활용.

 

 

 

Programmers Level.1 완주하지 못한 선수

처음에는 부르트포스로 하나씩 일일이 둘을 비교했더니 효율성 문제가 생겼음. 그래서 정렬 후에 둘을 비교함.

def solution(participant, completion):
    participant.sort()
    completion.sort()
    for i in range(len(completion)):
        if participant[i] != completion[i]:
            return participant[i]
    return participant[-1]

다른 사람의 풀이를 확인하니까 zip을 활용해도 괜찮더라. participant와 completion의 크기가 다르기 때문에 안될줄 알았는데 되더라.

def solution(participant, completion):
    participant.sort()
    completion.sort()
    for i,j in zip(participant, completion):
        if i != j:
            return i
    return participant[-1]

collections 모듈의 counter를 활용하는 방법도 있더라.

import collections


def solution(participant, completion):
    answer = collections.Counter(participant) - collections.Counter(completion)
    return list(answer.keys())[0]

 

 

 

Programmers Level.1 K번째수

def solution(array, commands):
    answer = []
    for command in commands:
        new_array = array[command[0]-1:command[1]]
        new_array.sort()
        answer.append(new_array[command[2]-1])
    return answer

 

 

 

Programmers Level.1 모의고사

def solution(answers):
    answer = list()
    score = [0, 0, 0]
    A = [1,2,3,4,5]
    B = [2,1,2,3,2,4,2,5]
    C = [3,3,1,1,2,2,4,4,5,5]
    for i in range(len(answers)):
        if A[i % 5] == answers[i]:
            score[0] += 1
        if B[i % 8] == answers[i]:
            score[1] += 1
        if C[i % 10] == answers[i]:
            score[2] += 1
    maxi = max(score)
    for i in range(3):
        if score[i] == maxi:
            answer.append(i+1)
    return answer

*

 

 

Programmers Level.2 체육복

def solution(n, lost, reserve):
    array = [1] * (n + 1)
    lost.sort()
    reserve.sort()
    array[0] = 0
    for i in lost:
        array[i] = 0
    for i in reserve:
        if array[i] == 0:
            array[i] = 1
        elif i > 1 and array[i-1] == 0:
            array[i-1] = 1
        elif i < n and array[i+1] == 0:
            array[i+1] = 1
    return sum(array)

 - 틀림.  맞게 생각한 것 같은데 틀려서 곤란했다. 그래서 일단 혹시나 해서 아래와 같이 바꿔보니까 답은 맞았다. 둘의 차이가 뭐지?

 

def solution(n, lost, reserve):
    array = [1] * (n + 1)
    lost.sort()
    reserve.sort()
    array[0] = 0
    for i in lost:
        if i not in reserve:
            array[i] = 0
    for i in reserve:
        if i not in lost:
            if i > 1 and array[i-1] == 0:
                array[i-1] = 1
            elif i < n and array[i+1] == 0:
                array[i+1] = 1
    return sum(array)

 - 맞음.

 

 - (둘의 차이) n = 5, lost = [2, 3], reserve = [1, 2]일 때,

    위에 방식대로 하면 lost에 의해 처음 array에는 [1번,4번,5번]이고 reserve에서 1번이 2번에게 빌려주고, 2번이 3번에게 빌려준다. 그러면 5명이 전부 갖고 올 수 있다. 하지만 이건 문제의 조건에 맞지 않는다.

    아래 방식대로 해야 처음에 array = [1번,4번,5번]일 때, 문제 조건에서 여벌을 갖고 있는 사람이 체육복을 잃어버렸을 때는 누구에게 빌려주지 않고 자기 자신이 사용한다고 했으니까 2번이 2번에게 빌려주고 1번은 누구에게도 빌려주지 않게 되서 4명만 체육복을 갖고 있게 된다. 체육복 여벌이 있으면서 체육복을 잃어버린 사람들을 먼저 처리해줘야 한다는 뜻이다.

 

 

 

Programmers Level.1 폰켓몬

def solution(nums):
    answer = 0
    a = len(set(nums))
    n = len(nums)
    if a <= n//2:
        answer = a
    else:
        answer = n//2
    return answer

 

이걸 짧게 적기.

def solution(nums):
    return min(len(set(nums)),len(nums)/2)

 

 

 

Programmers Level.1 실패율

def solution(N, stages):
    player = [0] * (N + 1)
    answer = []
    dicts = {}
    for i in stages:
        player[i-1] += 1
    sums = sum(player)
    for j, i in enumerate(player[:-1]):
        if i == 0:
            dicts[j+1] = 0
        else:
            dicts[j+1] = i/sums
            sums -= i
    dict_sorted = sorted(dicts.items(),key=lambda a:a[1],reverse=True)
    for i in dict_sorted:
        answer.append(i[0])
    return answer

 - 내 풀이

 

def solution(N, stages):
    result = {}
    denominator = len(stages)
    for stage in range(1, N+1):
        if denominator != 0:
            count = stages.count(stage)
            result[stage] = count / denominator
            denominator -= count
        else:
            result[stage] = 0
    return sorted(result, key=lambda x : result[x], reverse=True)

 - 다른 사람의 풀이. 

 

 - 나는 items를 이용해 튜플 형태로 추출한 다음에 정렬하고 거기서 key값을 뽑아냈는데 굳이 그렇게 하지 않아도 되는 것 같다. 좋은 공부가 됐다.

 

 

 

Programmers Level.1 약수의 개수와 덧셈

def solution(left, right):
    answer = 0
    for i in range(left, right + 1):
        cnt = 1
        for j in range(1, i):
            if i % j == 0:
                cnt += 1
        if cnt % 2 == 0:
            answer += i
        else:
            answer -= i
    return answer

 

 

 

Programmers Level.1 3진법 뒤집기

def solution(n):
    answer = 0
    array = []
    a = n
    while a != 0:
        array.append(a % 3)
        a = a // 3
    for i in range(len(array)):
        answer += array[i] * 3 ** (len(array)-i-1)
    return answer

 - 3진법을 직접 계산하는 식으로 구현.

 

def solution(n):
    ss = ''
    a = n
    while a != 0:
        ss += str(a % 3)
        a = a // 3
    return int(ss,3)

 - int함수 기능으로 3진법을 구현할 수 있더라. 문자열과 int함수의 합작.

 

 

 

Programmers Level.1 예산

def solution(d, budget):
    answer = 0
    d.sort()
    for i in d:
        budget -= i
        if budget < 0:
            break
        answer += 1
    return answer

greedy알고리즘으로 가장 작은 무게 부터 하나씩 넣어서 해결.

 

 

 

Programmers Level.1 두 개 뽑아서 더하기

def solution(numbers):
    answer = []
    for i in range(len(numbers) - 1):
        for j in range(i + 1, len(numbers)):
            if numbers[i] + numbers[j] not in answer:
                answer.append(numbers[i] + numbers[j])
    answer.sort()
    return answer

 

 

 

Programmers Level.1 2016년

def solution(a, b):
    answer = ''
    day = 0
    days = [0,31,29,31,30,31,30,31,31,30,31,30]
    dayword = ['THU', 'FRI', 'SAT', 'SUN', 'MON', 'TUE', 'WED']
    for i in range(a):
        day += days[i]
    day += b
    return dayword[day % 7]