내 인생 이대로 ㅈ될 수 없다

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

내 풀이

c++에서 처음 스택 배우면 한번씩은 해보는 괄호 맞추기다.

거기에 좀 변형되긴 했는데 하라는대로 하면 쉽게 풀리는 문제였다.

다른사람의 풀이

def solution(p):
    if p=='': return p
    r=True; c=0
    for i in range(len(p)):
        if p[i]=='(': c-=1
        else: c+=1
        if c>0: r=False
        if c==0:
            if r:
                return p[:i+1]+solution(p[i+1:])
            else:
                return '('+solution(p[i+1:])+')'+''.join(list(map(lambda x:'(' if x==')' else ')',p[1:i]) ))

사고가 아직 파이써닉 하지 못한거같다. 특히 람다로 표현한 리턴값은 예술이다.

마지막 학년이기도하고, 인턴 준비에 서류도내고, 기말준비, 거기다 7월에 있을 정처기 자격증까지 준비한다고 

'적어도'  하루에 한개는 문제를 푸려고했던 계획을 하나도 지키지 못하고 있다.

2학년 3학년 때 논것을 땅을 치고 후회한다.. 좀 열심히 살걸

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

내 풀이

다른사람의 풀이

from itertools import combinations
from collections import Counter
def solution(orders,course):
    answer=[]

    for i in course:
        candi =[]
        for menu_li in orders:
            for li in combinations(menu_li,i):
                res =''.join(sorted(li))
                candi.append(res)
        sort_candi = Counter(candi).most_common()
        answer +=[menu for menu,cnt in sort_candi if cnt >1 and cnt == sort_candi[0][1]]


    return sorted(answer)

이번 풀이는 막혀서 구글링을 좀 했다.

우선 이번 문제에서의 가장 큰 소득은

        answer +=[menu for menu,cnt in sort_candi if cnt >1 and cnt == sort_candi[0][1]]

이 부분일거같은데 

https://velog.io/@singco/Programmers-%EB%A9%94%EB%89%B4-%EB%A6%AC%EB%89%B4%EC%96%BC 

자세한 설명은 참조한 블로그를 첨부한다.

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

내 풀이

def solution(rows,columns,queries):
    arr = [[(i)*columns+(j+1) for j in range(columns)] for i in range(rows)] //초기화
    answer=[]
    for x,y,x1,y1 in queries:
        tmp = arr[x-1][y-1] //0부터 시작하기때문에 x-1 y-1로 처리해줘야 한다.
        mini = tmp //최초 시작시에 처음 시작점이 최소값이기에 최초의 최소값을 처음 시작점으로 줬다.

        for i in range(x-1,x1-1):
            arr[i][y-1]=arr[i+1][y-1]       
            mini = min(arr[i][y-1],mini)
        for i in range(y-1,y1-1):
            arr[x1-1][i]=arr[x1-1][i+1]
            mini = min(arr[x1-1][i],mini)
        for i in range(x1-1,x-1,-1):
            arr[i][y1-1] = arr[i-1][y1-1]
            mini = min(arr[i][y1-1],mini)
        for i in range(y1-1,y-1,-1):
            arr[x-1][i] = arr[x-1][i-1]
            mini = min(arr[x-1][i],mini)

        arr[x-1][y]=tmp
        answer.append(mini)
    return answer

다른사람의 풀이

def solution(rows, columns, queries):
    answer = []

    board = [[i+(j)*columns for i in range(1,columns+1)] for j in range(rows)]
    # print(board)

    for a,b,c,d in queries:
        stack = []
        r1, c1, r2, c2 = a-1, b-1, c-1, d-1


        for i in range(c1, c2+1):

            stack.append(board[r1][i])
            if len(stack) == 1:
                continue
            else:
                board[r1][i] = stack[-2]


        for j in range(r1+1, r2+1):
            stack.append(board[j][i])
            board[j][i] = stack[-2]

        for k in range(c2-1, c1-1, -1):
            stack.append(board[j][k])
            board[j][k] = stack[-2]

        for l in range(r2-1, r1-1, -1):
            stack.append(board[l][k])
            board[l][k] = stack[-2]

        answer.append(min(stack))


    return answer

본질적으로 푸는 방법은 다 비슷한거 같다.

처음에는 그냥 최소값을 구하기만 하고 돌았을 때 값을 갱신시켜주지 않았는데

그러면 겹치는 경우에 처리를 못하니까 결국 한번 돌때마다 값을 갱신시켜줘야한다.

한줄 한줄 갱신시켜주기가 애매해서 최초에는 값 전체를 다 한번에 갱신시켜주려고 했다.

문제에 일반항이 나와있었기 때문에 갱신시키는 거 자체는 문제가 없었는데 문제는 다중처리하기가 애매했다.

그래서 그냥 한줄 한줄 갱신하는 식으로 바꿨는데 시간이 나면 한번에 전체를 갱신하는 방향으로 시도해보려고 한다

그게 코드도 훨씬 짧고 간결해질거같아서.

https://programmers.co.kr/learn/courses/30/lessons/12973#

내 풀이

def solution(s):
    answer =[]

    for i in range(len(s)):
        if s[i] in answer:
            if s[i]==answer[-1]:
                answer.pop()
            else:
                answer.append(s[i])
        else:
            answer.append(s[i])

    if len(answer) ==0:
        return 1
    else:
        return 0    

딱히 할말은 없고.. 보자마자 스택이 생각나서 스택으로 풀어본 문제이다.

다만 자꾸 list range 오류가 많이난다. 조심해야할거 같다.

다른사람의 풀이

def solution(s):
    answer = []
    for i in s:
        if not(answer):
            answer.append(i)
        else:
            if(answer[-1] == i):
                answer.pop()
            else:
                answer.append(i)    
    return not(answer)

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

내 풀이

import heapq as hp
def solution(scoville,K):
    count=0
    hp.heapify(scoville)
    
    while (scoville[0]) < K:
        hp.heappush(scoville, hp.heappop(scoville) + hp.heappop(scoville) * 2)
        count +=1
        
        
        if len(scoville) ==1 and scoville[0]<K:
            return -1
        
        
    return count

밑에 if문 처리를 안해줘서 진짜 세시간은 고민했다.. 뭐가 잘못된거지 하고

요즘 코테를 풀다보면 예외처리를 안해줘서 틀리는 경우가 많은데 예외처리를 항상 좀 신경써줘야 할거같다.

다만 기존의 내 코드에서 조금 고친것은 heapify 라는 함수를 처음써봤다. 사실 이런게 있는지도 몰랐는데 꽤나 유용한거같다.

다른사람의 풀이

from heapq import heapify, heappush, heappop
def solution(scoville, K):
    heapify(scoville)
    for i in range(1000000):
        try:
            heappush(scoville, heappop(scoville)+(heappop(scoville)*2))
            if scoville[0] >= K: return i+1
        except:
            return -1

그런 의미에서 이분의 풀이가 깔끔하다고 느꼈다. 가장 좋아요를 많이받은 분 코드도 나쁘진 않지만 그냥 내 코드랑 비슷해서.. 

문제 자체가 어렵진 않은데 예외처리에 조금 더 신경을 쓰자.

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

내 풀이

def solution(progresses, speeds):
    answer=[]
    day=[]
    for i in range(len(progresses)):
        complete=100-progresses[i]
        if complete % speeds[i] !=0:
            days = (complete // speeds[i])+1
        else:
            days = (complete // speeds[i])
        day.append(days)
        
    tem=0
    for i in range(len(day)):
        if day[i] > day[tem]:
            answer.append(i-tem)
            tem = i
    answer.append(len(day)-tem)
        
          
        
    
    return answer

좀 어거지로 푼 감이 있는거 같다.

day안에 걸리는시간을 미리 계산해놓고(올림 했어도 괜찮았을거같다)

day[0],day[1].. 순서대로 나가야하니까 

작업순서가 빠르지만 작업 완료시점이 빠른건 바로 pop하면 된다.

반대로 작업순서가 빠르지만 작업 완료시점이 느린건 고려해줄 필요가 있었는데

작업순서가 빠른 일이 작업이 완료된 시점에는 당연히 작업순서가 느린 작업은 완료가 되어있으니까

그만큼 더해준다. 

다른사람의 풀이

def solution(progresses, speeds):
    Q=[]
    for p, s in zip(progresses, speeds):
        if len(Q)==0 or Q[-1][0]<-((p-100)//s):
            Q.append([-((p-100)//s),1])
        else:
            Q[-1][1]+=1
    return [q[1] for q in Q]

캬.. 이건 진짜 파이썬스럽다. 감탄이 나온다.