끼룽의 블로그

T = 10

for t in range(1, T+1):
    lst = []
    _ = int(input())
    for i in range(100):
        lst.append(list(map(int, input().split())))

    max = 0
    for i in range(100):
        max += lst[0][i]


    for i in range(100):
        total = 0
        for j in range(100):
            total += lst[i][j]
        if max < total:
            max = total

    for j in range(100):
        total = 0
        for i in range(100):
            total += lst[i][j]
        if max < total:
            max = total

    total = 0
    for i in range(100):
        total += lst[i][i]

    if max < total:
        max = total

    total = 0
    for i in range(100):
        total += lst[99 - i][i]

    if max < total:
        max = total

    print('#{} {}'.format(t, max))

T = int(input())

di = [0, 1, 0, -1]
dj = [1, 0, -1, 0]

for t in range(1, T+1):
    n = int(input())

    lst = [[0 for _ in range(n+2)] for _ in range(n+2)]

    for i in range(1, n+2):
        lst[0][i] = -1
        lst[n + 1][i] = -1
        lst[i][0] = -1
        lst[i][n + 1] = -1

    i = 1
    j = 0
    num = 1
    d = 0
    while num <= n*n:
        next_i = i + di[d]
        next_j = j + dj[d]

        if lst[next_i][next_j]:
            d = (d + 1) % 4
            continue

        i = next_i
        j = next_j
        lst[i][j] = num
        num += 1

    print('#{}'.format(t))
    for i in range(1, n+1):
        print(*lst[i][1:n+1], sep=' ')

T = int(input())

for t in range(1, T+1):
    abcde = [0, 0, 0, 0, 0]
    lst = [2, 3, 5, 7, 11]

    n = int(input())

    for i in range(len(lst)):
        num = lst[i]
        while n % num == 0:
            n //= num
            abcde[i] += 1

    a = abcde[0]
    b = abcde[1]
    c = abcde[2]
    d = abcde[3]
    e = abcde[4]
    print('#{} {} {} {} {} {}'.format(t, a, b, c, d, e))

def check(table, i, j, direction_dict):
    dol = table[i][j]

    flag = False
    for key, direction in direction_dict.items():

        flag2 = False
        for di, dj in zip(direction['di'], direction['dj']):
            i2 = i + di
            j2 = j + dj
            if i2 >= 19 or j2 >= 19 or i2 < 0 or j2 < 0:
                flag2 = True
                break
            if table[i2][j2] != dol:
                flag2 = True
                break

        if flag2:
            continue

        flag3 = False
        for di6, dj6 in zip(direction['check_i6'], direction['check_j6']):
            i6 = i + di6
            j6 = j + dj6
            if i6 < 19 and j6 < 19 and i6 >= 0 and j6 >= 0:
                if table[i6][j6] == dol:
                    flag3 = True
                    break

        if flag3:
            continue

        flag = True
        break

    return flag


if __name__=='__main__':

    table = [[0 for _ in range(19)] for _ in range(19)]

    direction_dict = {
        'row': {
            'di': [0, 0, 0, 0],
            'dj': [1, 2, 3, 4],
            'check_i6': [0, 0],
            'check_j6': [5, -1]
        },
        'col': {
            'di': [1, 2, 3, 4],
            'dj': [0, 0, 0, 0],
            'check_i6': [5, -1],
            'check_j6': [0, 0]
        },
        'cross_down': {
            'di': [1, 2, 3, 4],
            'dj': [1, 2, 3, 4],
            'check_i6': [5, -1],
            'check_j6': [5, -1]
        },
        'cross_up': {
            'di': [-1, -2, -3, -4],
            'dj': [1, 2, 3, 4],
            'check_i6': [-5, 1],
            'check_j6': [5, -1]
        }
    }

    for i in range(19):
        row = list(map(int, input().split()))
        for j in range(19):
            table[i][j] = row[j]

    flag = False
    for i in range(19):
        if flag:
            break
        for j in range(19):
            if table[i][j] != 0:
                if check(table, i, j, direction_dict):
                    print(table[i][j])
                    print('{} {}'.format(i + 1, j + 1))
                    flag = True
                    break

    if not flag:
        print(0)

T = 10

for t in range(1, T+1):
    dump = int(input())
    h_list = list(map(int, input().split()))

    cnt_list = [0 for _ in range(101)]

    for h in h_list:
        cnt_list[h] += 1

    l = 1
    r = 100

    while True:
        while cnt_list[r] == 0:
            r -= 1

        while cnt_list[l] == 0:
            l += 1

        if dump <= 0:
            break

        cnt_list[r] -= 1
        cnt_list[l] -= 1

        cnt_list[r - 1] += 1
        cnt_list[l + 1] += 1
        dump -= 1

    result = r - l
    print('#{} {}'.format(t, result))

T = int(input())

for t in range(1, T+1):
    n, q = map(int, input().split())
    lst = [0 for _ in range(n)]

    for i in range(q):
        l, r = map(int, input().split())
        for j in range(l - 1, r):
            lst[j] = i + 1

    result = '#{} '.format(t)

    for num in lst:
        result += '{} '.format(num)

    print(result.strip())

if __name__=='__main__':
    n = int(input())
    balls = input().strip()

    cnt_list = []

    parse_ball = balls.lstrip('R')
    cnt_list.append(parse_ball.count('R'))
    parse_ball = balls.lstrip('B')
    cnt_list.append(parse_ball.count('B'))
    parse_ball = balls.rstrip('R')
    cnt_list.append(parse_ball.count('R'))
    parse_ball = balls.rstrip('B')
    cnt_list.append(parse_ball.count('B'))

    print(min(cnt_list))

풀이

1. 주사위들은 아랫 면이 무엇이 올지 정해지면, 윗면과 옆면으로 무슨 숫자들이 오는지 알 수 있다.
   이를 이용하여, 옆 면으로 올 수 있는 숫자들 중 _최댓값_을 한쪽 면으로 몰아버리면 된다.

2. 아랫 면의 인덱스를 넣으면 윗 면의 숫자가 무엇인지, 또 옆 면으로 올 수 있는 숫자들이 무엇인지 바로 알 수 있도록 key-value 형태, 즉 딕셔너리를 만든다.

   bottom_to_top = {
       0: 5,
       1: 3,
       2: 4,
       3: 1,
       4: 2,
       5: 0
   }
   
   get_side_idxes = {
       0: [1, 2, 3, 4],
       1: [0, 2, 4, 5],
       2: [0, 1, 3, 5],
       3: [0, 2, 4, 5],
       4: [0, 1, 3, 5],
       5: [1, 2, 3, 4]
   }

3. 옆 면들의 인덱스를 갖고 해당 인덱스의 주사위 숫자들 중 최댓값을 구하려면 아래와 같이 해야 한다.

   dice_nums = [6, 4, 2, 5, 1, 3]
   side_idxes = [1, 2, 3, 4]
   
   side_nums = []
   for idx in side_idxes:
       num = dice_nums[idx]
       side_nums.append(num)
   
   max_num = max(side_nums)

   하지만, 이를 컴프리헨션 문법을 이용하면 간단하게 수행할 수 있다.

   dice_nums = [6, 4, 2, 5, 1, 3]
   side_idxes = [1, 2, 3, 4]
   
   max_num = max(dice_nums[idx] for idx in side_idxes)

   혹은, 람다식과 map 함수를 이용해서도 할 수 있다.

   max_num = max(map(lambda idx: dice_nums[idx], side_idxes))

   두 방법으로 코드를 제출해 본 결과, 람다식과 map 함수를 이용한 경우가 더 수행시간이 빨랐다.

코드

n = int(input())

dice_nums = []
for i in range(n):
    dice_nums.append(list(map(int, input().split())))

bottom_to_top = {
    0: 5,
    1: 3,
    2: 4,
    3: 1,
    4: 2,
    5: 0
}

get_side_idxes = {
    0: [1, 2, 3, 4],
    1: [0, 2, 4, 5],
    2: [0, 1, 3, 5],
    3: [0, 2, 4, 5],
    4: [0, 1, 3, 5],
    5: [1, 2, 3, 4]
}

max_total = 0
for i in range(6):
    top_idx = bottom_to_top[i]
    top_num = dice_nums[0][top_idx]
    side_idxes = get_side_idxes[i]
    # total = max(map(lambda idx: dice_nums[0][idx], side_idxes))
    total = max(dice_nums[0][idx] for idx in side_idxes)

    for j in range(1, len(dice_nums)):
        bottom_idx = dice_nums[j].index(top_num)
        top_idx = bottom_to_top[bottom_idx]
        top_num = dice_nums[j][top_idx]
        side_idxes = get_side_idxes[bottom_idx]
        # total += max(map(lambda idx: dice_nums[j][idx], side_idxes))
        total += max(dice_nums[j][idx] for idx in side_idxes)

    if max_total < total:
        max_total = total

print(max_total)