▶ 문제 : https://programmers.co.kr/learn/courses/30/lessons/64062

▶ 이분탐색을 이용해서 풀이한다. 

▶ 정규표현식으로 "0이 연속된 개수" 구하면 시간초과 !

▶ 이분탐색 코드 (정답)

# 건널 수 없는 경우가 있으면 false -> 이때, mid값을 줄여줘야됨 
# 건널 수 없는 경우가 없으면 true  -> 이때, mid값을 키워줘야됨 
def isPossible(stones, k, mid):
    disappearedStones = 0
    
    for s in stones:
        if s - mid <= 0:
            disappearedStones += 1
            if disappearedStones == k: # disappearedStones이 연속해서 k개가 나오면, False
                return False 
        else:
            disappearedStones = 0
            
    return True
 
    
def solution(stones, k):
    answer = 0
    
    left = 1
    right = 200000000 # stones의 원소값은 1 ~ 200,000,000
    
    while left <= right:
        mid = (left + right) // 2
        print('[left, right, mid]=', left, right, mid)
        
        if isPossible(stones, k, mid):
            print('>[true]')
            left = mid + 1 # mid값을 키워야 되니까, 반갈죽에서 오른쪽 택하겠다 
        else:
            print('>[false]')
            answer = mid # false일때, mid값으로 answer를 업데이트 해나간다.
                         # mid값(=빼야할 숫자)이 결국, 다리를 건넌 사람수와 동일 !
                         # Why? 문제의 조건 : 한명 건널때마다 전체 1씩 감소시키는 조건
            right = mid - 1 # mid값을 줄여야 되니까, 반갈죽에서 왼쪽 택하겠다

    print(answer)
    return answer


solution([2, 4, 5, 3, 2, 1, 4, 2, 5, 1], 3)

(정답 참조 : https://hellominchan.tistory.com/262)

문제 : https://programmers.co.kr/learn/courses/30/lessons/64064?language=python3

▶ 코드

import re
from itertools import product

def solution(user_id, banned_id):
    # 1.정규표현식 매칭하기 
    my =[]
    for p in banned_id:
        temp = []
        p = p.replace('*','.')
        for a in user_id:
            res = bool(re.match(p, a))
            if (res and len(p)==len(a)):
                temp.append(a)
        my.append(temp)
    #print(my)

    # 2.조합 구하기 
    lst = list(product(*my))
    #print(lst)

    answer = []
    for a in lst:
        if len(a) == len(set(a)):
            tmp_lst = list(a)
            tmp_lst.sort()
            #print(tmp_lst)
            if tmp_lst not in answer:
                answer.append(tmp_lst)

    #print(len(answer))
    return len(answer)
    
#solution(["frodo", "fradi", "crodo", "abc123", "frodoc"],["fr*d*", "abc1**"])
#solution(["frodo", "fradi", "crodo", "abc123", "frodoc"], ["*rodo", "*rodo", "******"])

문제 : https://programmers.co.kr/learn/courses/30/lessons/64065

▶ 코드

# 문자열 문제 

def solution(s):
    s = s[1:-1]
    s = s.replace('{','[')
    s = s.replace('}',']')
    #print(s)
    s = s[1:-1]
    s = s.split('],[')
    #print(s)
    s = sorted(s, key=lambda t: (len(t)))
    #print(s)
    #print()

    temp = []
    for a in s:
        temp.append(a.split(','))
    #print(temp)
    #print()
    
    result = []
    for a in temp:
        for b in a:
            if b not in result:
                result.append(b)
    #print(result)

    result = list(map(int, result))
    #print(result)

    return result
            
#solution("{{2},{2,1},{2,1,3},{2,1,3,4}}")
#solution("{{1,2,3},{2,1},{1,2,4,3},{2}}")
#solution("{{20,111},{111}}")
#solution("{{123}}")
#solution("{{4,2,3},{3},{2,3,4,1},{2,3}}")

문제 : https://programmers.co.kr/learn/courses/30/lessons/64061

▶ 코드

def solution(board, moves):
    n = len(board)
    p = [[] for i in range(n)] # 1번~N번 세로라인 배열 
    
    for i in range(n):
        for j in range(n):
            if board[i][j]!=0:
                p[j].append(board[i][j]) # 각 N번째 라인에 담아주기

    # 각 N번째 라인의 원소 순서 뒤집기 
    for a in p:
        a.reverse()
                
    my = [] # 뽑힌것 담을 배열 
    c = 0
    for a in moves:
        if len(p[a-1]) > 0:
            if len(my)>0 and p[a-1][-1] == my[-1]:
                my = my[:-1]
                p[a-1].pop()
                c += 1
            else:
                my.append(p[a-1].pop())
    #print(my)
    
    return c*2