IP주소에는 IPv4와 IPv6 두 가지 형식이 있는데, 

IPv4는 "A.B.C.D" 형태로 나타내면, 여기서 A, B, C, D는 0 이상 255이하의 정수이다.

IPv6는 "A:B:C:D:E:F:G:H" 형태로 나타내며, A,B,C,D,E,F,G,H는 각각 네 자리의 16진수이다. 

주어진 IP 주소가 어떤 형식인지 확인하여, IPv4인지 IPv6인지 알려주는 코드

import re

def is_ipv4(address):
    ipv4_pattern = r'^((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])$'
    return re.match(ipv4_pattern, address) is not None

def is_ipv6(address):
    ipv6_pattern = r'^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|' \
                   r'([0-9a-fA-F]{1,4}:){1,7}:|' \
                   r'([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|' \
                   r'([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|' \
                   r'([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|' \
                   r'([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|' \
                   r'([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|' \
                   r'[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|' \
                   r':((:[0-9a-fA-F]{1,4}){1,7}|:)|' \
                   r'fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|' \
                   r'::(ffff(:0{1,4}){0,1}:){0,1}(([0-9]{1,3}\.){3}[0-9]{1,3})|' \
                   r'([0-9a-fA-F]{1,4}:){1,4}:(([0-9]{1,3}\.){3}[0-9]{1,3}))$'
    return re.match(ipv6_pattern, address) is not None

address = input().strip()

if is_ipv4(address):
    print("IPv4")
elif is_ipv6(address):
    print("IPv6")

첫째 줄에 정수 N이 주어지는데 하루 동안 숫자 N을 볼수있는 시간은 몇초인지 출력하고 싶다.

예를 들어 N = 3일 때는 00:00:00부터 23:59:59까지 3이라는 숫자가 포함된 시간이 총 43875초라서 43875를 출력하면 된다. 

N = int(input())

count = 0

for hour in range(24):
  for minute in range(60):
    for second in range(60):
      time_str = f"{hour:02}{minute:02}{second:02}"
      if str(N) in time_str:
        count += 1

print(count)

직사각형 형태의 궁전을 형성하는 모든 가로, 세로 줄에 대해서 적어도 기둥이 하나씩은 존재하도록 만들고자 할때, 세워야하는 기둥의 최솟값을 출력하는 프로그램을 작성하고 싶다.

첫째 줄에  궁전의 세로 크기 N과 가로 크기 M이 주어진다는 말.
N과 M은 50보다 작거나 같은 자연수.

둘째 줄부터는 N개의 줄에는 궁전의 상태가 주어지고
궁전의 상태는 1은 빈칸, 0은 기둥이 있는 칸이다.

세워야 하는 기둥의 최솟값을 출력하고 싶다.

입력 예시는
3 3
1 1 1
1 1 1
1 1 1 이면
출력예시는 3이다. 

N, M = map(int, input().split())

matrix_dimension = [N, M]

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

count_row = 0
count_col = 0

for row in range(N):
  if sum(matrix[row]) == M:
    count_row += 1

for col in range(M):
  column_values = [matrix[row][col] for row in range(N)]
  
  if sum(column_values) == N:
    count_col += 1

if (count_col + count_row) < max(matrix_dimension):
  print((count_col + count_row))

else:
  if count_col > count_row:
    print(count_col)

  else:
    print(count_row)

6
12
28
-1

6 = 1 + 2 + 3
12 is NOT perfect.
28 = 1 + 2 + 4 + 7 + 14

내가 한 틀린 코드

nl = []
ll = []

while True:
    n = int(input())

    if n == -1:
        break
        
    l = []
    
    for i in range(1,n+1):
        if n % i == 0:
            l.append(i)

    l.remove(l[-1])
    ll.append(l)
    nl.append(n)

for j in range(len(ll)):
    if nl[j] == sum(ll[j]):
        print(f"{nl[j]} = ", end = "")

        for k in ll[j]:
            if k == 1:
                print(f"{k}", end = "")

            else:
                print(f" + {k}", end = "")
    else:
        print()
        print(f"{nl[j]} is NOT perfect.")

이 코드는 정답이랑 똑같은 형식으로 출력되기는 하는데

출력되는 형식이 이렇게 되면 안되기 떄문에 틀린 문제이다.

한 줄에 하나씩 출력되도록 해야하는데 그렇게 하지 않았기에 틀린문제

그럼 어떻게 해야하나?

옛날에 썼던 적이 있는 것 같은데 요즘 안써서 까먹은 join을 써야한다.

join을 통해 반복문 사이에 있는 인자들을 +로 연결해준다는 생각을 해주면 이렇게 길게 코드를 쓰지 않아도 된다.

정답 코드

nl = []
ll = []

while True:
    n = int(input())

    if n == -1:
        break
        
    l = []
    
    for i in range(1,n+1):
        if n % i == 0:
            l.append(i)

    l.remove(l[-1])
    ll.append(l)
    nl.append(n)

for j in range(len(ll)):
    if nl[j] == sum(ll[j]):
        temp = ' + '.join(str(i) for i in ll[j])
        print(f"{nl[j]} = {temp}")

    else:
        print(f"{nl[j]} is NOT perfect.")

2 1 5

4

5 1 6

2

100 99 1000000000

999999901

내가 실패한 답들 

A,B,V = map(int, input().split())

now = 0
day = 0

while True:
    now += A
    day += 1
    if now >= V:
        break
    else:
        now -= B

print(day)

A,B,V = map(int, input().split())
tot = A-B

now = 0
day = 0

while True:
    now += tot
    day += 1
    if V == now + A or V <= now + A:
        day += 1
        break
        
print(day)

출력은 되는데 모두 시간초과로 인해 실패하였다.

그래서 알고리즘 분류가 수학으로 돼있어서

x를 다 올라가는 횟수라하고 x-1을 내려가는 횟수라고 해서

식을 세우니 아래와 같은 결과가 나왔다.

Ax - B(x - 1) = V

Ax - Bx + B = V

(A - B)x = V - B

X = (V - B)/(A - B)

그래서 이걸 바탕으로 코드를 만들었다.

import math

A, B, V = map(int, input().split())
day = (V-B) / (A-B)
print(math.ceil(day))

ceil을 한 이유는 올림을 해줘야 우리가 원하는 답이 나오기 때문이다.

예를 들어 day의 값이 5.6이 나오면 5가 답이 아닌 6이 답이 나와야 하기 때문이다. 

앞으로 실행시간도 신경써서 코드를 만들어야겠다는 생각을 하게 되는 문제였다. 

문제

위의 그림과 같이 육각형으로 이루어진 벌집이 있다. 그림에서 보는 바와 같이 중앙의 방 1부터 시작해서 이웃하는 방에 돌아가면서 1씩 증가하는 번호를 주소로 매길 수 있다. 숫자 N이 주어졌을 때, 벌집의 중앙 1에서 N번 방까지 최소 개수의 방을 지나서 갈 때 몇 개의 방을 지나가는지(시작과 끝을 포함하여)를 계산하는 프로그램을 작성하시오. 예를 들면, 13까지는 3개, 58까지는 5개를 지난다.

입력

첫째 줄에 N(1 ≤ N ≤ 1,000,000,000)이 주어진다.

출력

입력으로 주어진 방까지 최소 개수의 방을 지나서 갈 때 몇 개의 방을 지나는지 출력한다.

예제 입력 1 복사

13

예제 출력 1 복사

3

정답코드

N = int(input())
first_interval = 1
answer = 1

while True:
    if N == 1:
        print(answer)
        break
    else:
        last_interval = first_interval + 6 * answer
        if N in range(first_interval, last_interval + 1):
            answer += 1
            print(answer)
            break
        else:
            answer += 1
            first_interval = last_interval

최소 개수의 방을 지나야한다.

그래서 나는 벌집 모양의 수들이 어떤 관계를 이루고 있는지 확인하였다. 

확인한 결과 1 밑에 2번 그리고 시계 방향으로 수가 증가한다. 

7에서 8로 넘어갈 때 회전하는 층이 바뀐다. 그림으로 설명하면 이렇다. 

1 - 7 - 19 - 37 - ... 이런 식으로 간격이 6 X 1, 6 X 2, 6 X 3 ... 이렇게 증가하는 걸 확인할 수 있다. 

그래서 구간을 1 ~ 7, 7 ~ 19, 19 ~ 37... 이런 식으로 잡을 수 있도록 변수를 설정해주었다. 

코드 설명

1.

N = int(input())
first_interval = 1
answer = 1

N에는 구하려는 숫자를 입력한다.

그리고 처음에 있는 숫자방인 1을 first_interval로 잡아준다.

숫자방 1에 있을 때도 방을 거친 것이 되기 때문에 초기값을 answer = 1로 잡아준다. 

2.

while True:
    if N == 1:
        print(answer)
        break
    else:
        last_interval = first_interval + 6 * answer
        if N in range(first_interval, last_interval + 1):
            answer += 1
            print(answer)
            break
        else:
            answer += 1
            first_interval = last_interval

N이 만약에 1이라면 그냥 출력할 수 있도록 한다.

그게 아니면 last_interval을 설정하여 거치는 방의 횟수를 구할 수 있도록 한다.

예를 들면 1 ~ 7의 범위 안에 숫자가 있는지 확인하고 있다면 방을 한번 더 거친 것이기 때문에 

answer에 1을 더할 수 있도록 한다.

그러고 난 다음에 print(answer)을 한다. 

1 ~ 7의 범위 안에 없다면 다음 범위로 넘어가야 하기 때문에 else 을 통해 다음 범위로 넘어갈 수 있도록 한다. 

정답 코드 

N = int(input())
init = 2

for i in range(N):
    init = init + 2 ** i

res = init ** 2
print(res)

규칙을 잘 찾으면 바로 답이 나오는 문제 

3
124
25
194

4 2 0 4
1 0 0 0
7 1 1 4

내가 만든  정답 코드

T = int(input())
Q = 25
D = 10
N = 5
P = 1

Q_list = []
D_list = []
N_list = []
P_list = []

for i in range(T):
    C = int(input())
    Quarter = C // Q
    Dime = (C - Quarter * Q) // D
    Nickel = (C - Quarter * Q - Dime * D) // N
    Penny = (C - Quarter * Q - Dime * D - Nickel * N) // P
    Q_list.append(Quarter)
    D_list.append(Dime)
    N_list.append(Nickel)
    P_list.append(Penny)

for i in range(T):
    print(f"{Q_list[i]} {D_list[i]} {N_list[i]} {P_list[i]}")

다른 사람들의 코드 

n = int(input())

for _ in range(n):
	money = int(input())
	for i in [25, 10, 5, 1]:
		print(money//i, end=' ')
		money = money%i

다른 사람들이 쓴 코드는 내가 일일이 복잡하게 모든 걸 쓴 코드에 비해 훨씬 간결하다.

여기서 보면 나는 25,10,5,1을 처음에 변수를 통해 설정해준 반면에 여기서는 리스트를 통해 반복문을 돌게 하여 나누도록 하였다. 내가 124에서 100을 빼고 20을 빼고 하는 식으로 코드를 짰는데 굳이 이렇게 안하고 124를 25로 나누고 10으로 나누고 각각 한 몫을 구해서 출력하도록 했으면 더 좋았을 것 같다. 

사람들 말로는 이 문제가 전형적인 그리드 문제라고 한다. 

그리드가 뭔지 몰라서 나는 찾아봤다. 

그리디 알고리즘(욕심쟁이 알고리즘, Greedy Algorithm)이란 "매 선택에서 지금 이 순간 당장 최적인 답을 선택하여 적합한 결과를 도출하자"라는 모토를 가지는 알고리즘 설계 기법이다.[1]

이거 보면서 생각난게 머신러닝의 가지치기 기법인데 혹시 연관이 있나 싶다. 

ZZZZZ 36

60466175

정답 코드

num_list = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

N, B = input().split()
answer = 0
for i, num in enumerate(N[::-1]):
    answer += int(B) ** i * num_list.index(num)

print(answer)

설명

1. 진법을 변환하기 위한 num_list 설정

2. N,B를 통해 입력받기

3. answer을 통해 구하려는 진법의 값을 받을 수 있는 변수 설정

4. 반복문 설정 

 4-1. 이때 N[::-1]을 하는 이유는 ZZZZZ가 입력된다고 하면 제일 앞에 있는 Z가 36**4*35를 받아야하기 때문

5. 출력

문제

가로, 세로의 크기가 각각 100인 정사각형 모양의 흰색 도화지가 있다. 이 도화지 위에 가로, 세로의 크기가 각각 10인 정사각형 모양의 검은색 색종이를 색종이의 변과 도화지의 변이 평행하도록 붙인다. 이러한 방식으로 색종이를 한 장 또는 여러 장 붙인 후 색종이가 붙은 검은 영역의 넓이를 구하는 프로그램을 작성하시오.

예를 들어 흰색 도화지 위에 세 장의 검은색 색종이를 그림과 같은 모양으로 붙였다면 검은색 영역의 넓이는 260이 된다.

3
3 7
15 7
5 2

260

array = [[0 for j in range(100)] for i in range(100)]
n = int(input()) # 색종이의 수 

for i in range(n):
    x1, y1 = list(map(int, input().split()))

    for x in range(x1, x1+10):
        for y in range(y1, y1+10):
            array[x][y] = 1

res = 0
for k in range(100):
    res += array[k].count(1)

print(res)

처음에는 길이가 겹치는 부분을 어떻게 하지 해서 전부 다 구해서 빼면 되나 했는데

너무 코드가 길어져서 패스했다.

그래서 다른 사람들이 한 것을 보니 

1. 10X10의 0으로 채운 정사각형을 만든다.

2. 색종이의 수를 받는다.

3. 색종이의 수만큼 수를 받아준다.

4. 그리고 해당하는 칸을 0에서 1로 만들어준다.(array[x][y])

5. 그리고 그 1을 모두 세어준다.

이렇게 하면 겹치는 부분의 넓이를 쉽게 구할 수 있다.

데이터 쌓았으니 다음 번에 써먹을 수 있도록 한번 더 연습해야겠다.