h32j00

문제

* [조건]을 만족하는 사람 중 코딩테스트 점수를 X점 이상 받은 사람은 모두 몇 명인가?

programmers.co.kr/learn/courses/30/lessons/72412

처음 작성한 코드 (효율성 미통과)

def solution(info, query):
    answer = [0]*len(query)
    info = [i.split() for i in info]
    query = [i.replace(" and",'').split() for i in query]
    for i in range(len(query)):
        for j in info:
            for k in zip(query[i][:-1],j[:-1]):
                if '-' not in k:
                    if k[0] != k[1]:
                        break
            else: 
                if int(query[i][-1]) <= int(j[-1]):
                    answer[i]+=1
        
    return answer

깨달은 점

• 효율성 통과 못했다..
• 정확성은 다 했는데..

문제

1단계 new_id의 모든 대문자를 대응되는 소문자로 치환합니다.
2단계 new_id에서 알파벳 소문자, 숫자, 빼기(-), 밑줄(_), 마침표(.)를 제외한 모든 문자를 제거합니다.
3단계 new_id에서 마침표(.)가 2번 이상 연속된 부분을 하나의 마침표(.)로 치환합니다.
4단계 new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
5단계 new_id가 빈 문자열이라면, new_id에 "a"를 대입합니다.
6단계 new_id의 길이가 16자 이상이면, new_id의 첫 15개의 문자를 제외한 나머지 문자들을 모두 제거합니다.
     만약 제거 후 마침표(.)가 new_id의 끝에 위치한다면 끝에 위치한 마침표(.) 문자를 제거합니다.
7단계 new_id의 길이가 2자 이하라면, new_id의 마지막 문자를 new_id의 길이가 3이 될 때까지 반복해서 끝에 붙입니다.

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

처음 작성한 코드

def solution(new_id):
    import re
    new_id = ''.join(re.findall('[a-z0-9-_.]',new_id.lower()))
    while True:
        new_id = new_id.replace('..','.')
        if new_id.find("..") == -1: break
    new_id = list(new_id)
    if new_id[0] == '.': (new_id).pop(0)
    if new_id:
        if new_id[-1] == '.': (new_id).pop()
    if not new_id: new_id.append('a')
    if len(new_id)>=16:
        new_id = new_id[:15]
        if new_id[-1]=='.': new_id.pop()
    if len(new_id)<=2:
        last = new_id[-1]
        while len(new_id)<3:
            new_id.append(last)    
    return ''.join(new_id)

코드 리뷰 후

def solution(new_id):
    import re
    new_id = re.sub('[^a-z0-9\-_.]','',new_id.lower())
    new_id = re.sub('\.+','.',new_id)
    new_id = re.sub('^[.]|[.]$','',new_id)
    if not new_id: new_id = 'a'
    if len(new_id)>=16: new_id = new_id[:15]
    new_id = re.sub('[.]$','',new_id)
    if len(new_id)<=2:
        last = new_id[-1]
        while len(new_id)<3:
            new_id += last
    return new_id

깨달은 점

• re.sub(정규식, 대체할 문자열, 대체될 문자열) 로 쓸 수 있다.
• ^[문자열] -> 문자열로 시작
• [문자열]$ -> 문자열로 끝
• '\d+' -> 0-9까지의 수가 여러번 나옴
• '\.+' -> .이 여러번 나옴

문제

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로만 해서 풀었다. 아참참~ 그런 방법이 있었네! 했다.
• 사실 처음에 문제에 있는 알고리즘 보고 이해 못했는데 그냥 알고리즘대로 코드를 작성했더니 통과했다.. 사실 지금도 알고리즘대로 하면 올바른 괄호 문자열이 되는 이유는 잘 모른다.. 그냥 하란대로 했다~