h32j00

문제

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

처음 작성한 코드

def solution(orders, course):
    from itertools import combinations
    answer = []
    for i in course:
        dic = {}
        for j in orders:
            for s in combinations(sorted(j),i):
                if ''.join(s) in dic.keys(): dic[''.join(s)] +=1
                else: dic[''.join(s)] = 1
        if not dic: continue
        maxNum = max(dic.items(), key = lambda x:x[1])[1]
        for x in dic.items():
            if x[1]==maxNum and maxNum>=2:
                answer.append(x[0])
    return sorted(answer)

1. orders를 돌면서 course 갯수만큼 combinations을 구한다.
2. dictionary 형 변수인 dic에 모든 조합을 넣을건데 이미 구한 조합에 있으면 count를 올리고 없으면 새로 추가할 것이다.
3. max의 key를 몇 번 사용됐는지 위에서 구한 값을 기준으로 하여 제일 많이 주문된 수를 maxNum에 저장한다.
4. dic을 돌면서 제일 많이 주문된 수와 같고 2번 이상 주문된 조합(메뉴조합)만 answer에 넣는다.

코드 리뷰 후

def solution(orders, course):
    from itertools import combinations
    from collections import Counter
    answer = []
    for i in course:
        dic = []
        for j in orders:
            for s in combinations(sorted(j),i):
                dic.append(''.join(s))
        dic = Counter(dic).most_common()
        maxNum = dic[0][1]
        for x in dic:
            if x[1]==maxNum and maxNum>=2:
                answer.append(x[0])
    return sorted(answer)

깨달은 점

• list를 Counter 하면 어떤 원소가 몇개있는지 dictionary 형태로 반환해준다. 만약 리스트가 ['a', 'a', 'c'] 라면 {'a':2, 'c':1} 이렇게 반환을 해주는데, Counter의 most_common()함수를 실행하면 제일 많이 사용한 순으로 정렬을 해준다.
• 재밌다 포헹

문제

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

처음 작성한 코드

def solution(expression):
    from itertools import permutations
    import re
    maxNum = -1
    number = list(map(int, re.findall('\d+', expression)))
    operator = re.findall('[-*+]', expression)
    priority = permutations(set(operator),len(set(operator)))

    for i in priority:
        number_ = list(map(int, re.findall('\d+', expression)))
        operator_ = re.findall('[-*+]', expression)
        for now in i:
            j = 0
            while True:
                if j == len(operator_): break
                if now == operator_[j]:
                    if now == '-':
                        tmp += number_[j] - number_[j+1]
                    elif now == '+':
                        tmp += number_[j] + number_[j+1]
                    else:
                        tmp += number_[j] * number_[j+1]
                    number_.pop(j+1)
                    number_.pop(j)
                    number_.insert(j,tmp)
                    operator_.pop(j)
                else: j+=1
        maxNum = max(maxNum, abs(number_[0]))
    return maxNum

1. permutation을 통해서 우선순위를 정하고 우선순위 리스트(priority)를 돌면서 현재 수식의 부호를 계산해준다.
2. number와 operator에 차례대로 수와 부호를 뽑아냈기 때문에 첫 부호는 첫 수와 그 다음 수에 영향을 미친다. 즉, operator[i] 는 number[i]와 number[i+1] 에 영향을 미치기 때문에 그에 대한 계산을 진행하고 number에 i와 i+1 번째 수를 제거하고 i번째에 계산된 수를 집어넣었다. operator에서도 현재 계산에 사용한 부호는 pop을 이용해 제거했다.
3. 모든 부호를 다 사용하여 계산을 하면 number에는 숫자가 하나만 남기때문에 현재 max 값과 number[0]값을 비교하여 더 큰 수를 maxNum에 저장한다.

코드 리뷰 후

def solution(expression):
    from itertools import permutations
    import re
    maxNum = -1
    number = list(map(int, re.findall('\d+', expression)))
    operator = re.findall('[-*+]', expression)
    priority = permutations(set(operator),len(set(operator)))

    for i in priority:
        number_ = number[:]
        operator_ = operator[:]
        for now in i:
            j = 0
            while True:
                if j == len(operator_): break
                if now == operator_[j]:
                    tmp = eval(str(number_[j])+now+str(number_[j+1]))
                    number_.pop(j+1)
                    number_.pop(j)
                    number_.insert(j,tmp)
                    operator_.pop(j)
                else: j+=1
        maxNum = max(maxNum, abs(number_[0]))
    return maxNum

깨달은 점

• 포문 도는 리스트에서 pop과 같은 연산을 해서 리스트의 길이가 변하면 포문 도는데 문제가 생긴다. 그래서 다른 조치를 취해서 돌아야 하는데 처음에 a_ = a 이런식으로 초기화를 했는데 디버깅하면서 돌렸는데 a_도 바뀌고 a도 바뀌더라.. 그래서 알게된 것이 a_ = a[:] 이렇게 하면 a의 값만 a_가 받아와서 도는 것 같다. 그냥 a_ = a 하면 포인터마냥 주소를 받아오는건가? 큼큼.. 하여튼 꿀팁!! a_ = a[:] 로 초기화하자.
• eval(string) 을 알게되었다. string에 수식을 적으면 그 수식대로 실행해서 값을 준다. eval("3+4")를 하면 7을 반환해준다. 그래서 이를 사용해서 코드를 깔끔하게 바꿀 수 있었다.

문제

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

처음 작성한 코드

def solution(skill, skill_trees):
    answer = 0
    for i in skill_trees:
        tmp = []
        flag = 1
        for j in skill:
            if j in i:
                if tmp:
                    if tmp[-1] > i.index(j):
                        flag = 0
                        break
                tmp.append(i.index(j))
            else:
                tmp.append(len(i))
        if flag:
            answer+=1
    return answer

1. skill을 still_trees에서 찾고 그 인덱스를 저장해뒀다가 비교후에 tmp에 넣는다. 만약 B의 인덱스보다 C의 인덱스가 뒤에 있다면 B를 먼저 배우게 되니까 조건에 충족되지 못하기 때문에 flag를 0으로 하고 break를 하여 tmp에 추가하지 않는다.
2. if j in i 의 else에 tmp.append(len(i))를 한 이유는 CD와 같은 스킬트리를 막기 위해서이다. 스킬이 스킬트리에 없으면 length를 넣어서 비교할 때 if문에 항상 참이되도록 하여 break 하기 위해서 코드를 작성했다.

코드 리뷰 후

def solution(skill,skill_trees):
    from collections import deque
    answer = 0
    for i in skill_trees:
        skillList = deque(skill)
        for j in i:
            if j in skill:
                if skillList.popleft() != j: break
        else: answer+=1
    return answer

1. 스킬트리를 돌면서 스킬트리가 스킬에 있고, 스킬의 맨 앞 즉 순서대로 존재하면 answer+=1 하는 식으로 작성했다.

깨달은 점

• for-else 좋다.
• 처음 작성한 코드랑 다른 사람의 코드 로직이 완전 반대이다. 신기하다.. 

문제

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

처음 작성한 코드

def solution(msg):
    di = dict()
    answer = []
    k = 26
   	for i in range(k):
        di[chr(65+i)] = i+1
    i = 0
    while True:
        tmp = ''
        for j in range(i,len(msg)):
            if msg[i:j+1] in di.keys():
                tmp = msg[i:j+1]
            else:
                di[msg[i:j+1]] = k+1
                k+=1
                answer.append(di[tmp])
                i += len(tmp)
                break
        else:
            answer.append(di[tmp])
            break
    return answer

코드 리뷰 후

def solution(msg):
    answer = []
    k = 26
    di = {chr(65+i):i+1 for i in range(k)}
    i = 0
    while True:
        tmp = ''
        for j in range(i,len(msg)):
            if msg[i:j+1] in di.keys():
                tmp = msg[i:j+1]
            else:
                di[msg[i:j+1]] = k+1
                k+=1
                answer.append(di[tmp])
                i += len(tmp)
                break
        else:
            answer.append(di[tmp])
            break
    return answer

깨달은 점

• dictionary도 리스트 초기화하듯 초기화할 수 있다.
• 2단계치고 쉽길래 풀었는데 역시나 점수가 2점인 쉬운 문제였다~

문제

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

처음 작성한 코드

def solution(relation):
    from itertools import combinations
    tupleNum = len(relation)
    attributeNum = len(relation[0])
    relation = list(map(list, zip(*relation)))
    result = []
    for i in range(attributeNum):
        allCombi = combinations(range(attributeNum),i+1)
        for j in allCombi:
            tmp = []
            for k in j:
                tmp.append(relation[k])
            if len(set(zip(*tmp))) == tupleNum:
                for ret in result:
                    if set(ret).issubset(set(j)):
                        break
                else:
                    result.append(j)
    return len(result)

1. relation에 같은 열을 묶은 배열들을 저장한다. -> 예시에서 학번은 학번끼리, 이름은 이름끼리 이런식으로..
2. attribute수를 인덱스로 하여 가능한 모든 조합을 뽑아낸다. -> 0, 1, 2, 3 , (0,1), (0,2) .. 이런식으로
3. relation[k]로 접근을 하면 k가 0일땐 tmp에 학번을 모아둔 리스트가 저장이 된다. 조합이 0,1일때는 학번리스트와 이름 리스트가 저장이 된다.
4. zip(*tmp)를 통해 같은 열의 값들을 묶어주고 set으로 중복을 제거하여 기존의 tupleNum과 같아지면 유일성이 입증된다.
5. result에는 최소성을 만족하는 조합들이 들어가있는데 result에 현재 조합에서의 하나의 값이라도 들어가있으면.. 즉 만약 result에 0이 있고 현재 조합이 0,1 이라면 조합 중 하나의 값인 0이 result에 있기 때문에 if 절에 걸려 break가 되어 result에 append 되지 않을 것이다. 이런 방식으로 최소성을 입증한다.

깨달은 점

• zip()은 크기가 같은 리스트들에서 같은 인덱스에 있는 값들을 뽑아준다.

• zip(list1,list2,list3) 이렇게도 사용할 수 있지만 list1,list2,list3이 2차원 배열로 하나의 변수 a에 저장되어 있다면 zip(*a) 이렇게 사용할 수 있다. -> 같은 열에 있는 값들을 뽑아서 저장할 때 유용하다.

• python에서는 부분집합인지 아닌지를 체크해주는 함수인 issubset()이 있다. 

• a = {1,2,3}, b = {1} 일 때, b는 a의 부분집합이다. b is subset of a 의 의미로 b.issubset(a)라고 쓰면 True를 반환한다.

• python에는 for-else문이 존재한다.

• for문을 다 돌고 break가 되지 않으면 else 문으로 간다. 위 코드에서 보면 if 절에 걸려서 break가 안될 경우는, result가 빈 리스트거나 다 돌았는데 부분집합이 아니거나 로 둘 중 하나이다. 그러면 그때 else로 가서 append를 해주는 것이다.

• 로직상 어렵지않은 문제였는데 파이썬 문법을 잘 몰라서인지 시간이 오래걸렸다.. 문법을 모른다는건 핑계겠지? 푸헹~ 다시 짜라하면 못짤거같다 푸헹~~

문제

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

처음 작성한 코드

def solution(record):
    answer = []
    person = {}
    for i in record:
        rec = i.split()
        if len(rec)==3:
            person[rec[1]]=rec[2]

    for i in record:
        rec = i.split()
        if rec[0]=='Enter':
            answer.append(person[rec[1]]+'님이 들어왔습니다.')
        elif rec[0]=='Leave':
            answer.append(person[rec[1]]+'님이 나갔습니다.')
    return answer

깨달은 점

• dictionary를 이용하여 풀었다. key:value 형태라 접근하기도 편하고 삽입, 수정도 편하다.
• 2단계치고 쉬웠던 것 같다.

문제

1. 입력이 빈 문자열인 경우, 빈 문자열을 반환합니다. 
2. 문자열 w를 두 "균형잡힌 괄호 문자열" u, v로 분리합니다. 단, u는 "균형잡힌 괄호 문자열"로 더 이상 분리할 수 없어야 하며, v는 빈 문자열이 될 수 있습니다. 
3. 문자열 u가 "올바른 괄호 문자열" 이라면 문자열 v에 대해 1단계부터 다시 수행합니다. 
  3-1. 수행한 결과 문자열을 u에 이어 붙인 후 반환합니다. 
4. 문자열 u가 "올바른 괄호 문자열"이 아니라면 아래 과정을 수행합니다. 
  4-1. 빈 문자열에 첫 번째 문자로 '('를 붙입니다. 
  4-2. 문자열 v에 대해 1단계부터 재귀적으로 수행한 결과 문자열을 이어 붙입니다. 
  4-3. ')'를 다시 붙입니다. 
  4-4. u의 첫 번째와 마지막 문자를 제거하고, 나머지 문자열의 괄호 방향을 뒤집어서 뒤에 붙입니다. 
  4-5. 생성된 문자열을 반환합니다.

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

처음 작성한 코드

def two(v):
    open_b = []
    close_b = []
    for i in range(len(v)):
        if v[i]=='(':
            open_b.append(v[i])
        else:
            close_b.append(v[i])
        if len(open_b) == len(close_b):
            ru = v[:i+1]
            rv = v[i+1:]
            return ru,rv

def right(u):
    open_b = []
    u = [i for i in u]
    for i in u:
        if i == ')':
            if not open_b:
                return False
            open_b.pop()
        else:
            open_b.append(i)
    if not open_b:
        return True

def solution(w):
    if w=='':
        return w
    u, v = two(w)
    if right(u):
        return u + solution(v)
    else:
        ret = '(' + solution(v)+')'
        u = [i for i in u[1:-1]]
        for i in range(len(u)):
            if u[i]=='(': u[i]=')'
            else: u[i]='('            
        ret += ''.join(u)
        return ret

코드 리뷰 후

def two(v):
    c = 0
    for i in range(len(v)):
        if v[i]=='(': c+=1
        else: c-=1
        if c == 0 :
            return v[:i+1], v[i+1:]
            
def right(u):
    c = 0
    for i in u:
        if i=='(': c+=1
        else: c-=1
        if c < 0: return False
    if c == 0: return True

def solution(w):
    if w=='':
        return w
    u, v = two(w)
    if right(u):
        return u + solution(v)
    else:
        ret = '(' + solution(v)+')'
        ret += ''.join(list(map(lambda x: '(' if x==')' else ')',u[1:-1])))
        return ret

깨달은 점

• lambda의 활용을 아직 못하는 것 같다.
• map()의 활욜을 아직 잘 못하는 것 같다. map(함수, 함수의 적용 대상)
• 처음 풀 때 list를 적용해서 좀 어렵게? 복잡하게? 풀었는데 다른 사람들 코드를 보니 count로만 해서 풀었다. 아참참~ 그런 방법이 있었네! 했다.
• 사실 처음에 문제에 있는 알고리즘 보고 이해 못했는데 그냥 알고리즘대로 코드를 작성했더니 통과했다.. 사실 지금도 알고리즘대로 하면 올바른 괄호 문자열이 되는 이유는 잘 모른다.. 그냥 하란대로 했다~

문제

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

처음 작성한 코드

def solution(s):
    mini = len(s)
    s = [''.join(list(i)) for i in s]
    for i in range(1,len(s)+1):
        ans = ''
        cnt = 1
        for idx in range(0,len(s),i):
            now = ''.join(s[idx:idx+i])
            if s[idx:idx+i]==s[idx+i:idx+i+i]:
                cnt += 1
                continue
            else:
                if cnt > 1:
                    ans += str(cnt)
                    cnt = 1
                ans += now
        mini = min(mini,len(ans))
    return mini

1. 문자열을 1개 단위로 자르는 거 부터해서 len(s)개 단위까지 자르는 포문을 돌면서 진행했다.
2. 현재 문자열과 다음 문자열이 같으면 cnt를 증가시키고
3. 다를 시, cnt+반복된문자열 이렇게 새로운 문자열에 저장시켜놓고 그 길이를 지금까지 구해둔 mini와 비교후 더 작은 값을 mini에 넣었다.

깨달은 점

• 문제를 풀 때, 처음부터 모든 경우를 풀 수 있는 로직을 짜지말고 최소한 단위를 작게하여 로직을 짜고 그걸 확장해나가는 방식으로 짜면 훨씬 수월하게 풀릴 때가 있는 것 같다.
• level 2 치고 쉬웠던 것 같다!

문제

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

처음 작성한 코드

def solution(m, n, board):
    from collections import deque
    answer = 0
    board = [list(i) for i in board]
    
    while True:
        flag = 0
        for i in range(m-1):
            for j in range(n-1):
                if board[i][j]!='_' and board[i][j].upper() == board[i][j+1].upper() == board[i+1][j].upper() == board[i+1][j+1].upper():
                    board[i][j] = board[i][j].lower()
                    board[i][j+1] = board[i][j+1].lower()
                    board[i+1][j] = board[i+1][j].lower()
                    board[i+1][j+1] = board[i+1][j+1].lower()
                    flag = 1
        
        if flag == 0: return answer
        
        for j in range(n):
            cnt = 0
            lower = deque()
            upper = deque()
            for i in range(m):
                if board[i][j].islower():
                    board[i][j] = '_'
                    lower.append(board[i][j])
                    cnt+=1
                else:
                    upper.append(board[i][j])
            
            index = 0
            while lower:
                board[index][j] = lower.popleft()
                index+=1
            while upper:
                board[index][j] = upper.popleft()
                index+=1
            
            answer += cnt

1. 4개가 모여 지워진 블록은 '_'로 변경했다.
2. 처음에 board를 돌면서 4개가 같으면 그 값들을 모두 소문자로 변경시켰다. -> 비교할 땐 대문자로 바꿔서..
3. flag 변수를 통해 더이상 같은 4개가 없으면 answer를 return하며 함수를 종료시켰다.
4. 세로를 돌면서 소문자라면 lower에 넣고('_'로 변환시킨 후) 아니면 upper에 넣었다. -> upper는 아직 안 지워진 블록이기 때문에 다음 턴에서 바닥에 깔리고 그 위에가 '_'로 깔려야한다.
5. while로 lower를 먼저 도는 이유는 인덱스가 0부터기 때문에 위에는 _로 깔리고 밑에가 영어로 깔리는게 당연하기 때문에 lower를 먼저 채웠다.
6. 4번에서 소문자라면 cnt를 1씩 증가하고 소문자의 갯수(==지워진 블록)를 cnt로 증가시켰기 때문에 answer에 cnt를 더했다.

깨달은 점

• string.islower()하면 소문자인지 대문자인지 체크해준다.
• c언어와는 다르게 a == b == c == d 이런식으로 2개 이상 비교가 가능하다.
• 간단한 문제였지만 접근하는 데 오래 걸린 것 같다. 푸헹