Barrer. better

99클럽 코테 스터디 32/99일차 TIL #리코쳇 로봇(미들러)

Barrer — Sat, 24 Aug 2024 10:47:48 +0900

문제 출처 : 프로그래머스

문제링크: https://school.programmers.co.kr/learn/courses/30/lessons/169199

from collections import deque

def solution(board):
    # 보드의 크기
    n, m = len(board), len(board[0])
    
    # 시작점과 목표점 찾기
    start = None
    goal = None
    for i in range(n):
        for j in range(m):
            if board[i][j] == 'R':
                start = (i, j)
            elif board[i][j] == 'G':
                goal = (i, j)
    
    # BFS 초기화
    queue = deque([(start[0], start[1], 0)])  # (x, y, 이동 횟수)
    visited = [[False] * m for _ in range(n)]
    visited[start[0]][start[1]] = True
    
    # 네 방향 (상, 하, 좌, 우)
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    
    while queue:
        x, y, dist = queue.popleft()
        
        # 목표에 도달한 경우
        if (x, y) == goal:
            return dist
        
        # 네 방향에 대해 이동 시도
        for dx, dy in directions:
            nx, ny = x, y
            
            # 장애물 또는 경계에 닿을 때까지 이동
            while 0 <= nx + dx < n and 0 <= ny + dy < m and board[nx + dx][ny + dy] != 'D':
                nx += dx
                ny += dy
            
            # 이동한 위치가 방문되지 않았을 경우 큐에 추가
            if not visited[nx][ny]:
                visited[nx][ny] = True
                queue.append((nx, ny, dist + 1))
    
    # 목표 지점에 도달하지 못한 경우
    return -1

99클럽 코테 스터디 30/99일차 TIL #점프점프(미들러)

Barrer — Thu, 22 Aug 2024 10:39:02 +0900

문제 출처: 백준

https://www.acmicpc.net/problem/14248

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

n = int(input().rstrip())
bridge = list(map(int, input().split()))
s = int(input().rstrip()) - 1  # 0-indexed로 변경
visited = [False] * n
cnt = 0

def dfs(x):
    global cnt
    visited[x] = True
    cnt += 1
    
    for direction in [1, -1]:
        nx = x + direction * bridge[x]
        if 0 <= nx < n and not visited[nx]:
            dfs(nx)

dfs(s)
print(cnt)

99클럽 코테 스터디 29/99일차 TIL #Find Right Interval(미들러)

Barrer — Wed, 21 Aug 2024 10:53:11 +0900

https://leetcode.com/problems/find-right-interval/description/

import bisect

def findRightInterval(intervals):
    n = len(intervals)
    # 구간의 시작점을 기준으로 정렬합니다.
    start_points = sorted((interval[0], i) for i, interval in enumerate(intervals))
    result = []
    
    for interval in intervals:
        # 현재 구간의 끝점을 기준으로 이진 탐색 수행
        end = interval[1]
        idx = bisect.bisect_left(start_points, (end,))
        
        # 만약 이진 탐색 결과가 리스트 길이보다 작다면, 해당 인덱스의 시작점이 구간의 끝점보다 큽니다.
        if idx < n:
            result.append(start_points[idx][1])
        else:
            result.append(-1)
    
    return result

99클럽 코테 스터디 29/99일차 TIL #이분탐색(미들러)

Barrer — Tue, 20 Aug 2024 10:33:46 +0900

https://leetcode.com/problems/longest-increasing-subsequence/description/

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
    # def lengthOfLIS(nums):
        if not nums:
            return 0
        
        dp = [1] * len(nums)
        
        for j in range(1, len(nums)):
            for i in range(j):
                if nums[j] > nums[i]:
                    dp[j] = max(dp[j], dp[i] + 1)
        
        return max(dp)

99클럽 코테 스터디 28/99일차 TIL #괄호 회전하기(미들러)

Barrer — Mon, 19 Aug 2024 10:08:59 +0900

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

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

]

def is_valid_bracket_string(s):
    stack = []
    bracket_map = {')': '(', ']': '[', '}': '{'}
    
    for char in s:
        if char in bracket_map.values():  # 여는 괄호
            stack.append(char)
        elif char in bracket_map.keys():  # 닫는 괄호
            if stack and stack[-1] == bracket_map[char]:
                stack.pop()
            else:
                return False
    return len(stack) == 0

def solution(s):
    valid_count = 0
    
    for i in range(len(s)):
        rotated_s = s[i:] + s[:i]  # 문자열을 왼쪽으로 i칸 회전
        if is_valid_bracket_string(rotated_s):
            valid_count += 1
    
    return valid_count

99클럽 코테 스터디 27/99일차 TIL #할인 행사(미들러)

Barrer — Sun, 18 Aug 2024 10:40:23 +0900

'''
일정 금액 지불 -> 10일간 회원
회원: 매일 한 가지 할인 -> 하루에 하나만 구매 가능
자신이 원하는 제품과 수량이 할인하는 날짜랑 10일 연속으로 일치할 경우 회원가입

discount=["chicken", "apple", "apple", "banana", "rice", "apple", "pork", "banana", "pork", "rice", "pot", "banana", "apple", "banana"]	
want=["banana", "apple", "rice", "pork", "pot"]	
number=[3, 2, 2, 2, 1]	
=> want_dict = dict(zip(want, number))


'''

from collections import Counter

def solution(want, number, discount):
    # 필요한 제품과 수량을 딕셔너리로 저장
    want_dict = dict(zip(want, number))
    days = len(discount) - 9  # 10일 연속 기간을 검사할 수 있는 시작 지점 수
    
    valid_days = 0
    
    for i in range(days):
        # 현재 10일간의 할인 제품 리스트
        current_window = discount[i:i+10]
        # 이 구간의 제품 수량을 카운트
        current_count = Counter(current_window)
        
        # 모든 제품이 원하는 수량만큼 있는지 확인
        if all(current_count[item] >= want_dict[item] for item in want_dict):
            valid_days += 1
    
    return valid_days

99클럽 코테 스터디 26/99일차 TIL #달리기 경주(미들러)

Barrer — Fri, 16 Aug 2024 12:09:41 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/178871

프로그래머스

programmers.co.kr

얀에서는 매년 달리기 경주가 열립니다. 해설진들은 선수들이 자기 바로 앞의 선수를 추월할 때 추월한 선수의 이름을 부릅니다. 예를 들어 1등부터 3등까지 "mumu", "soe", "poe" 선수들이 순서대로 달리고 있을 때, 해설진이 "soe"선수를 불렀다면 2등인 "soe" 선수가 1등인 "mumu" 선수를 추월했다는 것입니다. 즉 "soe" 선수가 1등, "mumu" 선수가 2등으로 바뀝니다.
선수들의 이름이 1등부터 현재 등수 순서대로 담긴 문자열 배열 players와 해설진이 부른 이름을 담은 문자열 배열 callings가 매개변수로 주어질 때, 경주가 끝났을 때 선수들의 이름을 1등부터 등수 순서대로 배열에 담아 return 하는 solution 함수를 완성해주세요.

자기 바로 앞의 선수를 추월할 때 추월한 선수의 이름 부름

해당 이름이 불리면 index를 한 칸 앞으로 당기기
1등은 불리지 않음

def solution(players, callings):
    
    
    for calling in callings:
        idx = players.index(calling)
        players.remove(calling)
        players.insert(idx-1, calling)        
        
    return players

시간 초과가 발생하는 이유는 players.index(calling)와 같은 리스트 연산이 호출될 때마다 리스트를 순회하기 때문입니다. index, remove, insert 같은 연산은 리스트의 길이에 비례하는 O(n)의 시간 복잡도를 가지기 때문에, 호출이 많아지면 전체 연산이 매우 느려질 수 있습니다.

이를 해결하기 위해 더 효율적인 방법을 사용해야 합니다. 여기서는 리스트와 딕셔너리를 함께 사용하여 문제를 해결하는 방법을 설명하겠습니다.

개선된 접근 방법

플레이어의 위치를 저장하는 딕셔너리 사용: 각 플레이어의 현재 인덱스를 기록하는 딕셔너리를 생성합니다. 이렇게 하면 특정 플레이어의 위치를 O(1) 시간 복잡도로 찾을 수 있습니다.
인덱스 업데이트: 호출된 플레이어와 그 앞에 있는 플레이어의 위치를 서로 바꿉니다.

def solution(players, callings):
   
    
    for calling in callings:
    
        idx = players.index(calling)

        players[idx], players[idx-1] = players[idx-1], players[idx]

    
    return players

리스트에서 index를 찾는 것 역시 O(n)의 연산 복잡도를 가지기 때문에 앞에 방식과 동일한 O(n)이므로 동일하게 시간초과 발생.

결국 여기서 남은언 index를 list의 함수를 쓰는 것이 아닌 다른 방법을 써야한다는 것.

그 중 가장 쉬운 방법이 dictionary를 사용하는 것이다.

def solution(players, callings):

    position = {player:i for i, player in enumerate(players)}
    
    for calling in callings:
        
        idx = position[calling]
        # players[idx]: current player 
        # players[idx-1]: ahead player 
        
        # players[idx]: ahead player 
        # players[idx-1]: current player 
        players[idx], players[idx-1] = players[idx-1], players[idx]
        
        # current player에 ahead player의 idx로 변경
        position[players[idx]] = idx
        # ahead player에 current player의 idx로 변경
        position[players[idx-1]] = idx-1
    
    
    return players

정확성 테스트

테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.01ms, 10.2MB)
테스트 3 〉	통과 (0.04ms, 10.3MB)
테스트 4 〉	통과 (0.29ms, 10.1MB)
테스트 5 〉	통과 (1.74ms, 10.6MB)
테스트 6 〉	통과 (5.89ms, 10.9MB)
테스트 7 〉	통과 (34.22ms, 14.3MB)
테스트 8 〉	통과 (52.48ms, 18.8MB)
테스트 9 〉	통과 (94.79ms, 27.8MB)
테스트 10 〉	통과 (277.24ms, 56.7MB)
테스트 11 〉	통과 (563.33ms, 91.6MB)
테스트 12 〉	통과 (552.90ms, 91.6MB)
테스트 13 〉	통과 (616.09ms, 91.5MB)
테스트 14 〉	통과 (0.01ms, 10.2MB)
테스트 15 〉	통과 (0.01ms, 10.3MB)
테스트 16 〉	통과 (0.01ms, 10MB)

채점 결과

정확성: 100.0

합계: 100.0 / 100.0

99클럽 코테 스터디 25/99일차 TIL #그래프(미들러)

Barrer — Fri, 16 Aug 2024 10:00:20 +0900

DFS(깊이 우선 탐색) 알고리즘: 기초 개념과 2D 그리드에서의 활용

깊이 우선 탐색(DFS, Depth-First Search)은 그래프나 트리에서 널리 사용되는 탐색 알고리즘이다. DFS는 시작 노드에서 출발해 가능한 한 깊이까지 탐색한 후, 더 이상 갈 곳이 없으면 이전 단계로 돌아와 다른 경로를 탐색하는 방식으로 동작한다. 이 글에서는 DFS의 기초 개념과 함께, 2D 그리드에서의 활용 방법을 설명한다.

1. DFS의 기본 개념

DFS는 그래프나 트리에서 주어진 시작 노드에서 출발하여 모든 노드를 방문하는 알고리즘이다. DFS는 일반적으로 재귀적으로 구현되며, 다음과 같은 기본 구조를 갖는다.

def dfs(graph, node, visited):
    visited.add(node)
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

위 코드에서 graph는 그래프를 나타내며, node는 현재 탐색 중인 노드를 의미한다. visited는 이미 방문한 노드를 추적하기 위한 집합(set)이다. DFS는 현재 노드를 방문 처리한 후, 연결된 모든 이웃 노드를 재귀적으로 탐색한다.

2. DFS의 2D 그리드에서의 활용

DFS는 2D 그리드에서도 유용하게 사용된다. 2D 그리드는 행(row)과 열(column)로 구성된 2차원 배열이며, 각 셀은 특정 좌표 (x, y)로 접근할 수 있다. DFS를 활용하여 그리드 내에서 특정 경로를 탐색하거나, 연결된 영역을 찾는 등의 작업을 수행할 수 있다.

2D 그리드에서의 DFS 구현은 다음과 같은 형태를 갖는다.

def dfs(grid, x, y, visited):
    if x < 0 or x >= len(grid) or y < 0 or y >= len(grid[0]):
        return
    if (x, y) in visited or grid[x][y] == '#':
        return
    
    visited.add((x, y))
    print(f"Visited: ({x}, {y})")
    
    dfs(grid, x + 1, y, visited)  # 아래로 이동
    dfs(grid, x - 1, y, visited)  # 위로 이동
    dfs(grid, x, y + 1, visited)  # 오른쪽으로 이동
    dfs(grid, x, y - 1, visited)  # 왼쪽으로 이동

이 코드는 그리드의 특정 좌표 (x, y)에서 출발하여 상하좌우로 이동하며 탐색을 진행한다. 방문한 셀은 visited 집합에 추가되어 다시 방문하지 않도록 한다.

3. 조건문을 통한 유효성 검사

DFS를 2D 그리드에서 사용할 때는 좌표의 유효성을 확인하는 것이 중요하다. 다음 조건문을 통해 그리드 범위를 벗어난 좌표나 이미 방문했거나 벽으로 표시된 셀에 대한 탐색을 중지할 수 있다.

if x < 0 or x >= len(grid) or y < 0 or y >= len(grid[0]):
    return

x < 0, y < 0: 그리드의 범위를 벗어난 좌표를 처리한다.
x >= len(grid), y >= len(grid[0]): 그리드의 오른쪽 경계 또는 아래쪽 경계를 벗어난 좌표를 처리한다.
이 조건문은 그리드 범위 내에서만 탐색이 이루어지도록 보장한다.

4. 탐색 경로의 기록과 반환

DFS를 수행하면서 탐색한 경로를 기록하고 반환하는 방법도 있다. 이는 경로를 추적하거나 분석할 때 유용하다. 다음은 탐색 경로를 기록하여 반환하는 예제 코드이다.

def dfs_path(grid, x, y, visited, path):
    if x < 0 or x >= len(grid) or y < 0 or y >= len(grid[0]):
        return
    if (x, y) in visited or grid[x][y] == '#':
        return
    
    visited.add((x, y))
    path.append((x, y))
    
    dfs_path(grid, x + 1, y, visited, path)
    dfs_path(grid, x - 1, y, visited, path)
    dfs_path(grid, x, y + 1, visited, path)
    dfs_path(grid, x, y - 1, visited, path)

    return path

visited = set()
path = dfs_path(grid, 0, 0, visited, [])
print("DFS 탐색 경로:", path)

이 코드는 그리드의 (0, 0)에서 출발하여 가능한 경로를 모두 탐색하고, 탐색한 경로를 리스트로 반환한다.

5. 결론

DFS는 그래프와 2D 그리드에서 강력한 탐색 도구이다. 2D 그리드에서의 DFS는 좌표의 유효성 검사와 방문 처리, 경로 기록을 통해 다양한 문제를 해결할 수 있다. 이 글에서 다룬 내용을 통해 DFS의 기본 개념과 2D 그리드에서의 활용 방법을 이해할 수 있을 것이다.

99클럽 코테 스터디 24/99일차 TIL #대충 만든 자판(미들러)

Barrer — Thu, 15 Aug 2024 09:08:10 +0900

문제 이해

1번 => A
2번 => B
3번 => C

1<=키 개수<=100
같은 문자가 여러번 할당, 키 하나에 같은 문자 여러번 할당
할당 안된 경우

최소 몇번 눌러야 문자열 작성 가능한지 => 완전 탐색

keymap = ["ABACD", "BCEFD"]
0번키 누르면 나오는 배열: ABACD
1번키 누르면 나오는 배열: BCEFD
-> ABCD
(0,1), (1,1), (1,2), (0,5)  => 9
특정 문자가 특정 키에서 가장 먼저 나오는 것을 찾고 그 인덱스를 반환

없는 경우 -1 return

lst = []
keymap => dic으로 만들고
target을 돌면서
for words in target:
    cnt = 0
    for word in words:
        word 가 있는지
        없으면 -1 return
        있으면 두 리스트 중에 인덱스 값이 가장 작은 값을 cnt +
    lst.append(cnt)

targets = ["ABCD","AABB"]

def solution(keymap, targets):
    
#     keymap을 딕셔너리로 만들기
    key_dic = {}
        
    for i in keymap:
        for key in i:
            if key not in key_dic:
                key_dic[key] = i.index(key)
            else:
                key_dic[key] = min(key_dic[key], i.index(key))
    # print(key_dic)
    
    result_dic = []
    for target in targets:
        cnt = 0
        for search_char in target:
            
            # print(search_char, key_dic)
            if search_char in key_dic:
                cnt += key_dic[search_char]+1
            else:
                cnt = -1
                break
        
        
        result_dic.append(cnt)
        
            
    return result_dic

99클럽 코테 스터디 22/99일차 TIL #멀리 뛰기(미들러)

Barrer — Tue, 13 Aug 2024 09:50:07 +0900

'''
경우의 수
한 번에 1칸 또는 2칸
1로 개수 만들고,
2개씩 줄이면서 개수 늘리고
2의 위치 개수

1로 만들어진 숫자 1개
2의 개수 = 0~ n//2개


2의 개수 0개~ n/2

total num = n
2의개수, 1의 개수 =  a, n-

'''

import math

def solution(n):
    total_count = 0
    
    for cnt_2 in range(0, n // 2 + 1):
        cnt_1 = n - 2 * cnt_2
        total_steps = cnt_1 + cnt_2
        
        # 조합의 개수 계산: total_steps! / (cnt_2! * cnt_1!)
        combinations = math.factorial(total_steps) // (math.factorial(cnt_2) * math.factorial(cnt_1))
        
        total_count += combinations
    
    return total_count % 1234567