PRESENT

[백준 14500 : PYTHON] 테트로미노

by cijbest — Tue, 15 Jun 2021 16:08:37 +0900

문제 풀기 : 14500번

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

문제

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다.

정사각형은 서로 겹치면 안 된다.
도형은 모두 연결되어 있어야 한다.
정사각형의 변끼리 연결되어 있어야 한다. 즉, 꼭짓점과 꼭짓점만 맞닿아 있으면 안 된다.

정사각형 4개를 이어 붙인 폴리오미노는 테트로미노라고 하며, 다음과 같은 5가지가 있다.

아름이는 크기가 N×M인 종이 위에 테트로미노 하나를 적절히 놓아서 테트로미노가 놓인 칸에 쓰여 있는 수들의 합을 최대로 하는 수를 구하라.

테트로미노는 회전이나 대칭을 시켜도 된다.

문제풀이

보드위에 테트로미노 하나를 놓아서 가장 최대가 되는 수를 찾는 문제이다. (~~처음엔 여러 개 놓는 문제인 줄 알았다...~~)

5개의 테트로미노를 어떻게 놓을지 고민해보자.

테트로미노를 자세히보면 4개의 정사각형으로 이루어져 있고 4개의 테트로미노는 연달아 이을 수 있지만 1개는 그렇지 않다. 그림을 보자!

왼쪽에 있는 테트로미노는 dfs로 상하좌우 최대 4번까지 돌려서 모양을 얻을 수 있지만, 오른쪽에 있는 테트로미노는 경우를 다르게 해주어야 한다는 것을 알 수 있을 것이다. 이해가 안 된다면 다음 설명을 보면된다.

왼쪽을 먼저 살펴보자!

회전과 대치를 시킨 모양들이다. 이 모양들은 상하좌우로 단 4번의 움직임으로 나올 수 있는 모든 모양이다. 신기했다.

진짜 그럴까 하신 분들은 아래의 표에서 아무렇게나 4번 움직여서 확인하시면 됩니다.

그럼 이제 오른쪽에 있는 모양의 경우의 수를 따져보자면 이렇다.

이 경우엔 가운데를 중심으로 3개의 날개(?)를 고려하면된다. 위에선 상하좌우 4가지 방향을 고려했지만 여기선 dfs를 돌릴 필요도 없고 4가지 경우를 순차적으로 확인하면 된다.

코드에서 중요한 부분을 몇 가지 언급하자면,

dfs를 돌릴 땐 중복 방문을 피하기 위해 visited를 만들어 방문여부를 꼭 확인하고 dfs가 끝나면 방문했던 곳은 방문해제를 해준다.

ㅗ 모양의 날개(?)부분을 확인할 때 방향 한 개만 뺀 경우를 따질 때는 좌표를 미리 적어두어 사용해도 되지만 나의 경우엔 상하좌우(move) 배열을 그대로 사용했다. t = (n+k)%4 계산식을 사용해서 3개의 인덱스만을 탐색했다.

전체코드

import sys
input = sys.stdin.readline

# 상, 하, 좌, 우
move = [(0, 1), (0, -1), (1, 0), (-1, 0)]

# INPUT
N, M = map(int, input().split())
board = [list(map(int,input().split())) for _ in range(N)]
visited = [[False] * M for _ in range(N)]

# 최대값 변수
maxValue = 0

# ㅗ, ㅜ, ㅓ, ㅏ 제외한 모양들 최대값 계산
def dfs(i, j, dsum, cnt):
    global maxValue
    # 모양 완성되었을 때 최대값 계산
    if cnt == 4:
        maxValue = max(maxValue, dsum)
        return

    # 상, 하, 좌, 우로 이동
    for n in range(4):
        ni = i+move[n][0]
        nj = j+move[n][1]
        if 0 <= ni < N and 0 <= nj < M and not visited[ni][nj]:
            # 방문 표시 및 제거
            visited[ni][nj] = True
            dfs(ni, nj, dsum + board[ni][nj], cnt+1)
            visited[ni][nj] = False


# ㅗ, ㅜ, ㅓ, ㅏ 모양의 최대값 계산
def exce(i, j):
    global maxValue
    for n in range(4):
        # 초기값은 시작지점의 값으로 지정
        tmp = board[i][j]
        for k in range(3):
            # move 배열의 요소를 3개씩 사용할 수 있도록 인덱스 계산
            # 012, 123, 230, 301
            t = (n+k)%4
            ni = i+move[t][0]
            nj = j+move[t][1]

            if not (0 <= ni < N and 0 <= nj < M):
                tmp = 0
                break
            tmp += board[ni][nj]
        # 최대값 계산
        maxValue = max(maxValue, tmp)


for i in range(N):
    for j in range(M):
        # 시작점 visited 표시
        visited[i][j] = True
        dfs(i, j, board[i][j], 1)
        visited[i][j] = False

        exce(i, j)

print(maxValue)

[백준 12100 : PYTHON] 2048 (Easy)

by cijbest — Mon, 14 Jun 2021 13:57:25 +0900

문제 풀기 : 12100번

12100번: 2048 (Easy)

첫째 줄에 보드의 크기 N (1 ≤ N ≤ 20)이 주어진다. 둘째 줄부터 N개의 줄에는 게임판의 초기 상태가 주어진다. 0은 빈 칸을 나타내며, 이외의 값은 모두 블록을 나타낸다. 블록에 쓰여 있는 수는 2

www.acmicpc.net

문제

한 번의 이동은 보드 위에 있는 전체 블록을 상하좌우 네 방향 중 하나로 이동시킨다.

같은 값을 갖는 두 블록이 충돌하면 두 블록은 하나로 합쳐지게 된다.

한 번의 이동에서 이미 합쳐진 블록은 또 다른 블록과 다시 합쳐질 수 없다. (실제 게임에서는 이동을 한 번 할 때마다 블록이 추가되지만, 이 문제에서 블록이 추가되는 경우는 없다)

보드의 크기는 N×N 이다.

보드의 크기와 보드판의 블록 상태가 주어졌을 때, 최대 5번 이동해서 만들 수 있는 가장 큰 블록의 값을 구하라.

문제풀이

이 문제는 dfs, bfs 둘 다 사용해서 풀 수 있는 문제로 필자는 dfs로 접근해서 문제를 풀었다.

dfs 코드 작성은 쉽다. 상, 하, 좌, 우로 dfs를 돌리고 5번을 다 돌렸을 때 배열에서 가장 큰 값의 요소를 리턴해주면 4방향의 리턴값들 중 다시 최대값을 리턴하는 것이다.

가장 어려웠던 부분은 4방향으로 움직이는 함수들을 만드는 것이었다.

위로 움직였을 때의 상태를 예시로 들자면, 열순으로 두번째 행부터 탐색해주어야 한다. 이렇게 해주는 이유는 포인터를 사용하기 위함이다. 포인터는 가장 맨 앞쪽부터 위치해서 포인터가 가리키는 숫자들과 탐색되어지는 숫자들을 비교해 값을 변경하는 용도를 쓰여질 것이다. 이렇게 하는 이유는 경우의 수들을 보면 알 수 있다.

그럼 이제 경우의 수를 따져야 한다. 경우의 수는 3가지로 나뉠 수 있다.

포인터가 가리키는 수가 0일 때
포인터가 가리키는 수가 현재 위치의 수와 같을 때
포인터가 가리키는 수가 현재 위치의 수와 다를 때

첫 번째, 포인터가 가리키는 수가 0이라면 그 자리에 0이 아닌 수를 배치시켜야 하므로 현재 탐색한 수가 0이 아니면 포인터가 가리키는 곳에 탐색한 수를 넣는다. 현재 위치는 0으로 비워준다.

두 번째, 포인터가 가리키는 수가 현재 위치와 같다면 포인터의 수를 2배로 만들고 현재 위치는 0으로 만든 후에 포인터를 하나 증가시킨다. 포인터를 증가시키는 이유는 같은 수가 여러 개 연달아 있을 때 중복으로 더해질 수 있기 때문이다.

세 번째, 포인터가 가리키는 수가 현재 위치의 수와 다르면 포인터만 하나 증가시킨다.

전체코드

import sys
from copy import deepcopy
input = sys.stdin.readline

# INPUT
n = int(input())
board = [list(map(int, input().split())) for _ in range(n)]
answer = 0

# UP
def up(board):
    for j in range(n):
        pointer = 0
        for i in range(1, n):
            if board[i][j]:
                tmp = board[i][j]
                board[i][j] = 0
                # 포인터가 가리키는 수가 0일 때
                if board[pointer][j] == 0:
                    board[pointer][j] = tmp
                # 포인터가 가리키는 수와 현재 위치의 수가 같을 때
                elif board[pointer][j]  == tmp:
                    board[pointer][j] *= 2
                    pointer += 1
                # 포인터가 가리키는 수와 현재 위치의 수가 다를 때
                else:
                    pointer += 1
                    board[pointer][j] = tmp
    return board

# DOWN
def down(board):
    for j in range(n):
        pointer = n - 1
        for i in range(n - 2, -1, -1):
            if board[i][j]:
                tmp = board[i][j]
                board[i][j] = 0
                if board[pointer][j] == 0:
                    board[pointer][j] = tmp
                elif board[pointer][j]  == tmp:
                    board[pointer][j] *= 2
                    pointer -= 1
                else:
                    pointer -= 1
                    board[pointer][j] = tmp
    return board

# LEFT
def left(board):
    for i in range(n):
        pointer = 0
        for j in range(1, n):
            if board[i][j]:
                tmp = board[i][j]
                board[i][j] = 0
                if board[i][pointer] == 0:
                    board[i][pointer] = tmp
                elif board[i][pointer]  == tmp:
                    board[i][pointer] *= 2
                    pointer += 1
                else:
                    pointer += 1
                    board[i][pointer]= tmp
    return board

# RIGHT
def right(board):
    for i in range(n):
        pointer = n - 1
        for j in range(n - 2, -1, -1):
            if board[i][j]:
                tmp = board[i][j]
                board[i][j] = 0
                if board[i][pointer] == 0:
                    board[i][pointer] = tmp
                elif board[i][pointer]  == tmp:
                    board[i][pointer] *= 2
                    pointer -= 1
                else:
                    pointer -= 1
                    board[i][pointer] = tmp
    return board


# DFS
def dfs(board, cnt):
    if cnt == 5:
        # 2차원 배열 요소 중 가장 큰 값 반환
        return max(map(max, board))

    # 상, 하, 좌, 우로 움직여 리턴한 값들 중 가장 큰 값 반환
    # board를 꼭 deepcopy하여 함수를 거친 board값이 다음 함수에 들어가지 못하도록 해주어야 한다.
    return max(dfs(up(deepcopy(board)), cnt + 1), dfs(down(deepcopy(board)), cnt + 1), dfs(left(deepcopy(board)), cnt + 1), dfs(right(deepcopy(board)), cnt + 1))

print(dfs(board, 0))

[백준 13458 : PYTHON] 시험 감독

by cijbest — Sun, 13 Jun 2021 21:57:29 +0900

문제 풀기 : 13458번

13458번: 시험 감독

첫째 줄에 시험장의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다. 둘째 줄에는 각 시험장에 있는 응시자의 수 Ai (1 ≤ Ai ≤ 1,000,000)가 주어진다. 셋째 줄에는 B와 C가 주어진다. (1 ≤ B, C ≤ 1,000,000)

www.acmicpc.net

문제

총 N개의 시험장이 있고, 각각의 시험장마다 응시자들이 있다.

총감독관은 한 시험장에서 감시할 수 있는 응시자의 수가 B명이고, 부감독관은 한 시험장에서 감시할 수 있는 응시자의 수가 C명이다.

각각의 시험장에 총감독관은 오직 1명만 있어야 하고, 부감독관은 여러 명 있어도 된다.

각 시험장마다 응시생들을 모두 감시해야 한다. 이때, 필요한 감독관 수의 최솟값을 구하는 프로그램을 작성하라.

문제풀이

각각의 시험장의 감독관을 정할 때 총감독관을 먼저 배치한다. 총감독관이 감시할 수 있는 사람(B)을 시험장에 있는 사람을 다 커버할 수 있으면 감독관 수를 증가시키고 커버할 수 없으면 부감독관의 수를 구한다. 부감독관은 남은 사람들에서 부감독관이 감독할 수 있는 사람(C)만큼 나눈다. 나머지가 0이면 나눈 몫만큼이 부감독관 수가 되고 나머지가 0이 아니면 나눈 몫에 부감독관 한명을 더 추가시킨 것이 부감독관의 수가 된다.

예) 시험장 사람 : 15명, 부감독이 감시할 수 있는 사람 : 4 일때,

15 / 4 = 3(몫)...3(나머지)

필요한 부감독수 : 4명

전체코드

import sys
sys.stdin.readline

# INPUT
N = int(input())
data = list(map(int, input().split()))
B, C = map(int, input().split())

# 감독관 수
cnt = 0

for d in data:
    # 총감독이 감독할 수 있는 사람 빼기
    d -= B
    # 아직 감독해야할 사람이 있는 경우
    if d > 0:
        # 부감독관이 감독할 수 있는 사람이 딱 떨어지는 경우(총감독관 1명 포함)
        if (d/C) == int(d/C):
            cnt += 1 + (d/C)
        # 부감독관이 감독할 수 있는 사람보다 조금 더 있는 경우(총감독관 1명 포함)
        else:
            cnt += 1 + int(d/C) + 1
    # 총감독만으로 시험장 감독이 가능한 경우
    else:
        cnt += 1
        
print(int(cnt))

[백준 14499 : PYTHON] 주사위 굴리기

by cijbest — Sun, 13 Jun 2021 21:32:36 +0900

문제 풀기 : 14499번

14499번: 주사위 굴리기

첫째 줄에 지도의 세로 크기 N, 가로 크기 M (1 ≤ N, M ≤ 20), 주사위를 놓은 곳의 좌표 x y(0 ≤ x ≤ N-1, 0 ≤ y ≤ M-1), 그리고 명령의 개수 K (1 ≤ K ≤ 1,000)가 주어진다. 둘째 줄부터 N개의 줄에 지도

www.acmicpc.net

문제

N×M인 지도가 존재한다.

지도의 오른쪽은 동쪽, 위쪽은 북쪽이다.

지도의 좌표는 (r, c)로 나타내며, r는 북쪽으로부터 떨어진 칸의 개수, c는 서쪽으로부터 떨어진 칸의 개수이다.

가장 처음에 주사위에는 모든 면에 0이 적혀져 있다.

지도의 각 칸에는 정수가 하나씩 쓰여져 있다.

주사위를 굴렸을 때, 이동한 칸에 쓰여 있는 수가 0이면, 주사위의 바닥면에 쓰여 있는 수가 칸에 복사된다.
0이 아닌 경우에는 칸에 쓰여 있는 수가 주사위의 바닥면으로 복사되며, 칸에 쓰여 있는 수는 0이 된다.

문제풀이

주사위를 굴릴 때마다 상하좌우로 바뀌는 주사위의 숫자를 어떻게 따져줘야 할 지 몰라서 문제를 못 풀고 있었다. 다른 사람들의 풀이를 봐도 이해를 못하다가 여러 풀이를 보고 깨달았다.

문제를 최대한 쉽게 설명해보려 한다.

우선! 주사위가 움직일 때마다 주사위의 윗면과 밑면을 고정할 수 있는 방법이 무엇인지를 생각해야 한다. 문제에서 전개도를 괜히 준게 아니었다! 전개도는 주사위가 움직일 때마다 변하는 주사위 값의 위치를 지정할 수 있는 유일한 방법이다.

문제에 있는 전개도이다. 핵심은 전개도에 있는 저 숫자들을 고정된 인덱스로 정하는 거다! 예를 들어 1이 있는 위치는 1번 인덱스라고 고정을 하는 것이다. 그렇게 하면 고정된 전개도 내에서 규칙(동서남북)만 찾는다면 값의 위치가 변해도 같은 주사위인 것이다. (코드에서 dice 변수는 각 인덱스의 값들을 저장하는 배열이다.)

아직 이해가 되지 않는다면 다음 규칙을 보자.

1번 인덱스를 기준으로 동쪽으로 이동했을 때의 바뀐 전개도이다. 4개의 인덱스 위치가 변경되었고 다른 방향도 바뀌는 상태를 따져주어 적용한다.

4방향의 변경된 인덱스 위치는 다음과 같다. 바뀐 인덱스대로 값을 변경해주는 함수는 changDiceState이므로 코드에서 확인하면 된다.

여기까지 주사위의 상태를 바꿀 수 있다면 다 되었다. 주사위의 윗면은 dice[1]이라는 것과 밑면은 dice[6]이라는 것을 이용하면 나머지 코드는 짤 수 있다.

코드에서는 배열의 인덱스 특성상 0부터 시작하기 때문에 위의 전개도의 인덱스들은 1부터 시작하지만 코드를 작성할 때는 0에 맞추어 작성했다.

전체코드

import sys
input = sys.stdin.readline

# 동, 서, 북, 남
direct = [(0, 1), (0, -1), (-1, 0), (1, 0)]

#INPUT
n, m, x, y, k = map(int, input().split())
board = [list(map(int, input().split())) for _ in range(n)]
move = list(map(int, input().split()))

# 주사위에 적힌 수 보관 (전개도)
dice = [0] * 6

def changeDiceState(i):
    if i == 1:
        dice[0], dice[2], dice[3], dice[5] = dice[3], dice[0], dice[5], dice[2]
    elif i == 2:
        dice[0], dice[2], dice[3], dice[5] = dice[2], dice[5], dice[0], dice[3]
    elif i == 3:
        dice[0], dice[1], dice[4], dice[5] = dice[4], dice[0], dice[5], dice[1]
    else:
        dice[0], dice[1], dice[4], dice[5] = dice[1], dice[5], dice[0], dice[4]

for i in move:
    nx = x + direct[i-1][0]
    ny = y + direct[i-1][1]
    
    # 범위 밖에 있으면 명령 건너뛰기
    if nx < 0 or ny < 0 or nx > n - 1 or ny > m - 1:
        continue

    # 주사위 전개도 배치 바꾸기
    changeDiceState(i)

    # 지도 칸의 숫자가 0일 때
    if board[nx][ny] == 0:
        board[nx][ny] = dice[5]
    # 지도 칸의 숫자가 0이 아닐 때
    else:
        dice[5] = board[nx][ny]
        board[nx][ny] = 0
    
    x = nx
    y = ny

    # 주사위 윗면 출력
    print(dice[0])

[백준 3190 : PYTHON] 뱀

by cijbest — Sun, 13 Jun 2021 16:42:29 +0900

문제 풀기 : 3190번

3190번: 뱀

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다. 게임

www.acmicpc.net

문제

NxN 정사각 보드위에서 진행한다.

몇몇 칸에는 사과가 놓여져 있다.

보드의 상하좌우 끝에 벽이 있다.

뱀은 맨위 맨좌측에 위치한다. 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.

뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.

먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

문제풀이

1. 뱀의 위치를 큐에 넣어서 보관한다. 뱀이 이동할 때 머리와 꼬리의 변화만 있기 때문이다. 배열말고 큐를 사용하는 이유는 삽입, 삭제 시 logN만큼의 시간이 걸리기 때문에 효율성이 좋다.

2. 뱀이 움직이는 방향 인덱스 변수(idx)를 만들어서 인덱스번호에 맞춰 move배열에 배치시킨다.

제 경우엔 왼쪽으로 90도 돌렸을 때의 방향들 순으로 배치했다. (오른쪽 → 위 → 왼쪽 → 아래)

오른쪽 90도의 경우에는 인덱스 반대방향이다.

3. X(초), C(방향)는 각각 따로 배열에 저장한다. while 문으로 1초씩 움직이면서 X에 방향 바꿀 시간이 되면 방향의 타입(L 또는 D)에 따라 뱀의 방향(idx)을 바꿔준다.

방향 바꿀 시간이 아니라면, 뱀의 다음 방향(nx, ny)이

벽이나 자기 자신이라면 while문을 빠져 나가고
사과라면 현재 사과 위치를 snake 큐 맨앞에 넣어 뱀의 몸 길이를 늘린다. 사과를 먹었으므로 사과 위치(7)를 뱀이 지나다닐 수 있는 위치(0)으로 바꿔준다.
사과가 아니면 다음 위치를 뱀의 머리(큐 맨앞)에 위치시키고 꼬리 위치(큐 맨끝)를 없앤다.

4. 카운트는 뱀이 시작할 때 시작 위치에 위치하는 시간까지 포함해야 하므로 +1을 해준다.

전체코드

import sys
input = sys.stdin.readline
from collections import deque

# 뱀의 현재위치
snake = deque()
snake.appendleft([0,0])

# 왼쪽 90도 기준 (오, 위, 왼, 아)
move = [[0, 1], [-1, 0], [0, -1], [1, 0]]

# 뱀의 현재 방향
idx = 0

# INPUT
N = int(input())
board = [[0] * N for _ in range(N)]

K = int(input())
for _ in range(K):
    x, y = map(int, input().split())
    # 사과 위치 표시
    board[x-1][y-1] = 7

# 게임 시간
sec = 0

L = int(input())
X = []
C = []
for i in range(L):
    t1, t2 = input().split()
    X.append(int(t1))
    C.append(t2)

while True:
    # 방향 바꾸는 시간이 되었을 때
    if sec in X:
        # 방향바꾸기
        d = C[X.index(sec)]    
        
        # 왼쪽 90도
        if d == 'L':
            idx = (idx + 1) % 4
        # 오른쪽 90도
        else:
            if (idx - 1) == -1:
                idx = 3
            else:
                idx = (idx - 1) % 4

    nx = snake[0][0] + move[idx][0]
    ny = snake[0][1] + move[idx][1]

    # 벽에 부딪히거나 자기 자신을 만났을 때
    if nx < 0 or ny < 0 or nx > N-1 or ny > N-1 or ([nx, ny] in snake) :
        break
    # 사과일 때
    if board[nx][ny] == 7:
        snake.appendleft([nx, ny])
        board[nx][ny] = 0
    # 사과 아닐 때
    else:
        # 머리 위치 변경, 꼬리 줄이기
        snake.appendleft([nx, ny])
        snake.pop()

    sec += 1
        
# 뱀이 처음 시작자리에 놓이는 시간 포함  
print(sec + 1)

[프로그래머스 : PYTHON] 다트 게임

by cijbest — Sat, 5 Jun 2021 18:18:40 +0900

다트 게임

카카오톡에 뜬 네 번째 별! 심심할 땐? 카카오톡 게임별~

카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.
갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다. 다트 게임의 점수 계산 로직은 아래와 같다.

다트 게임은 총 3번의 기회로 구성된다.
각 기회마다 얻을 수 있는 점수는 0점에서 10점까지이다.
점수와 함께 Single(S), Double(D), Triple(T) 영역이 존재하고 각 영역 당첨 시 점수에서 1제곱, 2제곱, 3제곱 (점수1 , 점수2 , 점수3 )으로 계산된다.
옵션으로 스타상(*) , 아차상(#)이 존재하며 스타상(*) 당첨 시 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다. 아차상(#) 당첨 시 해당 점수는 마이너스된다.
스타상(*)은 첫 번째 기회에서도 나올 수 있다. 이 경우 첫 번째 스타상(*)의 점수만 2배가 된다. (예제 4번 참고)
스타상(*)의 효과는 다른 스타상(*)의 효과와 중첩될 수 있다. 이 경우 중첩된 스타상(*) 점수는 4배가 된다. (예제 4번 참고)
스타상(*)의 효과는 아차상(#)의 효과와 중첩될 수 있다. 이 경우 중첩된 아차상(#)의 점수는 -2배가 된다. (예제 5번 참고)
Single(S), Double(D), Triple(T)은 점수마다 하나씩 존재한다.
스타상(*), 아차상(#)은 점수마다 둘 중 하나만 존재할 수 있으며, 존재하지 않을 수도 있다.

0~10의 정수와 문자 S, D, T, *, #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.

입력 형식

"점수|보너스|[옵션]"으로 이루어진 문자열 3세트.
예) 1S2D*3T

점수는 0에서 10 사이의 정수이다.
보너스는 S, D, T 중 하나이다.
옵선은 *이나 # 중 하나이며, 없을 수도 있다.

출력 형식

3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력한다.
예) 37

입출력 예제

예제	dartResult	answer	설명
1	1S2D*3T	37	11 * 2 + 22 * 2 + 33
2	1D2S#10S	9	12 + 21 * (-1) + 101
3	1D2S0T	3	12 + 21 + 03
4	1S2T3S	23	11 * 2 * 2 + 23 * 2 + 31
5	1D#2S*3S	5	12 * (-1) * 2 + 21 * 2 + 31
6	1T2D3D#	-4	13 + 22 + 32 * (-1)
7	1D2S3T*	59	12 + 21 * 2 + 33 * 2

문제풀이

문자열을 하나씩 돌면서 number에 숫자 문자열을 더한다. 숫자가 10일 경우엔 문자열 하나로 해결되지 않기 때문이다. 그리고 S, D, T가 나왔다는 건 숫자가 다 끝났다는 이야기이므로 S, D, T가 나오면 number를 점수를 저장하는 score 배열에 추가한다. 점수에 제곱을 하거나 옵션 조건을 적용할 때는 배열의 -1, -2 인덱스를 사용해서 점수를 조정한다.

전체코드

def solution(dartResult):
    score = []
    number = ''
    for d in dartResult:
    	# d가 숫자일 때
        if "0" <= d <= "9":
        	# 숫자 10을 고려
            number += d
         
        # d가 S, D, T 중 하나일 때
        elif d in ("S","D", "T"):
        	# S, D, T가 나왔다는 건 점수 문자열이 다 나왔다는 것
            # 점수 저장
            score.append(int(number))
            # number 초기화
            number = ''
            
            # 종류별 제곱
            if d == "S":
                score[-1] **= 1
            elif d == "D":
                score[-1] **= 2
            else:
                score[-1] **= 3
                
        # d가 *, # 중 하나일 때
        elif d in ("*", "#"):
            if d == "*":
                score[-1] *= 2
                # 아직 점수가 하나일 때
                if len(score) == 1:  
                    continue
                score[-2] *= 2
            else:
                score[-1] *= -1
    return sum(score)

[프로그래머스 : PYTHON] 직사각형 별찍기

by cijbest — Sat, 5 Jun 2021 18:03:40 +0900

문제 설명

이 문제에는 표준 입력으로 두 개의 정수 n과 m이 주어집니다.
별(*) 문자를 이용해 가로의 길이가 n, 세로의 길이가 m인 직사각형 형태를 출력해보세요.

제한 조건

n과 m은 각각 1000 이하인 자연수입니다.

예시

입력

5 3

출력

*****
*****
*****

전체코드

a, b = map(int, input().strip().split(' '))
print((a * '*' + '\n') * b)

[프로그래머스 : PYTHON] x만큼 간격이 있는 n개의 숫자

by cijbest — Sat, 5 Jun 2021 18:01:26 +0900

문제 설명

함수 solution은 정수 x와 자연수 n을 입력 받아, x부터 시작해 x씩 증가하는 숫자를 n개 지니는 리스트를 리턴해야 합니다. 다음 제한 조건을 보고, 조건을 만족하는 함수, solution을 완성해주세요.

제한 조건

x는 -10000000 이상, 10000000 이하인 정수입니다.
n은 1000 이하인 자연수입니다.

입출력 예

x	n	answer
2	5	[2,4,6,8,10]
4	3	[4,8,12]
-4	2	[-4, -8]

전체코드

def solution(x, n):
    answer = []
    
    for i in range(1, n+1):
        answer.append(x * i)
    
    return answer

[프로그래머스 : PYTHON] 행렬의 덧셈

by cijbest — Sat, 5 Jun 2021 17:59:09 +0900

문제 설명

행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.

제한 조건

행렬 arr1, arr2의 행과 열의 길이는 500을 넘지 않습니다.

입출력 예

arr1	arr2	return
[[1,2],[2,3]]	[[3,4],[5,6]]	[[4,6],[7,9]]
[[1],[2]]	[[3],[4]]	[[4],[6]]

문제풀이

처음엔 zip()으로 풀고 싶었는데 zip 함수에 대한 이해가 완전하지 않아서 결국 for문 두개로 하나씩 탐색해 가면서 풀었다. '다른 사람 풀이'를 참고해서 풀면 좋다.

arr1 => [[1,2],[2,3]], arr2 => [[3,4],[5,6]]

첫 번째 zip : [ ( [1,2], [3,4] ), ( [2,3], [5,6] ) ]

두 번째 zip : [ ( (1, 3), (2, 4) ), ( (2, 5), (3, 6) ) ]

전체코드

def solution(arr1, arr2):
    answer = []
    for i in range(len(arr1)):
        tmp = []
        for j in range(len(arr1[0])):
            tmp.append(arr1[i][j] + arr2[i][j])
        answer.append(tmp)
        
    return answer

다른 사람 풀이

def solution(A,B):
    answer = [[c + d for c, d in zip(a, b)] for a, b in zip(A,B)]
    return answer

[프로그래머스 : PYTHON] 핸드폰 번호 가리기

by cijbest — Sat, 5 Jun 2021 17:52:13 +0900

문제 설명

프로그래머스 모바일은 개인정보 보호를 위해 고지서를 보낼 때 고객들의 전화번호의 일부를 가립니다.
전화번호가 문자열 phone_number로 주어졌을 때, 전화번호의 뒷 4자리를 제외한 나머지 숫자를 전부 *으로 가린 문자열을 리턴하는 함수, solution을 완성해주세요.

제한 조건

s는 길이 4 이상, 20이하인 문자열입니다.

입출력 예

phone_number	return
"01033334444"	"*******4444"
"027778888"	"*****8888"

문제풀이

문자열.rjust()를 이용하여 풀었지만 '다른 사람 풀이' 처럼 '*'에 원하는 수만큼 곱해주어도 된다.

전체코드

def solution(phone_number):
    
    answer = ''
    answer = answer.rjust(len(phone_number)-4, '*') + phone_number[-4:]
    
    return answer

다른 사람 풀이

def solution(phone_number):
    return "*"*(len(phone_number)-4) + phone_number[-4:]