흔적남기기

처음 풀이시 각 패턴에 대한 함수를 도출해내는 문제인줄로 알고, 머리를 싸매었는데 도무지 패턴을 알 수 없었다.

1번 수포자의 함수식은 비교적 간단하지만, 2번 수포자부터는 식을 도출해낼 수 없었다.

그래서 그냥 나는 프로그래머니까 무식하게 가자는 생각으로 다음과 같이 구현해내었다.

def first(num):
    return (num % 5) + 1

def second(num):
    if num % 2 == 0: #짝수
        return 2
    else:
        rem = num % 8
        if rem == 1:
            return 1
        elif rem == 3:
            return 3
        elif rem == 5:
            return 4
        else:
            return 5

def third(num):
    rem = num % 10
    if rem < 2:
        return 3
    elif rem < 4:
        return 1
    elif rem < 6:
        return 2
    elif rem < 8:
        return 4
    else:
        return 5
    
def solution(answers):
    
    dic = {1:0, 2:0, 3:0}

    for idx, ans in enumerate(answers):
        if ans == first(idx):
            dic[1] += 1
        if ans == second(idx):
            dic[2] += 1
        if ans == third(idx):
            dic[3] += 1

    scoreMax = max(dic.values())

    answers = []
    for k, v in dic.items():
        if v == scoreMax:
            answers.append(k)

    return answers

각 수포자마다 함수를 마련하고, 딕셔너리에 점수를 기입한 후 최대값을 구하고, 최대값을 가진 모든 수포자들을 for문 돌면서 추가하는 코드

'무식한게 최고다' 라는 완전탐색의 취지에 부합하긴 하지만, 문제에 비해 코드량이 너무 길다고 느껴졌다.

그래서 다른 굇수분들의 풀이를 보았는데 역시나 머리를 탁 치게 하는 코드다. 패턴을 그냥 나열하고, 거기에 나머지 값을 이용해 구현하는 방식이 너무 깔끔하다. 

def solution(answers):
    pattern1 = [1,2,3,4,5]
    pattern2 = [2,1,2,3,2,4,2,5]
    pattern3 = [3,3,1,1,2,2,4,4,5,5]
    score = [0, 0, 0]
    result = []

    for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1

    for idx, s in enumerate(score):
        if s == max(score):
            result.append(idx+1)

    return result

기본 알고리즘은 같지만 함수가 아닌, 패턴을 배열로 나열한 부분이 다름 (코드량이 거진 1/3)

존경합니다.

def solution(citations):
    citations.sort()

    hIndex = 0

    for i in range(len(citations) + 1):
        if sum(citation >= i for citation in citations) >= i:
            hIndex = i
        else:
            break

    return hIndex

import heapq

def solution(scoville, K):
    heapq.heapify(scoville)

    maxCount = len(scoville) - 1

    answer = 0
    curK = 0

    while maxCount > answer:
        first = heapq.heappop(scoville)
        second = heapq.heappop(scoville)
        heapq.heappush(scoville, first + (second * 2))
        answer += 1
        isAllOver = True
        for i in scoville:
            if i < K:
                isAllOver = False
                break

        if isAllOver:
            return answer

    return -1

import math
from collections import deque

def solution(progresses, speeds):
    days = deque()
    for idx, val in enumerate(progresses):
        days.append(math.ceil((100 - progresses[idx]) / speeds[idx]))

    answer = []
    lastDay = 0

    while(len(days)):
        day = days.popleft()
        if lastDay >= day:
            continue

        funcNum = 1
        for chkDay in days:
            if day < chkDay:
                break
            else:
                funcNum += 1

        answer.append(funcNum)
        lastDay = day

    return answer

from collections import deque

def solution(prices):
    queue = deque(prices)
    answer = []

    while len(queue) > 0:
        val = queue.popleft()
        length = 0

        for i in queue:
            length += 1
            if val > i:
                break

        answer.append(length)

    return answer

def solution(genres, plays):

    answer = []

    tmpGenreDict = {}

    songDict = {}
    for i in range(len(genres)):
        genre = genres[i]
        playTime = plays[i]

        if genre not in songDict:
            songDict[genre] = {}
            tmpGenreDict[genre] = 0

        songDict[genre][i] = playTime
        tmpGenreDict[genre] += playTime

    tmpGenreDict = sorted(tmpGenreDict.items(), key=lambda x: x[1], reverse=True)

    for arr in tmpGenreDict:
        sortedSongs = sorted(songDict[arr[0]].items(), key=lambda x: x[1], reverse=True)
        curCnt = 0
        for idx in sortedSongs:
            if curCnt >= 2:
                continue
            answer.append(idx[0])
            curCnt += 1

    return answer

from itertools import combinations

def solution(clothes):
    _dict = {}
    for _set in clothes:
        _category = _set[1]
        if _category in _dict:
            _dict[_category] += 1
        else:
            _dict[_category] = 1

    answer = 1

    for i in _dict.values():
        answer *= (i + 1)

    answer = answer - 1

    return answer

def solution(phone_book):
    chDic = {}

    answer = True

    for pN in phone_book:
        for key, val in chDic.items():
            _isContain = False
            if val <= len(pN):
                _isContain = Check(key, pN)
            else:
                _isContain = Check(pN, key)

            if _isContain:
                answer = False
                break

        if answer == False:
            break

        chDic[pN] = len(pN)

    return answer

def Check(short, long):
    idx = 0
    for char in short:
        if char != long[idx]:
            return False

        idx += 1
    return True