내 인생 이대로 ㅈ될 수 없다

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

내 풀이

def solution(dirs):
    answer=0
    visited = []
    move = {'U': (0, 1), 'D': (0, -1), 'R': (1, 0), 'L': (-1, 0)}
    x,y=0,0
    
    for dir in dirs:
        nx = x + move[dir][0]
        ny = y + move[dir][1]
        print(x,y,nx,ny)
        if -5<=nx<=5 and -5<=ny<=5:
            if not ([[x,y],[nx,ny]] in visited or [[nx,ny],[x,y]] in visited):
                visited.append([[x,y],[nx,ny]])
                
                answer+=1
            x,y=nx,ny
            print(x,y,nx,ny)    
    
    
    
    return answer

사실 처음에는 10 x 10 그래프를 만들어놓고 bfs 문제 풀듯이 다 체크한 뒤에 1의 개수만 세려고했는데 너무 낭비인거같아서 방법을 바꿨다.

방법은 이렇다, u,d,r,l 마다 움직일 방향을 미리 정해놓고 정해놓은 방향으로 갔을때 범위를 넘지않고, 한번도 방문한적 없다면 visit에 넣어준다. 넣어줄때마다 answer에 더해준다.

하나 생각해야할것은, 가령 (1,0) 에서 (0,0)로 좌측으로 한칸 가는거나 (0,0) 에서 (1,0)으로 우측으로 한칸가는거나 같은거다.

그래서 그전 좌표와 갱신할 좌표를 모두 visit에 넣어준다 (x,y,nx,ny) 그리고 x,y 에 갱신 한 좌표를 마지막에 할당해줌으로서 이어나간다.

다른사람의 풀이

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