-

[백준 24499] Blobyum - 파이썬

choiht — Thu, 11 Jul 2024 16:06:13 +0900

문제

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

풀이

1. 이 문제는 선형이 아니라 원형 큐의 형태이므로 입력받은 배열을 뒤에 하나 더 붙여서 풀면 편하다.

2. 배열의 처음부터 끝까지 누적합을 visited 배열에 저장한다.

3. visited 배열을 돌며 인덱스의 차이가 k인 수들의 차이의 최대값을 구한다.

코드

n, k = map(int, input().split())
arr = list(map(int, input().split()))
arr.extend(arr)

ans = 0
visited = [0] * 200002

for i in range(1, n*2 + 1):
    visited[i] = visited[i-1] + arr[i-1]

for i in range(k, n*2 + 1):
    ans = max(ans, visited[i] - visited[i-k])
    
    
print(ans)

[백준 11059] 크리 문자열 - 파이썬

choiht — Wed, 10 Jul 2024 13:10:05 +0900

문제

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

풀이

1. 문자열을 정수 배열로 변환한다.

2. 해당 배열의 누적 합을 새로운 배열에 추가한다.

3. 모든 짝수 길이의 부분 문자열을 탐색하며 절반의 합을 계산한다.

4. 만약 절반의 합이 서로 일치한다면 해당 문자열을 길이를 저장한다.

코드

def find(s):
    n = len(s) 
    ans = 0
    
    # 문자열을 정수 배열로 변환
    arr = [int(char) for char in s]
    
    # 누적 합 계산
    prefix_sum = [0] * (n + 1)
    for i in range(1, n + 1):
        prefix_sum[i] = prefix_sum[i - 1] + arr[i - 1]
        
    
    # 모든 짝수 길이의 부분 문자열 탐색
    for length in range(2, n + 1, 2):
        for start in range(n - length + 1):
            mid = start + length // 2
            
            # 누적 합을 이용하여 각 절반의 합 계산
            sum_front = prefix_sum[mid] - prefix_sum[start]
            sum_back = prefix_sum[start + length] - prefix_sum[mid]
            
            if sum_front == sum_back:
                ans = max(ans, length)
                
    return ans
                
s = str(input())
print(find(s))

[백준 1756] 피자굽기 - 파이썬

choiht — Sat, 13 Apr 2024 22:05:00 +0900

문제

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

1756번: 피자 굽기

첫째 줄에 오븐의 깊이 D와 피자 반죽의 개수 N이 공백을 사이에 두고 주어진다. (1 ≤ D, N ≤ 300,000) 둘째 줄에는 오븐의 최상단부터 시작하여 깊이에 따른 오븐의 지름이 차례대로 주어진다. 셋

www.acmicpc.net

풀이 방법

오븐이 현재 5 6 4 3 6 2 3 처럼 되어있으므로 어차피 지름이 3인 반죽은 맨 밑바닥까지 가지 못하고 그 위에 지름이 2인 오븐에서 막힌다.

따라서 이를 비교하기 쉽도록 바꿔줘야한다.

5 6 4 3 6 2 3 → 5 5 4 3 3 2 2 로 바꿔주는 작업이 필요하다.

그 후에는 가장 밑바닥 오븐부터 차례대로 올라오며 피자 반죽의 지름과 비교한다.

코드

d, n = map(int, input().split())  #오븐 깊이, 반죽 개수
oven = list(map(int, input().split()))
pizza = list(map(int, input().split()))
       

for i in range(1, d):
    if oven[i] > oven[i-1]:
        oven[i] = oven[i-1]
        
p = 0   #오븐에 넣은 피자 반죽 개수
i = d - 1  #오븐 인덱스

while i >= 0:
    if pizza[p] <= oven[i]:  #오븐의 제일 밑바닥부터 비교
        p += 1
        if p == n:
            break
    i -= 1
            

if p < n:  #피자 반죽이 아직 남아있으면
    print(0)
else:
    print(i + 1)

[프로그래머스] 조건에 맞는 개발자 찾기 - SQL

choiht — Thu, 7 Mar 2024 16:34:56 +0900

문제

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

프로그래머스

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

programmers.co.kr

풀이 방법

SKILL_CODE 가 Python 이나 C#을 나타내는 비트를 포함하는 개발자를 찾아야한다.

즉, 해당 기술을 나타내는 비트가 1로 설정되어있는지 확인해야하므로, 비트를 비교하는 연산을 해야한다.

'&' 연산자를 사용하면, 10진수 숫자들은 자동으로 2진수로 변환된 후 비트별로 AND 연산이 수행된다.

따라서 SKILL_CODE와 'Python' 에 해당하는 2진수 비트를 비교해서 포함되어있는지 확인하는 것이다.

코드

SELECT ID, EMAIL, FIRST_NAME, LAST_NAME
FROM DEVELOPERS
WHERE SKILL_CODE & (SELECT CODE FROM SKILLCODES WHERE NAME = 'Python')
    OR SKILL_CODE & (SELECT CODE FROM SKILLCODES WHERE NAME = 'C#')
    
ORDER BY ID

[백준 2852] NBA 농구 - 파이썬

choiht — Sat, 2 Mar 2024 15:21:22 +0900

문제

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

2852번: NBA 농구

첫째 줄에 골이 들어간 횟수 N(1<=N<=100)이 주어진다. 둘째 줄부터 N개의 줄에 득점 정보가 주어진다. 득점 정보는 득점한 팀의 번호와 득점한 시간으로 이루어져 있다. 팀 번호는 1 또는 2이다. 득

www.acmicpc.net

풀이 방법

이 문제는 두 팀이 비기고 있을 때에는 시간 초를 카운트하면 안된다.

따라서 1팀이 득점하면 flag 변수를 +1 해주고, 2팀이 득점하면 flag 변수를 -1 해줌으로써 누가 이기고 있는 상황인지 판단한다.

시간 계산은 전체 시간에서 비기고 있는 시간을 빼는 방식으로 계산했다.

코드

n = int(input())
info = []

one = 0
two = 0
flag = 0

for i in range(n):
    team, time = input().split()
    m, s = map(int, time.split(':'))
    
    if team == '1':
        if flag == 0:
            one += 48*60 - (60*m+s)

        flag += 1
        if flag == 0:
            if two > 0:
                two = two - (48*60 - (60*m+s))
            
            
    else:
        if flag == 0:
            two += 48*60 - (60*m+s)
        
        flag -= 1
        if flag == 0:
            if one > 0:
                one = one - (48*60 - (60*m+s))
                
                
print('{:0>2}:{:0>2}'.format(one//60,one%60))
print('{:0>2}:{:0>2}'.format(two//60,two%60))

[백준 16173] 점프왕 쩰리 - 파이썬

choiht — Fri, 1 Mar 2024 11:07:32 +0900

문제

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

16173번: 점프왕 쩰리 (Small)

쩰리는 맨 왼쪽 위의 칸에서 출발해 (행, 열)로 나타낸 좌표계로, (1, 1) -> (2, 1) -> (3, 1) -> (3, 3)으로 이동해 게임에서 승리할 수 있다.

www.acmicpc.net

풀이 방법

시작 지점인 (0, 0)부터 시작하여 dfs로 돌면서 방문한 곳은 visited 배열에서 1로 바꿔준다.

좌표가 맵 밖을 벗어나거나 이미 방문한 곳은 return으로 빠져나온다.

도착 지점에 도착했으면 (= visited 배열에서 도착 지점에 해당하는 곳이 1이면) 성공한 것으로 간주한다.

코드

n = int(input())
board = [list(map(int, input().split())) for _ in range(n)]
visited = [[0]*n for _ in range(n)]

def dfs(x, y):
    if x < 0 or x >= n or y < 0 or y >= n or visited[x][y] == 1:
        return
    
    if board[x][y] == -1:
        visited[x][y] = 1
        return
    
    visited[x][y] = 1
    
    dfs(x + board[x][y], y)
    dfs(x, y + board[x][y])
    
    
dfs(0, 0)
if visited[-1][-1] == 1:
    print('HaruHaru')
else:
    print('Hing')

[백준 2116] 주사위쌓기 - 파이썬

choiht — Wed, 28 Feb 2024 19:07:00 +0900

문제

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

2116번: 주사위 쌓기

첫줄에는 주사위의 개수가 입력된다. 그 다음 줄부터는 한 줄에 하나씩 주사위의 종류가 1번 주사위부터 주사위 번호 순서대로 입력된다. 주사위의 종류는 각 면에 적혀진 숫자가 그림1에 있는

www.acmicpc.net

풀이 방법

주사위의 개수와 주사위 정보를 입력받는다.

가장 밑에 오는 주사위에서 밑면을 무엇으로 해야 최대가 되는지 계산하기 위해 for 문을 1 - 6까지 돈다.

밑에 있는 주사위의 윗면과, 위에 있는 주사위의 밑면이 일치해야하기 때문에 그 수를 맞춘 상태에서 옆면이 최대가 되는 숫자를 더해준다.

for 문이 끝날 때마다 최대가 되는 옆면의 합을 갱신한다.

코드

n = int(input())
dice_list = [list(map(int, input().split())) for _ in range(n)]
max_sum = 0

def find_max(dice, bottom):
    for i in range(6):
        if dice[i] == bottom:
            break
    
    if i == 0:
        return (dice[5], max(dice[1], dice[2], dice[3], dice[4]))
    elif i == 1:
        return (dice[3], max(dice[0], dice[2], dice[4], dice[5]))
    elif i == 2:
        return (dice[4], max(dice[0], dice[1], dice[3], dice[5]))
    elif i == 3:
        return (dice[1], max(dice[0], dice[2], dice[4], dice[5]))
    elif i == 4:
        return (dice[2], max(dice[0], dice[1], dice[3], dice[5]))
    elif i == 5:
        return (dice[0], max(dice[1], dice[2], dice[3], dice[4]))



for i in range(1, 7):
    bottom = i
    total = 0
    
    for j in range(n):
        bottom, maxnum = find_max(dice_list[j], bottom)
        total += maxnum
        
    if max_sum < total:
        max_sum = total
        
print(max_sum)

[백준 16922] 로마 숫자 만들기 - 파이썬

choiht — Tue, 27 Feb 2024 10:31:04 +0900

문제

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

16922번: 로마 숫자 만들기

2, 6, 10, 11, 15, 20, 51, 55, 60, 100을 만들 수 있다.

www.acmicpc.net

풀이 방법

로마숫자를 더해서 나오는 수에 해당하는 인덱스 (예를 들어 로마숫자 IX → 11) 에 1을 더해준다.

나중에 로마숫자로 만들 수 있는 숫자의 총 개수를 sum 함수로 쉽게 세기 위함이다.

재귀함수를 사용해서 숫자를 반복적으로 더해준다.

코드

n = int(input())
roma = [1, 5, 10, 50]
arr = [0] * 1001
num = 0


def dfs(cur, start):
    global num
    if cur == n:
        arr[num] = 1
        return
    
    for i in range(start, 4):
        num += roma[i]
        dfs(cur+1, i)
        num -= roma[i]



dfs(0, 0)
print(sum(arr))

[백준 14890] 경사로 - 파이썬

choiht — Sun, 18 Feb 2024 16:27:01 +0900

문제

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

14890번: 경사로

첫째 줄에 N (2 ≤ N ≤ 100)과 L (1 ≤ L ≤ N)이 주어진다. 둘째 줄부터 N개의 줄에 지도가 주어진다. 각 칸의 높이는 10보다 작거나 같은 자연수이다.

www.acmicpc.net

풀이 방법

지나갈 수 있는 길인지 체크할 때,

높이가 같은 경우 : 그냥 넘어감
높이가 2 이상 차이 나는 경우 : False 반환
왼쪽이 더 높은 경우 : 경사로를 놓을 공간이 있는지 체크 후 경사로 설치
오른쪽이 더 높은 경우 : 경사로를 놓을 공간이 있는지 체크 후 경사로 설치

로 나눠서 풀어야 한다.

이 때, 경사로를 설치한 곳에는 중복해서 설치할 수 없기 때문에 bridge 라는 리스트를 만들어 해당 위치에 경사로를 설치했다는 것을 표시해놓아야 한다.

또한 가로를 모두 체크했으면 이제 배열을 90도 회전해 세로를 체크해야 한다.

코드

n, l = map(int, input().split())
floor = [list(map(int, input().split())) for _ in range(n)]


def check(board):
    bridge = [False for i in range(n)]
    
    for i in range(n-1):
        if board[i] == board[i+1]: #높이가 같은 경우
            continue
        
        if abs(board[i] - board[i+1]) >= 2: #높이가 2이상 차이나는 경우
            return False
        
        if board[i] > board[i+1]: #왼쪽이 더 높은 경우
            for j in range(i+1, i+1+l):
                if 0 <= j < n:
                    if board[j] != board[i+1]:
                        return False
                    if bridge[j] == True:
                        return False
                    bridge[j] = True
                else:
                    return False
                
        else: #오른쪽이 더 높은 경우
            for j in range(i, i-l, -1):
                if 0 <= j < n:
                    if board[j] != board[i]:
                        return False
                    if bridge[j] == True:
                        return False
                    bridge[j] = True
                else:
                    return False
                
    return True
   
    
    
def rotate(n, arr):  #기존 배열 90도로 돌리는 함수
    ret = [[0]*n for _ in range(n)]
    
    for i in range(n):
        for j in range(n):
            ret[j][n-1-i] = arr[i][j]
            
    return ret
    
    
    
ans = 0
  
for i in floor: #가로로 지나갈 수 있는 길 체크
    if check(i):
        ans += 1

floor = rotate(n, floor)

for i in floor: #세로로 지나갈 수 있는 길 체크
    if check(i):
        ans += 1


print(ans)

[백준 21608] 상어 초등학교 - 파이썬

choiht — Sun, 18 Feb 2024 00:59:41 +0900

문제

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

21608번: 상어 초등학교

상어 초등학교에는 교실이 하나 있고, 교실은 N×N 크기의 격자로 나타낼 수 있다. 학교에 다니는 학생의 수는 N2명이다. 오늘은 모든 학생의 자리를 정하는 날이다. 학생은 1번부터 N2번까지 번호

www.acmicpc.net

풀이 방법

n = 3 일 때, 전체 9칸을 차례대로 돌면서 주변에 있는 내가 원하는 번호의 개수와, 빈 자리를 체크하여 리스트에 저장한다.

문제에서 주어진 조건에 맞게 자리 배치를 하기 위해 lambda 함수를 사용해 리스트를 정렬하는데, 원하는 번호의 개수와 빈자리를 내림차순으로, 행과 열을 오름차순으로 정렬한다.

이렇게 정렬을 마쳤으면 가장 첫 번째 오는 원소에 있는 행과 열에 해당하는 자리에 학생을 앉힌다.

자리에 다 앉혔다면 이제 학생 번호 순서대로 각자가 원하는 번호와 몇개나 인접해있는지 개수를 센다.

코드

n = int(input())
students = [list(map(int, input().split())) for _ in range(n**2)]
arr = [[0]*n for _ in range(n)]

dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

for order in range(n**2):
    student = students[order]
    
    tmp = []
    for i in range(n):
        for j in range(n):
            if arr[i][j] == 0:
                like = 0
                blank = 0
                
                for k in range(4):
                    nx = i + dx[k]
                    ny = j + dy[k]
                    
                    if 0 <= nx < n and 0 <= ny < n:
                        if arr[nx][ny] in student[1:]:
                            like += 1
                        if arr[nx][ny] == 0:
                            blank += 1
                            
                tmp.append([like, blank, i, j])
                
    tmp.sort(key = lambda x:(-x[0], -x[1], x[2], x[3]))
    arr[tmp[0][2]][tmp[0][3]] = student[0]
    
        

result = 0
students.sort()


for i in range(n):
    for j in range(n):
        ans = 0
        
        for k in range(4):
            nx = i + dx[k]
            ny = j + dy[k]
            
            if 0 <= nx < n and 0 <= ny < n:
                if arr[nx][ny] in students[arr[i][j]-1]:
                    ans += 1
                    
        if ans != 0:
            result += 10 ** (ans - 1)
            
            
print(result)