내 인생 이대로 ㅈ될 수 없다

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/17680?language=python3 

내 풀이

from collections import deque

def solution(cacheSize, cities):
    time=0
    cache = deque()
    
    cities=[i.lower() for i in cities]
    
    
    for i in cities:
        if len(cache) <cacheSize:
            if i in cache:
                time +=1
                cache.append(i)
                cache.remove(i)
            else:
                cache.append(i)
                time+=5
        else:
            if i in cache:
                time+=1
                cache.append(i)
                cache.remove(i)
                
            else:
                cache.append(i)
                cache.popleft()
                time+=5
        
        
        
                
            
    return time

다른사람의 풀이

def solution(cacheSize, cities):
    import collections
    cache = collections.deque(maxlen=cacheSize)
    time = 0
    for i in cities:
        s = i.lower()
        if s in cache:
            cache.remove(s)
            cache.append(s)
            time += 1
        else:
            cache.append(s)
            time += 5
    return time

maxlen으로 길이를 정해줄수있다는것을 배웠다.

https://programmers.co.kr/learn/courses/30/lessons/67256

def solution(numbers,hand):
    answer=''
    Left_current = 10
    Right_current = 12
    for x in numbers:
        if x==1 or x==4 or x==7:
            answer +='L'
            Left_current = x
        elif x==3 or x==6 or x==9:
            answer +='R'
            Right_current = x
        else:
            if x==0:
                x=11
                
            Ldis = abs(Left_current-x) //3 + abs(Left_current-x) %3
            Rdis = abs(Right_current-x) //3 + abs(Right_current-x) %3
            if Ldis > Rdis:
                answer +='R'
                Right_current = x
            elif Ldis < Rdis:
                answer +='L'
                Left_current =x
            else:
                if hand=='right':
                    answer +='R'
                    Right_current=x
                else:
                    answer+='L'
                    Left_current=x
    return answer

문제를 처음봤을 때 느낀점은 귀찮겠다.. 였다

이 풀이의 중점은 특수문자를 숫자로 치환한다는거다.

또 그걸이용해서 키패드 간의 거리를 나타낼 수 있다

1 2 3

4 5 6

7 8 9

10 11 12

이런식으로 치환하는것이다.

그렇다면 여기서 거리는 어떻게 구할 수 있을까?

각 키패드간의 거리는 무조건 1이라고 했으니까

각 키패드를 x,y값으로 생각하고 x값의 차 + y값의 차 = 키패드간의 거리가 된다.

그럼 키패드간의 거리는 어떻게 구할 수 있을까?

특성을 생각하면 간단하게 구할 수 있는데

예를들어서 1열을 예로들어보면

1 4 7 10 이다.

이는 3으로 나눴을때 몫이 +1씩 증가하는 규칙을 가지고 있다.

1//3=0 4//3=1 7//3=2 10//3=3

또 1행을 예로 들어서보면

1 2 3 인데 얘들은 3으로 나눴을때 나머지가 1 2 0 을 반복하는 형태로 나온다.

1%3=1 2%3=2 3%3=0

고로 이를 정리해보면 키패드간의 거리는

두 넘버패드의 거리차이 //3 + 두 넘버패드의 거리차이 %3 으로 정리할수 있겠다

가령

현재 왼손이 7,오른손이 6 목표가 2라고하면

abs((7-2)) // 3 + abs((7-2)) %3  = 1 + 2 = 3

왼손과 다음목표까지의 거리=3

abs((6-2))//3 + abs((6-2))%3 = 1 + 1 = 2

오른손과 다음목표까지의 거리 =2

따라서 오른손이 더 가까움을 알 수 있다.

https://programmers.co.kr/learn/courses/30/lessons/72410

내 풀이

from string import punctuation


def solution(new_id):
    new_id=new_id.lower()
    
    symbols=punctuation.replace('-','').replace('_','').replace('.','') 
    
    for symbol in symbols:
              new_id = new_id.replace(symbol,'')
    while '..' in new_id:
         new_id = new_id.replace('..','.')
    if new_id.startswith('.') or new_id.endswith('.'):
        new_id=new_id.strip('.')
    if not new_id:
        new_id='a'
    if len(new_id) >=16:
        new_id=new_id[:15]
        if new_id[-1]=='.':
            new_id=new_id[:-1]
    
    while len(new_id)<3:
          new_id += new_id[(len(new_id)-1)]   
    return new_id

다른사람의 풀이

import re

def solution(new_id):
    st = new_id
    st = st.lower()
    st = re.sub('[^a-z0-9\-_.]', '', st)
    st = re.sub('\.+', '.', st)
    st = re.sub('^[.]|[.]$', '', st)
    st = 'a' if len(st) == 0 else st[:15]
    st = re.sub('^[.]|[.]$', '', st)
    st = st if len(st) > 2 else st + "".join([st[-1] for i in range(3-len(st))])
    return st

정규식 연습하기 제일 좋은 문제라고 생각했는데 자꾸 테스트케이스 하나가 오류가 나서 포기하고 저렇게 풀었다.

두번째는 정규식으로 푼 모범답안

정규식을 알면 굉장히 쉽고 이쁘게 풀린다는걸 알 수 있다.

punctuation 라는 모듈은 특수모음 모음집이다.

punctuation안에 -,_ 를 공백으로 대체해서 걔내 들은 빼고 검사한 거다. 나름 이쁘게 풀었다고 생각했는데 역시 정규식이 짱이였다.

https://programmers.co.kr/learn/courses/30/lessons/92334

def solution(id_list, report, k):
    answer = [0] * len(id_list)    
    reports = {x : 0 for x in id_list}

    for r in set(report):
        reports[r.split()[1]] += 1

    for r in set(report):
        if reports[r.split()[1]] >= k:
            answer[id_list.index(r.split()[0])] += 1

    return answer

https://programmers.co.kr/learn/courses/30/lessons/81301