내 인생 이대로 ㅈ될 수 없다

https://school.programmers.co.kr/learn/courses/30/lessons/12927

내 풀이

최초 틀렸던 풀이

def solution(n, works):
    answer = 0
    if n >= sum(works):
        return 0

    sums=0    
    while n:
        works.sort(reverse=True)
        works[0] -=1
        n-=1
    works.sort()

    return sum([i**2 for i in works])

사실 틀릴줄 알고 있었다. 왜냐면 레벨3 문제인데 너무 쉬웠기 때문.

틀리고 나니까 heapq을 써야겠구나 싶어서 바로 적용해서 풀었다.

import heapq

def solution(n, works):
    answer = 0
    if n >= sum(works):
        return 0

    works = [-i for i in works]
    #print(works)
    heapq.heapify(works)

    for _ in range(n):
        i = heapq.heappop(works)
        i += 1
        heapq.heappush(works, i)

    return sum([i ** 2 for i in works])

리스트 컴프리헨션이 점점 익숙해지고 있어서 그 점은 마음에 든다만 잘 짠 코드인지는 좀 의문이 든다.

다른사람의 풀이

내 풀이

import numpy as np
def solution(A, B):

    return (np.matrix(A)*np.matrix(B)).tolist()

def solution(A, B):

    return [[sum(a*b for a, b in zip(A_row,B_col)) for B_col in zip(*B)] for A_row in A]

1번 풀이는 Numpy를 이용한 풀이다. 과거에 기계 학습을 이용해서 넘파이와 판다스를 통해서 공부한 기억이 있어 쉽게 풀수 있었다

근데 numpy나 pandas는 pip를 이용해서 설치해야하는 외부 모듈이다. 내 생각에는 아마도 넘파이를 지원하지 않을 확률이 높을거 같다.

마지막에 tolist로 바꿔주는 이유는 numpy의 return 값이 numpy이기 때문이다. 그런데 대부분의 코딩테스트 시 return 할 수 있는 형태가 정해져있다. 그렇기 때문에 바꿔줘야한다.

2번 풀이는 zip의 언패킹을 활용한 풀이다.

zip은 패킹과 언패킹을 할 수 있는데

차근차근 해석해보자면

1) sum(a*b) for a,b in zip(A_row,B_col)

a,b 의 합을 구하는데 그 a,b는 a_row,b_col을 zip한 것이다

아래 그림을 보면 zip의 역할을 알 수 있는데 어떤 내용을 zip하게 되면 하나의 셋트로 묶어준다.

2) 그럼 a_row와 b_col은 무엇인가?

b_col은  zip(*B)를 한것인데 이를 언패킹이라고 부르고 이것의 역할 역시 아래 예시를 보면 알 수 있다.

그러니까 b의 요소들을 언패킹해서 b_col 에 할당해주는것이다.

3)근데 그럼 왜 A는 언패킹 해주지 않아도되냐?

이유는 행렬의 계산 자체가 그렇게 하는거라서이다. 

다른사람의 풀이

https://hmkim312.github.io/posts/Zip과_언팩킹/

잘 이해가 안된다면 패킹과 언패킹관련 글을 하나 보는것을 추천한다.

https://school.programmers.co.kr/learn/courses/30/lessons/12981

내 풀이

def solution(n, words):

    answer=[]
    candi = []
    set_words = set(words)
    if len(set_words) != len(words):
        for i in range(len(words)): 
            if words[i] in candi:
                answer.append((i%n)+1,)
                answer.append(i//n+1)
                return answer
            candi.append(words[i])



    else:
        for i in range(len(words)-1):
            print(words[i][-1],words[i+1][0])
            if words[i][-1] != words[i+1][0]:
                answer.append(((i+1)%n)+1,)
                answer.append((i+1)//n+1)

                return answer
        else:
            return [0,0]        

def solution(n, words):
    for i in range(len(words)-1):
        
        if words[i][-1] != words[i+1][0] or words[i+1] in words[:i]: 
            return [((i+1)%n+1),((i+1)//n)+1]
    else:
        #print('for debug')
        return [0,0]

최초에 풀 때는 아예 경우를 달리두고 풀었다

1) 겹치는 단어가 있을 때는 길이가 달라지니까 그거를 셋으로 바꿔서 중복값을 없애고 길이를 비교하는 멍청한짓을 했다

2)겹치는 단어가 없을 때 끝말잇기의 규칙을 어기는 경우

근데 생각해보니까 그럴 필요가 없었다.

그래서 더 간단하게 풀었다. 하나 고려해야할 것은 중복검사를 할때 i+1부터 해야한다는것. 어차피 최초값은 중복일 리가 없고

i로 중복값을 검사하면 맨 마지막에 중복값이 나올경우를 거를 수가 없기 때문이다.

다른사람의 풀이

def solution(n, words):
    for p in range(1, len(words)):
        if words[p][0] != words[p-1][-1] or words[p] in words[:p]: return [(p%n)+1, (p//n)+1]
    else:
        return [0,0]

아니면 이분처럼 1부터 시작해도 방법일거같다.

https://school.programmers.co.kr/learn/courses/30/lessons/92335

내 풀이

import string
import math
tmp = string.digits+string.ascii_lowercase


def solution(n, k):
    count=0
    tmp_result=convert(n,k)
    result = tmp_result.split('0')
    print(result)
    for i in result:
        if len(i)==0:
            continue
        if check_prime(int(i)):
            count +=1
    return count


def convert(num, base) :
    q, r = divmod(num, base)
    if q == 0 :
        return str(tmp[r]) 
    else :
        return str(convert(q, base) + tmp[r])
def check_prime(n):
    if n==1:
        return False
    for i in range(2,int(math.sqrt((n))) +1 ):
        if n%i==0:
            return False
    return True

몇 가지 가져갈 점이 있다고 생각하는데

1) 10진수를 n번쨰로 변환하는 방법

그냥 나눠주면 된다. 다만 여기서 str로 변환한 이유는 문자열 처리 때문이다.

2) 소수판단하는 방법

흔히들 하는 소수판단법은 2부터 자기자신 -1 까지 나눠지는지 여부를 판단하는 것이다.

기본 아이디어는 같지만, 포인트는 제곱근까지 가능한지 확인 해보면되는것이다. 

가령 16이라고 한다면 원래는 2,~15까지 다 나눠보겠지만 

그게 아니라 2부터 4까지만 확인해보면 되는데 이유는, 간단하다 어차피 그 뒤는 순서가 바꼈을 뿐 같은 수이기 때문이다

2 * 8,  4 * 4 ,
4 * 4,  8 * 2  

다른사람의 풀이

def solution(n, k):
    word=""
    while n:            # 숫자를 k진법으로 변환
        word = str(n%k)+word
        n=n//k
        
    word=word.split("0")  # 변환된 숫자를 0을 기준으로 나눈다.
    
    count=0
    for w in word:
        if len(w)==0:    # 만약 0또는 1이거나 빈공간이라면 continue를 통해 건너뛴다.
            continue
        if int(w)<2:
            continue
        sosu=True
        for i in range(2,int(int(w)**0.5)+1): # 소수찾기
            if int(w)%i==0:
                sosu=False
                break
        if sosu:
            count+=1
            
    return count

https://school.programmers.co.kr/learn/courses/30/lessons/12938

내 풀이

def solution(n, s):
    answer = []
    if n>s:
        return [-1]
    
    a, b = divmod(s, n)
    print(a,b)
    answer = [a] * n
    
    
    for i in range(b):
        answer[i] += 1
        
    return sorted(answer)

아이디어는 간단하다. 집합 구성원들의 편차가 낮으면 된다.

다른사람의 풀이

def bestSet(n, s):
    answer = []
    a = int(s/n)

    if a == 0:
        return [-1]

    b = s%n

    for i in range(n-b):
        answer.append(a)
    for i in range(b):
        answer.append(a+1)

    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/92341

내 풀이

from collections import defaultdict
import math

def solution(fees,records):
    info = {}
    answer=defaultdict(int)
    result =[]
    max_time = 23 * 60 + 59
    for i in records:
        time,number,status = i.split()
        hour,minu = time.split(':')
        time = int(hour) * 60 + int(minu)
        if number in info:
            answer[number] += time - info[number]
            
            del(info[number])
            
            
        else:
            info[number]= time
    max_time = 23 * 60 + 59
    for num,t in info.items():
        answer[num] += max_time - t
    
    
    basic_t,basic_f,m_t,m_f = fees
    for num,time in answer.items():
        cost = basic_f
        if basic_t < time:
            cost += math.ceil ((time - basic_t)  / m_t)  * m_f
        result.append((num,cost))
    result.sort()
    
    return [i[1] for i in result]

진짜 오래걸렸다. 이유는 모르겠음 한 두시간은 푼거같다. 어렵지도 않았는데 말이지

다른사람의 풀이

from collections import defaultdict
from math import ceil

class Parking:
    def __init__(self, fees):
        self.fees = fees
        self.in_flag = False
        self.in_time = 0
        self.total = 0

    def update(self, t, inout):
        self.in_flag = True if inout=='IN' else False
        if self.in_flag:  self.in_time = str2int(t)
        else:             self.total  += (str2int(t)-self.in_time)

    def calc_fee(self):
        if self.in_flag: self.update('23:59', 'out')
        add_t = self.total - self.fees[0]
        return self.fees[1] + ceil(add_t/self.fees[2]) * self.fees[3] if add_t >= 0 else self.fees[1]

def str2int(string):
    return int(string[:2])*60 + int(string[3:])

def solution(fees, records):
    recordsDict = defaultdict(lambda:Parking(fees))
    for rcd in records:
        t, car, inout = rcd.split()
        recordsDict[car].update(t, inout)
    return [v.calc_fee() for k, v in sorted(recordsDict.items())]