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


n,m,k = map(int,input().split())

fireball = {}

for _ in range(m):
    temp = list(map(int,input().split()))
    fireball[(temp[0]-1,temp[1]-1)] = []
    # 질량, 속도, 방향
    fireball[(temp[0]-1,temp[1]-1)].append([temp[2],temp[3],temp[4]])


for _ in range(k):
    new_fireball = {}
    for ind,vals in fireball.items():
        for val in vals:
            new_x = (ind[0] + val[1]*dx[val[2]])%n
            new_y = (ind[1] + val[1]*dy[val[2]])%n

            if new_fireball.get((new_x,new_y)):
                new_fireball[(new_x,new_y)].append([val[0],val[1],val[2]])
            else:
                new_fireball[(new_x,new_y)] = [[val[0],val[1],val[2]]]
    fireball ={}
    for ind,vals in new_fireball.items():
        if len(vals) > 1:
            total_weight = 0
            total_speed = 0
            total_direction = []
            for val in vals:
                total_weight += val[0]
                total_speed += val[1]
                total_direction.append(val[2])
            next_weight = total_weight//5
            next_speed = total_speed//len(vals)
            if next_weight:
                total_direction = list(map(lambda x: x%2 ,total_direction))
                if sum(total_direction) == 0 or sum(total_direction) == len(vals):
                    next_direction = [0,2,4,6]
                else:
                    next_direction = [1,3,5,7]
                fireball[ind] = []
                for i in range(4):
                    fireball[ind].append([next_weight,next_speed,next_direction[i]])

        else:
            fireball[ind] = vals

result = 0
for ind,vals in fireball.items():
    for val in vals:
        result += val[0]
print(result)

문제에 나온 내용을 그대로 시뮬레이션을 해주면 되는 것이었다.

이러한 무한의 길이를 가진 행렬문제나, 한 위치에 여러가지 정보를 저장해야하는 경우가

나오면 리스트로 구현하기 보단, 딕셔너리로 해서 위치좌표를 키로 지정하고 밸류 값에 여러가지 정보를 저장하는 방식을 선호한다.

 

이 문제에서 주의해야할 점은 행렬의 범위를 벗어나면 반대편으로 나오는 것이다. 

이 부분은 나는 n으로 나눈 나머지로 해결했다. 그 뒤에는 딕셔너리에 저장된 값 중 길이가 2 이상인 경우에는 문제에서 주어졌던 조건에 맞추어, 분리가 되도록 구현했다.

direction = [0,1,2,3]
# dire의 값이 0 : 좌
#  1: 하
#  2: 우
#  3: 상
move_dire = [[0,-1],
[1,0],
[0,1],
[-1,0]]
# 토네이도가 부는 방향 좌 하 우 상
#  -90도 회전 list(zip(*tornado))[::-1]
tornado = [[0,0,2,0,0],
[0,10,7,1,0],
[5,0,0,0,0],
[0,10,7,1,0],
[0,0,2,0,0]]



N = int(input())
arr = [list(map(int,input().split())) for _ in range(N)]

k = N**2 -1
cnt = 0
number_cnt = 1 
# number_cnt는 현재 방향으로 진행되는 최대거리를 알려주는 것이다.
double_cnt = 0
# 최대거리가 진행되는 횟수를 알려주는 것이다.
cur_cnt = 0
# 현재 이동 횟수이다.
cur_dire = 0 
# 현재 진행 방향이다.
# 이 문제에서 보면 알 수 있듯이, 좌하우상 순서로 진행되면 그 거리는 1,1,2,2,3,3,4,4,5,5,6,6 순으로 진행된다.
# 최대거리가 동일한게 2번 반복되는 것을 알 수 있다.
location = [N//2,N//2]
result = 0

while True:
    # 최대 거리와 현재 이동거리가 같다면 방향이 바뀌어야하는 것이므로, 방향을 바꾸면서 최대거리를 갱신해주는 작업을 해준다.
    if cur_cnt == number_cnt:
        cur_cnt = 0
        double_cnt += 1
        cur_dire = (cur_dire+1)%4
        tornado = list(zip(*tornado))[::-1]
        # -90도 회전을 해주는 간편한 방법이다. 
        if double_cnt == 2:
            # double_cnt가 2라는 것은 최대 이동거리가 동일한게 2번 반복된것이니, 최대 이동거리를 증가시켜줘야한다.
            double_cnt = 0
            number_cnt += 1
    # target_location은 현재 토네이도의 위치인 x에서 y로 갈때 y의 위치이다.
    target_location = [location[0]+move_dire[cur_dire][0],location[1]+move_dire[cur_dire][1]]
    # total_more는 targetloaction에 있는 모래의 양이다.
    total_more = arr[target_location[0]][target_location[1]]
    # torandao로 이동하는 것을 해주는 것이다.
    for i in range(5):
        for j in range(5):
            move_ind = [target_location[0]+i-2,target_location[1]+j-2]
            more = int(tornado[i][j]*arr[target_location[0]][target_location[1]]/100)
            if 0<=move_ind[0]<N and 0<=move_ind[1]<N:
                arr[move_ind[0]][move_ind[1]] += more
            # 만약 범위를 벗어나면, 결과값에 추가해준다.
            else:
                if more:
                    result += more
            # 흩날리고 남은 모래를 a의 모래가 되므로 구해준다.
            total_more -= more
    cur_cnt += 1
    last_location = [location[0]+2*move_dire[cur_dire][0],location[1]+2*move_dire[cur_dire][1]]
    # a의 위치가 범위를 벗어나면, result에 추가해주고, 아니면 해당위치에 모래를 추가해준다.
    if 0<=last_location[0]<N and 0<=last_location[1]<N:
        arr[last_location[0]][last_location[1]] += total_more
    else:
        result += total_more
    location = [location[0]+move_dire[cur_dire][0],location[1]+move_dire[cur_dire][1]]
    arr[location[0]][location[1]] = 0
    if location[0] == 0 and location[1] == 0:
        break
print(result)

 

 처음 풀었던 방식은 문제에 나와있는걸 그대로 구현해주었다.

이 문제를 풀때 중요한것은 방향전환과 그 반복성이 어떻게 진행되는지 찾아주고 그것을 구현해주는 방식이다.

하지만 코드길이가 길고, 변수도 많아서 문제를 풀때 헷갈리는게 많았다.

 

import sys

def blowSand(x,y,dire):
    global N
    ret = 0
    init_sand = arr[x][y]
    for i in range(10):
        if i == 9:
            sand = arr[x][y]
        else:
            sand = int(init_sand * rate[i]/100)
            arr[x][y] -= sand
        move_x = x + blowx[dire][i]
        move_y = y + blowy[dire][i]

        if 0<=move_x<N and 0<=move_y<N:
            arr[move_x][move_y] += sand
        else:
            ret += sand
    arr[x][y] = 0
    return ret

dx = [0,1,0,-1]
dy = [-1,0,1,0]
rate = [1, 1, 7, 7, 10, 10, 2, 2, 5]

blowx = [[-1, 1, -1, 1, -1, 1, -2, 2, 0,0], #left
[-1, -1, 0, 0, 1, 1, 0, 0, 2,1],   #down
[-1, 1, -1, 1, -1, 1, -2, 2, 0,0], #right
[1, 1, 0, 0, -1, -1, 0, 0, -2,-1],]  #up

blowy = [[1, 1, 0, 0, -1, -1, 0, 0, -2,-1],  #left
[-1, 1, -1, 1, -1, 1, -2, 2, 0,0], #down
[-1, -1, 0, 0, 1, 1, 0, 0, 2,1],   #right
[-1, 1, -1, 1, -1, 1, -2, 2, 0,0]] #up
N = int(sys.stdin.readline())
arr =[list(map(int,sys.stdin.readline().split())) for _ in range(N)]
x,y = N//2,N//2
i = 1
dire = 0
result = 0
while i<=N:
    j = 0
    while j <int(i):
        x = x + dx[dire%4]
        y = y + dy[dire%4]
        result += blowSand(x,y,dire%4)
        j += 1
    dire += 1
    i += 0.5
print(result)

위의 코드는 클론코딩한 것으로, 기본적인 원리는 위와 비슷하지만 좀 더 깔끔해서 보기가 편하다.

모래방향에 따른 x,y의 이동값을 전부 저장해준다. 그리고 그에 맞게 이동시 날라가는 비율을 적어준다.

 

여기서는 위에서 내가 했던 double_cnt 같은 것을 이용하지 않고 0.5 단위로 i의 값을 올려주고, 그것을 int화 함으로서 2번반복을 구현해냈다.

blowSand라는 함수를 통해, 날라간 모래 양을 계속 더해주고, 모래가 날라간 상황을 만들어줬다.

T = int(input())

dx = [-2,-1,1,2,2,1,-1,-2]

dy = [-1,-2,-2,-1,1,2,2,1]

for tc in range(T):

    l = int(input())

    array = [list(map(int,input().split())) for _ in range(2)]



    start = array[0][:]

    end = array[1][:]

    if start == end:

        print(0)

    else:

        result = 0

        visited = [[0]*l for _ in range(l)]

        visited[start[0]][start[1]] = 1

        stack = []

        stack.append((start[0],start[1],0))

        while stack:

            x,y,cnt = stack.pop(0)

            if x == end[0] and y == end[1]:

                result = cnt

                break

            for i in range(8):

                nx = x + dx[i]

                ny = y + dy[i]

                if 0<=nx<l and 0<=ny<l:

                    if not visited[nx][ny]:

                        visited[nx][ny] = 1

                        stack.append((nx,ny,cnt+1))

        print(result)

BFS를 이용해서 거리 변수만 추가해주면 되는 문제였다.

내 최초 풀이

# step 1 봄버맨 폭탄 설치 설치시간 동일
# step 2 정지
# step 3 폭탄이 설치되어 있지않은 모든칸에 폭탄을 설치
# step 4 1초가 지난후 3초전에 설치된 폭탄이 모두 폭발한다.
# step 5 step 3 ~ step 4 반복
dx = [1,-1,0,0]
dy = [0,0,1,-1]

R,C,N = map(int,input().split())
# R은 행 C은 열 N은 초
bomb = [list(input()) for _ in range(R)]
times = [[-1]*C for _ in range(R)]

for x in range(R):
    for y in range(C):
        if bomb[x][y] == 'O':
            times[x][y] = 3

        

for k in range(N):
    bomb_set = set()
    if k%2:
        for x in range(R):
            for y in range(C):
                times[x][y] -= 1
                if bomb[x][y] == '.':
                    times[x][y] = 3
                    bomb[x][y] = 'O'
    else:
        for x in range(R):
            for y in range(C):
                times[x][y] -= 1
                if times[x][y] == 0:
                    bomb_set.add((x,y))
                    for i in range(4):
                        nx = x + dx[i]
                        ny = y + dy[i]
                        if 0<=nx<R and 0<=ny<C:
                            bomb_set.add((nx,ny))
    for nx,ny in bomb_set:
        bomb[nx][ny] = '.'





for rows in range(R):
    print(''.join(bomb[rows]))

내 최초 풀이 방식은 문제의 방식을 그대로 따라한것이다.

문제를 보면 알수 있듯이 2의 배수의 시간일때는 폭탄을 설치해주는 것을 알 수 있다.

폭탄을 저장할 수 있는 리스트와 폭탄이 폭파되기까지 걸리는 시간을 저장해주기 위한 리스트를 두 종류를 준비해주었다.

그래서 2의 배수의 시간일때에는 폭탄을 설치해주고, 그 외의 시간에는 폭탄의 시간이 줄어들면서 터지는 폭탄의 위치들을 집합에 모아주고, 그것을 폭파해주는 방식으로 해주어 시뮬레이션을 해주었다.

 

이 풀이는 단순히 문제에 적혀져 있는 방식대로 시뮬레이션을 돌린거다 보니, 시간이 오래걸렸다.

 

 

# heecheol1508 클론코딩


R,C,N = map(int,input().split())
board = [list(input()) for _ in range(R)]

if N%2 == 0:
    # 시간이 짝수일때는 무조건 전부 폭탄이 설치되기 때문에, 시간이 짝수일때는 전부 폭탄이 설치된 경우를 출력하면 된다.
    for _ in range(R):
        print('O'*C)
elif N == 1:
    # 1초일때는 초기 상태를 그대로 출력하면 된다.
    for row in board:
        print(''.join(row))
else:
    # 그 외의 시간일때는 나머지를 출력하면 된다.
    # 그런데 해당문제에서는 폭탄이 터지는 경우는 크게 2가지 밖에 없다.
    # 최초 설치된 폭탄 즉 0초에 설치된 폭탄이 터지는 경우와 
    # 2초에 설치된 폭탄 중에 최초 설치된 폭탄과 인접하지 않는 폭탄이 터지는 경우 2가지밖에 없다.
    # 그렇기 때문에 최초 설치된 폭탄이 터ㅣ는 시간대와 2초에 설치된 폭탄이 터지는 경우 두가지만 구분하면 된다.
    # 최초 설치된 폭탄이 터지는 시간대는 3초,7초,11초,15초로 4초 간격으로 터진다. 
    # 2초에 설치된 폭탄 중 최초 설치된 폭탄과 인접하지 않은 폭탄이 터지는 시간은 5초,9초,13초,17초이다.
    # 먼저 터지는 것은 최초 설치된 폭탄의 위치와 그와 인접한 폭탄이다. 그 부분만 폭탄이 터지는걸로 해주고 나머지는 폭탄이 설치된 걸로 만들어주면 된다.
    # 그래서 최초 폭탄이 터졌을때의 상황을 만들어주고, 그때의 시간이 3,7,11,15일때에는 그대로 출력하고,
    # 그때가 아닐때에는 2초에 설치된 폭탄이 터지는 경우이니 한번 더 폭탄이 터지는 것을 반복해주면 된다.
    bomb = []
    for x in range(R):
        for y in range(C):
            if board[x][y] == 'O':
                board[x][y] = '.'
                bomb.append((x,y))
            else:
                board[x][y] = 'O'
    dx = [1,-1,0,0]
    dy = [0,0,1,-1]
    for bx,by in bomb:
        for i in range(4):
            nx = bx + dx[i]
            ny = by + dy[i]
            if 0<=nx<R and 0<=ny<C:
                board[nx][ny] = '.'

    times = (N-3)%4
    if not times:
        for row in board:
            print(''.join(row))
    else:
        bomb = []
        for x in range(R):
            for y in range(C):
                if board[x][y] == 'O':
                    bomb.append((x,y))
                    board[x][y] = '.'
                else:
                    board[x][y] = 'O'
        for bx,by in bomb:
            for i in range(4):
                nx = bx + dx[i]
                ny = by + dy[i]
                if 0<=nx<R and 0<=ny<C:
                    board[nx][ny] = '.'
        for row in board:
            print(''.join(row))

위의 코드 같은 경우 백준의 heecheol1508님의 코드를 분석하고, 이해한뒤 클론코딩한 것이다.

문제를 보면 2의 배수시간일때에는 폭탄이 빈곳에 설치하기 때문에 모든 배열에 폭탄이 설치되는 것이 알 수 있다.

그래서 주어진 시간이 2의 배수이면 폭탄이 전부 설치된 것을 보여주면 된다.

그리고 폭탄이 터지는 경우는 2가지 케이스이다.

최초로 설치된 폭탄이 터지는 경우와 2초에 설치한 폭탄이 터지는 경우이다.

최초의 설치된 폭탄과 2초에 설치된 폭탄이 터질때 서로 영향을 못준다. 왜냐하면, 폭탄이 터지면서 상하좌우를 터트리고 연쇄 폭파가 일어나지 않기 때문에, 일종의 안전지대가 생성이 되는 것이다. 

그렇기 때문에 이런한 성향을 이용하여, 계산하면 된다.

최초 설치된 폭탄은 3초에 최초로 터지고 그 뒤로 7초 11초 15초 4의 간격으로 터진다.

그래서 처음에 설치된 폭탄들이 터졌을때의 상황을 만들어주고,

위의 시간이 아니면 2초에 설치된 폭탄들이 터지는 것을 구현해주면 된다.

'알고리즘 > 백준' 카테고리의 다른 글

[BOJ] 20057 마법사 상어와 토네이도  (0) 2021.01.10
[BOJ] 7562 나이트의 이동  (0) 2021.01.10
[BOJ] 16236 아기상어  (0) 2021.01.10
[BOJ] 14891 톱니바퀴  (0) 2021.01.09
[BOJ] 11654 아스키 코드  (0) 2021.01.09
# 16236번 아기상어
# N*N 크기에 물고기 M마리 아기상어 1마리
# 아기상어 초기 크기는 2,
# 자기보다 큰 물고기는 먹기x 지나가기 x
# 자기와 같은 물고기 먹기x, 지나가기 o
# 자기보다 작은 물고기 먹기 o 지나가기 o
# 아기상어는 자기 크기 만큼의 횟수만큼 물고기를 먹는다면 크기가 1 증가한다.
# 먹을 수 있는 물고기가 없으면 엄마상어에게 가기
# 먹을 수 있는 물고기가 1마리면 거리가 가장 가까운 물고기를 먹으러간다.
# 먹을수 있는 물고기가 가장 가까운 거리에 있는걸 먹는다. 위 1순위 왼쪽 2순위 위로 정렬 왼쪽으로 정렬 2중정렬
# 1~6 은 물고기 9은 아기상어 위치
dx = [-1,1,0,0]
dy = [0,0,-1,1]
N = int(input())
aquarium = [list(map(int,input().split())) for _ in range(N)]
fishs = []
for x in range(N):
    for y in range(N):
        if aquarium[x][y]:
            if aquarium[x][y] == 9:
                shark_x = x
                shark_y = y
time = 0
shark_size = 2
shark_eat = 0
flag = True
while flag:
    eat_fishs = []
    visited = [[0]*N for _ in range(N)]
    shark = []
    shark.append((shark_x,shark_y,0))
    visited[shark_x][shark_y] = 1
    while shark:
        x,y,distance = shark.pop(0)
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
            if 0<= nx < N and 0<= ny< N:
                if not visited[nx][ny]:
                    if aquarium[nx][ny] > shark_size:
                        continue
                    else:
                        visited[nx][ny] = 1
                        if aquarium[nx][ny] == shark_size or aquarium[nx][ny] == 0:
                            shark.append((nx,ny,distance+1))
                        else:
                            shark.append((nx,ny,distance+1))
                            eat_fishs.append((nx,ny,distance+1))
    if not len(eat_fishs):
        break
    else:
        eat_fishs.sort(key=lambda x: (x[2],x[0],x[1]))
        aquarium[shark_x][shark_y] = 0
        shark_x = eat_fishs[0][0]
        shark_y = eat_fishs[0][1]
        shark_eat += 1
        aquarium[shark_x][shark_y] = 9
        time += eat_fishs[0][2]
        if shark_eat == shark_size:
            shark_size += 1
            shark_eat = 0
print(time)
            
    

 

 

 

 아기상어 문제는 조건들을 정리하는 것이 먼저였다.

1. 상어보다 작거나 같은 크기의 물고기들은 지나갈수 있다.

2. 상어는 자기보다 작은 물고기만 먹는다.

3. 가장 가까운 물고기를 먼저 먹는다.

4. 같은 위치에 존재하면, x축이 작은 것을 1순위, y축이 작은것이 2순위이다.

5. 상어의 크기의 개수만큼의 물고기를 먹으면 상어가 커진다.

 

이 부분을 정리하고 풀면 쉬웠다.

 

기본적으로 BFS를 하는대신 상대적인 거리를 측정하기 위한 distance를 넣어주었다.

그래서 상어가 먹을 수 있는 모든 물고기의 위치를 파악해주고, 거리를 측정해주었다.

여기서 시간을 더 줄이고 싶으면, 어차피 BFS이기 때문에 최소거리로 측정이 된다.

그러므로, 최초로 먹을수 있는 물고기와의 거리를 측정하고 그 거리보다 큰 것들이 나오는 순간 BFS를 멈춰도 된다.

 

하지만 시간제한이 널널한 편이었고, 첫시도였기 때문에, 머리로만 생각하고 넘어갔다.

위와 같이 먹을 수 있는 물고기목록을 구한뒤에는 lambda를 통한 다중정렬을 해서 문제 조건에 맞게 오름차순으로 정리해준다.

그리고 선택된 물고기의 위치를 상어의 위치로 바꿔주고, 상어의 크기와 상어의 먹은 물고기의 수를 비교해줘서 같아지면 상어의 크기를 키워주고 먹은 물고기 수를 초기화 시켜줬다.

 

이 문제에서 시간이 좀 걸렸던 요인은 움직인 상어의 이전 위치의 좌표를 초기화 안 시켜줘서 생겼다. 그냥 상어의 최초위치만 파악하고 난뒤에는 상어의 위치는 지속적으로 추적이 가능하므로, 그냥 상어의 값을 0으로 바꿔주는게 더 편할수 있을 것 같다.

'알고리즘 > 백준' 카테고리의 다른 글

[BOJ] 7562 나이트의 이동  (0) 2021.01.10
[BOJ] 16918 봄버맨(풀이 방식 2종류)  (0) 2021.01.10
[BOJ] 14891 톱니바퀴  (0) 2021.01.09
[BOJ] 11654 아스키 코드  (0) 2021.01.09
[BOJ] 10989 수 정렬하기3  (0) 2021.01.09
import sys
from collections import deque
# 까다로웠던 점 
# 회전은 전부 판별이 되고 난뒤에, 작동한다
gears =[ list(deque(map(deque,sys.stdin.readline().split()))) for _ in range(4)]

K = int(sys.stdin.readline())
# 12시 0, 3시 2, 9시 6
# N극은 0 S극은 1
for _ in range(K):
    index,rotate = list(map(int,sys.stdin.readline().split()))
    leftindex = index-1
    leftrotate = -rotate
    rightrotate = -rotate
    rightindex = index+1
    rotatelist = []
    while leftindex >=1:
        origingear = list(gears[leftindex][0])
        leftgear = list(gears[leftindex-1][0])
        if origingear[6] == leftgear[2]:
            break
        else:
            rotatelist.append([leftindex-1,leftrotate])
        leftrotate = -leftrotate
        leftindex-=1
    while rightindex <=4:
        origingear = list(gears[rightindex-2][0])
        rightgear = list(gears[rightindex-1][0])
        if origingear[2] == rightgear[6]:
            break
        else:
            rotatelist.append([rightindex-1,rightrotate])
        rightrotate = -rightrotate
        rightindex+=1
    for rotateindex,rotation in rotatelist:
        gears[rotateindex][0].rotate(rotation)
    gears[index-1][0].rotate(rotate)


result = 0

for i in range(4):
    tw = gears[i][0].popleft()
    if tw == '1':
        result += 2**i

print(result)

이 문제에서 까다로웠던 점은 한번 사이클이 다 돌고 난뒤에 회전을 한다는 것이다. 그 부분을 처음에 놓쳤기에 틀렸다.

deque 모듈에는 rotate라는 메소드가 있으며, 양수를 적으면, 양수만큼 오른쪽으로 이동하고, 음수를 적으면 음수의 크기만큼 왼쪽으로 이동하는 것을 이용하여, 반시계와 시계방향의 회전을 구현했다.

'알고리즘 > 백준' 카테고리의 다른 글

[BOJ] 16918 봄버맨(풀이 방식 2종류)  (0) 2021.01.10
[BOJ] 16236 아기상어  (0) 2021.01.10
[BOJ] 11654 아스키 코드  (0) 2021.01.09
[BOJ] 10989 수 정렬하기3  (0) 2021.01.09
[BOJ] 9498 시험성적  (0) 2021.01.09
print(ord(input()))

'알고리즘 > 백준' 카테고리의 다른 글

[BOJ] 16236 아기상어  (0) 2021.01.10
[BOJ] 14891 톱니바퀴  (0) 2021.01.09
[BOJ] 10989 수 정렬하기3  (0) 2021.01.09
[BOJ] 9498 시험성적  (0) 2021.01.09
[BOJ] 7576 토마토  (0) 2021.01.09
# 출력을 할때에도 여러번 반복하는 것이면 곱해서 하자 곱하기가 된다.


import sys
N = int(sys.stdin.readline())
array = [0 for _ in range(10001)]
for _ in range(N):
    num = int(sys.stdin.readline())
    array[num] += 1
for k in range(10001):
    print(f'{k}\n'*array[k],end='')

처음에 출력을 할떄

if array[k]:
   for _ in range(array[k]):
        pirnt(k)

위와 같은 식으로 했었다. 그랬더니 무수한 메모리 초과 오류가 발생했다.

아마도 매번 range(array[k]) 만큼의 리스트를 만들어줘야했기에, 메모리가 초과 된것 같다.

 

크게 두가지 방법이 있는것 같아다.

 

sys에 있는 write를 이용해 출력을 하는방법과

print()를 횟수만큼 곱해서 하는방법이 있었다.

그 중에서 나는 후자를 선택했다.

'알고리즘 > 백준' 카테고리의 다른 글

[BOJ] 14891 톱니바퀴  (0) 2021.01.09
[BOJ] 11654 아스키 코드  (0) 2021.01.09
[BOJ] 9498 시험성적  (0) 2021.01.09
[BOJ] 7576 토마토  (0) 2021.01.09
[BOJ] 7569 토마토  (0) 2021.01.09

+ Recent posts