[SWEA] D2 - Python 풀이

SW Expert Academy

1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기

#1. 최빈수 출력 - Counter() 이용
from collections import Counter

T = int(input())

for test_case in range(1, T + 1):
    idx = int(input())
    scores = list(map(int,input().split()))
    c = Counter(scores).most_common()[0][0] #Counter 최빈값 내림차순 나열, 최빈값 튜블 [0][0] 가장 큰 수 출력

    print(f"#{idx}",c)


# 2. 딕셔너리 이용
T = int(input())

for tc in range(1, T+1):
    idx = int(input())
    scores = list(map(int, input().split()))
    freq = {}
    for v in scores:
        freq.setdefault(v,0)
        freq[v] += 1
    freq_num, mode_freq = max(freq.items(), key=lambda x:x[1])
    print(f"#{idx}",freq_num)


#3. 정석 배열 이용
T = int(input())
for i in range(1, T + 1):
    num = input()
    arr = list(map(int, input().split()))
    num_arr = [0 for _ in range(101)]

    for el in arr: #점수 값을 토대로 배열에 최빈값 카운트 값 갱신
        num_arr[el] += 1

    max_num = 0
    idx = 0

    for el in range(len(num_arr)):
        if max_num <= num_arr[el]: #최빈값 max_num에 넣음
            max_num = num_arr[el]
            idx = el #최빈값에 해당하는 점수

    print("#" + num, idx)

1284. 수도 요금 경쟁

#P, Q, R, S, W(1 ≤ P, Q, R, S, W ≤ 10000, 자연수)
#요금 저렴한 회사를 골라서 그 요금 계산
T = int(input())
price = 0
for tc in range (1,T+1):
    P, Q, R, S, W = map(int, input().split())
    A_price = P*W
    B_price_over = Q+(W-R)*S
    #요금 더 저렴한 회사 고르기 -> 그회사 계산
    if R >=W: #B사 사용량 기본요금
        if A_price < Q:
            #A사 요금 계산 출력
            print(f'#{tc}', A_price)
        else:
            #B사 요금 계산 출력
            print(f'#{tc}', Q)

    else: #B사 초과요금
        if A_price < B_price_over:
            #A사 요금 계산 출력
            print(f'#{tc}', A_price)
        else:
            #B사 요금 계산 출력
            print(f'#{tc}', B_price_over)

1288. 새로운 불면증 치료법 (양세기)

#set 집합에 각 자리수 넣음 (.update([]))
#튜플 0~9완성되면 횟수 카운트 리턴 양세기 종료


T = int(input())
for test_case in range(1, T + 1):
    N = int(input())
    N_set = set([])
    k=1

    while(True):
        Num = N*k
        str_N = str(Num)
        str_N_len = len(str_N)

        for i in str_N:
            N_set.add(i)

        if len(N_set) == 10:
            break
        k += 1
    print(f"#{test_case}", Num)

1928. Base64 Decoder

[SWEA D2-1928] Base64 Decoder - Python

#6비트 잘린 값 4개 모아서 24비트
# - > 8byte로 다시 잘라서 디코딩

T = int(input())

for tc in range(1,T+1):
    B64_str = str(input())
    Binary_B64 = "" #입력값 2진수 형태로 저장할 변수
    answer = ""
    for i in B64_str:
        if i.isupper(): #대문자 A -> 0시작
            Binary_B64 += format(ord(i) - ord('A'),'b').zfill(6) #해당 문자->int 형 변환-> 6bit길이 2진수로

        elif i.islower(): #소문자 a -> 26시작
            Binary_B64 += format(ord(i) - ord('a') + 26,'b').zfill(6)

        elif i.isdigit():#숫자 0 -> 52시작
            Binary_B64 += format(ord(i) - ord('0') + 52,'b').zfill(6)

        elif i == '+':
            Binary_B64 += format(62,'b').zfill(6)

        elif i == '/':
            Binary_B64 += format(63,'b').zfill(6)

    for i in range(0,len(Binary_B64),8): #8bit씩 잘라서 아스키코드 문자로 변환
        answer += chr(int(Binary_B64[i:i+8],2)) #자른 8bit를 해당 아스키코드로 변환

    print(f'#{tc}',answer)

1940. 가랏! RC카!

T = int(input())
for tc in range(1,T+1):
    distance = 0  # 거리 = 속도*시간
    velocity = 0  # 속도
    N = int(input()) #커맨드 갯수

    for i in range(N):
        command = list(map(int, input().split()))

        if command[0] == 0:
            distance += velocity #sec는 1이므로, 거리 = 1*속도
        else:
            if command[0] == 1:
                velocity += command[1] #가속
                distance += velocity

            elif command[0] == 2:
                velocity -= command[1]
                if velocity < 0:
                    velocity = 0
                distance += velocity
    print(f"#{tc}", distance)

1945. 간단한 소인수분해

def Factorization(N, div):
    cnt = 0
    while (N%div)==0:
        N = N // div
        cnt += 1
    return N, cnt

T = int(input())

for tc in range(1,T+1):
    N = int(input())

    N, a = Factorization(N, 2)
    N, b = Factorization(N, 3)
    N, c = Factorization(N, 5)
    N, d = Factorization(N, 7)
    N, e = Factorization(N, 11)

    print(f"#{tc}", a, b, c, d, e)

1946. 간단한 압축 풀기

T = int(input())

for tc in range(1,T+1):
    N = int(input()) #숫자쌍 개수
    answer = ""
    for i in range(0, N*2, 2): #Ci에 숫자쌍 하나씩 값 입력
        Ci = list(map(str, input().split()))
        answer += Ci[0]*int(Ci[1])

    print(f"#{tc}")
    for i in range(len(answer)):
        if i%10==0 and i !=0:
            print('')
        print(answer[i],end="")
    print('')

#Ci를 리스트 말고 변수 두개 잡고 넣어봤더니 메모리도 더 차지하고 실행시간도 길었다.
#그냥 리스트 변수 하나만 써서 연산하는게 더 효율적

1948. 날짜 계산기

T = int(input())
month_end = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

for tc in range(1, T+1):
    date = list(map(int, input().split()))
    month_diff = date[2] - date[0]
    answer = 0
    idx = 0

    if month_diff == 0:
        print(f'#{tc}',date[3] - date[1] + 1)
        continue

    idx = date[0] - 1
    answer += month_end[idx] - date[1]

    for i in range(1,month_diff):
        idx = date[0]+i-1
        answer += month_end[idx]

    answer += date[3]+1

    print(f'#{tc}', answer)

########################################################################################
#깔끔한 코드
months = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

for tc in range(1, int(input())+1):
    m1, d1, m2, d2 = map(int, input().split())
    ans = 0

    # 같은 달에 위치할 경우
    if m1 == m2:
        ans = d2 - d1 + 1

    else:
        # 시작하는 달
        ans = months[m1] - d1 + 1
        # 중간에 있는 달
        for i in range(m1 + 1, m2):
            ans += months[i]
        # 마지막 달
        ans += d2
    print(f'#{tc} {ans}')

1954. 달팽이 숫자

T = int(input())

for tc in range(1,T+1):
    size = int(input())
    snail = [[0]*size for _ in range(size)] #달팽이 2차원 배열 생성
    direction = 0  # 우:0, 하:1, 좌:2, 상:3
    num_fill = size #해당하는 한 방향으로 채우는 숫자 개수 설정.

    row, col = 0,-1 #좌표 초기값

    dr = [0,1,0,-1] #우,하,좌,상 : 방향에 따른 row값 변화량
    dc = [1,0,-1,0] #col 변화량

    num = 0
    while num < size*size : # 2차원 배열 값 넣을 만큼 반복
        #한 방향 채우기
        for _ in range(num_fill):
            row += dr[direction]
            col += dc[direction]
            num += 1
            snail[row][col] = num

        direction += 1 #다음 방향을 위해 방향값 변화

        if direction % 4 == 0: #방향 초기화
            direction = 0

        if direction % 2:
            num_fill -= 1

    print(f"#{tc}")
    for i in range(size):
        print(*snail[i])

1959. 두 개의 숫자열

T = int(input())

for tc in range(1,T+1):
    N, M = map(int, input().split())
    Ai = list(map(int, input().split()))
    Bj = list(map(int, input().split()))

    #1. 배열 나누기
    if N<M:
        min_li = Ai
        max_li = Bj
    else:
        min_li = Bj
        max_li = Ai

    loop = len(max_li)-len(min_li)+1
    value = [0]*loop

    #2. 움직여보면서 마주보는 수 곱하고 더하고 계산
    for i in range(loop):
        for j in range(len(min_li)):
            value[i] += min_li[j]*max_li[i+j]

    print(value)

    #3. 더 큰 값 프린트
    print(f"#{tc}", max(value))

1961. 숫자 배열 회전

T = int(input())

for tc in range(1,T+1):
    N = int(input())
    matrix = []

    # 반복하면서 2차원 N*N 리스트에 값 저장
    for i in range(N):
        matrix.append(list(map(int, input().split())))

    #90도, 180도 270도 회전 모양 출력 (한줄씩 같이)
    #90도 : 왼쪽 밑에서 위로 - 시작점: 좌하단
    #180도 : 오른쪽 밑에서 좌로 - 시작점 : 우하단
    #270도 : 오른쪽 위에서 아래로 - 시작점 : 우상단

    print(f"#{tc}")
    for i in range(N):
        # 출력할 좌표 초기화
        row = [N, 0, -1]
        col = [0, N, 0]

        for j in range(N):
            row[0] -= 1
            col[0] = i
            print(matrix[row[0]][col[0]], end="")
        print(" ",end="")

        for k in range(N):
            row[1] = N-1-i
            col[1] -= 1
            print(matrix[row[1]][col[1]], end="")
        print(" ",end="")

        for l in range(N):
            row[2] += 1
            col[2] = N-1-i
            print(matrix[row[2]][col[2]], end="")
        print("")

1966. 숫자를 정렬하자

T = int(input())

for tc in range(1,T+1):
    N = int(input())
    nums = sorted(map(int, input().split()))
    print(f"#{tc}", *nums)

1970. 쉬운 거스름돈

# 최소가 되는 각 지폐별 거스름돈 개수 출력

T = int(input())

for tc in range(1, T+1):
    N = int(input())
    nums = [0,0,0,0,0,0,0,0] # 거스름돈 개수 초기화
    money = [50000,10000,5000,1000,500,100,50,10]

    for i in range(8):
        nums[i] = N // money[i]
        N = N - nums[i] * money[i]

    print(f"#{tc}")
    print(*nums)

1974. 스도쿠 검증

T = int(input())

for tc in range(1, T+1):
    #스도쿠 9*9 2차원 배열 저장
    sudoku = [list(map(str,input().split())) for _ in range(9)]
    offset_row = [0, 0, 0, 3, 3, 3, 6, 6, 6] # 3*3 격자 검증을 위한 시작 주소
    offset_col = [0, 3, 6, 0, 3, 6, 0, 3, 6]
    state = True

    #1. 각 가로줄 검증
    for i in range(9):
        checker = set(sudoku[i])
        if len(checker) != 9:#검증 실패
            state = False
            break

    #2. 각 세로줄 검증
    for i in range(9):
        row = [s[i] for s in sudoku] #세로줄 한줄
        checker = set(row)
        if len(checker) != 9: #검증 실패
            state = False
            break

    #3. 3*3 격자 검증
    for idx in range(9): #3*3 격자 9개
        checker = set()
        for i in range(3): #한 격자 만큼 검증
            for j in range(3):
                checker.add(sudoku[i+offset_row[idx]][j+offset_col[idx]])
        if len(checker) != 9:#검증 실패 0출력
            state = False
            break

    #검증 모두 통과 1출력
    print(f"#{tc}",1) if state == True else print(f"#{tc}", 0)

1976. 시각 덧셈

T = int(input())

for tc in range(1,T+1):
    h1,m1,h2,m2 = map(int,input().split())
    time = [h1+h2,m1+m2]

    if time[1] >= 60:
        time[0] += 1
        time[1] -= 60

    if time[0] > 12:
        time[0] -= 12

    print(f"#{tc}", time[0], time[1])

1979. 어디에 단어가 들어갈 수 있을까

T = int(input())

# 퍼즐 한 행씩, 연속된 가로 1갯수 K개 찾기
def findContinuous_1(puzzle, N, K):
    answer = 0

    for i in range(N):
        cnt = 1
        for j in range(0, N-1):
            if puzzle[i][j] == puzzle[i][j+1] == 1:
                cnt += 1
            else:
                if cnt == K:
                    answer += 1
                cnt = 1
        if cnt == K:
            answer += 1
    return answer


for tc in range(1,T+1):
    N, K = map(int, input().split()) #N*N 퍼즐, K크기 단어
    puzzle = [list(map(int, input().split())) for _ in range(N)] #검은부분:0, 흰부분:1
    puzzle_T = list(zip(*puzzle))

    cnt = findContinuous_1(puzzle, N , K)
    cnt += findContinuous_1(puzzle_T, N, K)

    print(f"#{tc}", cnt)

1983. 조교의 성적 매기기

T = int(input())

for tc in range(1, T+1):
    N, K = map(int, input().split())
    scores = [list(map(int, input().split())) for _ in range(N)]
    total = []
    #각 평점당 같은 비율 부여. 각 평점당 N/10 비율로 부여함.

    #scores를 각 비율별 총점 합계 리스트 만들기
    for i in range(N):
        total.append(scores[i][0]*0.35 + scores[i][1]*0.45 + scores[i][2]*0.2)

    #K번째 학생에 대한 등수를 통해 무슨 학점인지 판단
    K_score = total[K-1]
    total.sort(reverse=True)
    K_rank = total.index(K_score) + 1

    print(f"#{tc}", end=" ")
    if K_rank <= N/10:
        print("A+")
    elif K_rank <= 2*N//10:
        print("A0")
    elif K_rank <= 3*N//10:
        print("A-")
    elif K_rank <= 4*N//10:
        print("B+")
    elif K_rank <= 5*N//10:
        print("B0")
    elif K_rank <= 6*N//10:
        print("B-")
    elif K_rank <= 7*N//10:
        print("C+")
    elif K_rank <= 8*N//10:
        print("C0")
    elif K_rank <= 9*N//10:
        print("C-")
    elif K_rank <= 10*N//10:
        print("D0")
        
  ####################################################################################
  #짧은 코드
for t in range(int(input())):
    N, K = map(int,input().split())
    r=[[*map(int,input().split())]for _ in range(N)]

    k = r[K-1]
    r.sort(key=lambda x:.35*x[0]+.45*x[1]+.2*x[2]);

    print(f"#{t+1} {['D0','C-','C0','C+','B-','B0','B+','A-','A0','A+'][r.index(k)//(N//10)]}")

1984. 중간 평균값 구하기

T = int(input())

for tc in range(1,T+1):
    nums = list(map(int, input().split()))
    nums.remove(max(nums)) #remove는 중복되면 하나만 지움.
    nums.remove(min(nums))
    print(f"#{tc}", round(sum(nums)/8))

1986. 지그재그 숫자

T = int(input())

for tc in range(1,T+1):
    N = int(input())
    answer = 0
    for i in range(1,N+1):
        if i % 2: #홀수
            answer += i
        else:
            answer -= i

    print(f"#{tc}", answer)

1989. 초심자의 회문 검사

T = int(input())

for tc in range(1, T+1):
    words = input()
    len_words = len(words)
    answer = 0

    for i in range(len(words)//2+1):
        if words[i] == words[len_words-1-i]:
            answer = 1
        else:
            answer = 0
            break
    print(f"#{tc}", answer)

2001. 파리 퇴치

# N=5일때 M=2면, 완전 탐색 4*4씩 순회
# 즉, N-M+1 씩 순회
# 그 안에서 M*M번 크기 값 확인 -> 각 경우의 저장

T = int(input())

for tc in range(1, T+1):
    N, M = map(int, input().split())
    area = [list(map(int, input().split())) for _ in range(N)]
    answer = [[0 for _ in range(N-M+1)] for _ in range(N-M+1)]

    for i in range(N-M+1):
        for j in range(N-M+1):
            for x in range(M):
                for y in range(M):
                    answer[i][j] += area[x+i][y+j]
    print(f"#{tc}", max(map(max, answer)))

2005. 파스칼의 삼각형

T = int(input())

for tc in range(1, T+1):
    N = int(input())
    pascal = [[0] * N for _ in range(N)]
    pascal[0][0] = 1

    print(f"#{tc}")
    print(pascal[0][0])

    for i in range(1, N):
        for j in range(N):
            if j == 0:
                pascal[i][j] = 1
            else:
                pascal[i][j] = pascal[i-1][j-1] + pascal[i-1][j]

            if pascal[i][j] != 0:
                print(pascal[i][j], end=' ')

        print('')

2007. 패턴 마디의 길이

# 처음 문자와 같은 문자가 다시 나올경우, 쭉쭉 판독 시작
# 다르면 판독X 다시 첫글자 같은거 나오면 판독 시작

T = int(input())
for tc in range(1, T+1):
    str = input()
    word = ""

    for i in range(1, 30):
        # 첫 글자가 다시 나오면, 해당 번호만큼 다시 반복해서 word에 넣음.
        if str[i] == str[0]:
            for j in str[i:i+i]:
                word += j
        #마디 찾으면 출력하고 멈춤
        if word == str[:i]:
            print(f"#{tc}", len(word))
            break
        #틀리면, 다시 word 초기화
        else:
            word = ""

1926. 간단한 369게임

def check369(num):
    strNum = str(num)
    count = 0
    for i in strNum:
        if i in ('3','6','9'):
            count += 1
    if count == 0:
        return num
    else:
        return "-"*count

N = int(input())
for i in range(1,N+1):
    print(check369(i),end=" ")

1859. 백만 장자 프로젝트

#최대이익 : 제일 쌀 때 사서 비쌀 때 팜
#비싼 가격이 두번째, 세번째에 무조건 있어야됨.
#가격이 내림차순이면 0


T = int(input())

for tc in range(1, T+1):

    N = int(input())
    price = list(map(int, input().split()))
    dp = [0] * N

    # 최대 가격 마지막 날짜로 초기화
    max_price = price[-1]

    # 끝에서 두번째 부터 거꾸로 반복
    for i in range(N-2, -1, -1):

        # 최대 가격이 해당 가격보다 크면,
        # 즉, 미래 가격이 더 비싸므로, 해당 차액을 dp에 저장
        if max_price > price[i]:
            dp[i+1] = max_price - price[i]
        # 미래의 최대 가격 보다 이전 가격이 더 비싸므로 해당 최대가격 갱신
        else:
            max_price = price[i]
    # 미래의 가격이 과거보다 비싸서, 최대 차액거래가 되는 모든 경우가 dp 리스트에 저장된다.
    print(f"#{tc}", sum(dp))