내 인생 이대로 ㅈ될 수 없다

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

내 풀이

def solution(order):
    temp = []
    i = 1
    now = 0
    
    while i != len(order)+1:
        temp.append(i)
        while temp[-1] == order[now]:
            now += 1
            temp.pop()
            
            if len(temp) == 0:
                break
        i += 1


    return now

처음에 문제가 잘 이해가 안됐다.

[1,2,3,4,5]의 순서로 있는택배를 order에서 요청한 대로 쌓아야하는데, 그게 불가능하다면 최대한으로 가능한 숫자를 리턴한다

그니까 1 2 3 4 5 -> 4 3 1 2 5 의 순서대로 쌓으라는 말이다

4번을 최초로 쌓으라했으니 1 2 3 번 까지 스택구조의 임시컨테이너에 넣어놓고 4번을 택배트럭에 싣는다.

다음 3번을 쌓아야하니 임시컨테이너에서 3번을 꺼낸다(스택구조) 참고로 pop은 리스트에서 젤 뒤에 요소를 삭제하고 그 값을 리턴한다. 

만약에 임시컨테이너에 더 쌓여진게 없으면 모두 택배에 넣어진거니까 break해서 빠져나온다.

다른사람의 풀이

https://velog.io/@namkun/프로그래머스-lv2-택배상자

https://school.programmers.co.kr/learn/courses/30/lessons/132265?language=python3 

내 풀이

from collections import defaultdict

def solution(topping):
    Top = defaultdict(int)
    for i in topping:
        Top[i] +=1
        
    Top_set=set()
    count=0
    for i in topping:
        Top[i] -=1
        Top_set.add(i)
        if Top[i] ==0:
            Top.pop(i)
        if len(Top) == len(Top_set):
            count +=1
    return count

defaultdict를 이용해서 있는거 추가해주고 어떤 key의 VALUE값이 0 이면 없애준다.

다른사람의 풀이

from collections import Counter

def solution(topping):
    Top = Counter(topping)
    count=0
    Top_set=set()
    for i in topping:
        Top[i] -=1
        Top_set.add(i)
        if Top[i] ==0:
            Top.pop(i)
        if len(Top) == len(Top_set):
            count +=1
    return count

이게 더 나은 코드같다. 다 똑같은데 counter를 쓰면 편하게 셀 수 있다!

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

내 풀이

# xor 연산 - 같으면 0 다르면 1 연산의 결과중에 1의 개수가 2개 이하인거만 세면되지않을까?


# def solution(numbers):
#     maxs=100000
#     temp = []
#     for i in numbers:  
#         j = i + 1
#         while True:
#             if bin(i^j).count('1') <=2:
#                 temp.append(j)
#                 break
#             j=j+1
                    
#     return temp

최초의 풀이는 이랬다. xor연산 했고 시간초과

def solution(numbers):
    answer=[]
    for i in numbers:
            if i % 2 ==0:
                answer.append(i+1)
            else:
                j = '0' + bin(i)[2:]
                idx = j.rfind('0')
                j = list(j)
                j[idx]='1'
                j[idx+1]='0'

                answer.append(int(''.join(j),2))
    return answer

그래서 그냥 예제케이스로 보여준거 그대로 구현해봤는데 성공했다

다른 블로그 보니까 직접 손으로 구하셨던데, 게으른 나는 그냥 테스트케이스에서 일반화 했는데 얻어걸렸다.

다른사람의 풀이

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

내 풀이

import re
def solution(files):
    target = '([0-9]+)'
    
#     test= [(1,i) for i in range(0,100)]
    
#     test = sorted(test,key = lambda x:x[0])
#     print(test)
    
    temp = [re.split(target,s) for s in files]
    sort = sorted(temp, key = lambda x: (x[0].lower(), int(x[1])))
    
    return [''.join(s) for s in sort]

문제를 풀면서 조금 신경쓰였던 부분이 안정 정렬 부분이였다. 안정 정렬에 관한 내용을 분명 배웠고 무슨 내용인지는 아는데

파이썬에서 기본적으로 제공하는 sorted 와 sort가 안정정렬인지에 관하여 확신을 할 수 없었다.

그래서 그냥 실험으로 확인해보았다(주석부분). 그 후에 이 부분에 관하여 궁금하여 공식문서를 찾아았다 

https://docs.python.org/3/howto/sorting.html

찾아보면 알겠지만 stable하다고 나온다.

문제에서 요구하는 조건은 총 3가지인데

일전에 텐서플로우를 공부할 때 배웠던 정규식으로 풀어보았다.

target을 기준으로 나누는데

타겟의 조건은 0부터 9까지 즉 숫자가 존재하는지 여부이다. 뒤에 +는 반복인데 1번이상 나올때만 체크된다.

긍까 숫자가 한자리 숫자만 나오는게 아니라 여러자리 숫자가 나올 수 있기 때문에 +는 넣어줘야한다.

이후에 정렬 해주는데 기준을 두가지로 정렬해준다. 첫번째는 head를 lower()로 바꿔서, 두번째는 숫자를 기준으로

어렵지 않은 문제였는데 정규식이 아니였다면 엄청나게 돌아갔을거 같기도 한 문제이다.

다른사람의 풀이

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

내 풀이

def solution(n, left, right):
    answer = []
    
    for i in range(left,right+1):
        a = i//n
        b = i % n
        
        answer.append(max(a,b)+1)
        
    return answer

다른사람의 풀이

solution = lambda n, left, right: list((max(i // n, i % n) + 1 for i in range(left, right + 1)))

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 에 갱신 한 좌표를 마지막에 할당해줌으로서 이어나간다.

다른사람의 풀이