Posts

ring = list(map(int, input().split()))
first = ring[0]
rings = ring[1:]
def gcd(a, b):
    while a % b != 0:
        r = a % b
        a, b = b, r
    return b

for r in rings:
    if first % r == 0:
        print(f"{first // r}/1")
    elif r % first == 0:
        print(f"1/{r // first}")
    else:
        g = gcd(first, r)
        print(f"{first // g}/{r // g}")

$a, b \in \mathbb{Z}$이고 $a$를 $b$로 나눈 나머지를 $r$이라 하자. ($b \leq a, 0 \leq r \leq b$)

$a, b$의 최대 공약수를 $(a, b)$라고 하면, 다음이 성립한다.

$(a, b)=(b, r)$

출처: wikipidia

$r$이 0이 될 때 알고리즘을 멈추며, 이 때의 $b$가 최대공약수가 된다.

예를 들어 1460과 1037에 대해 알고리즘을 진행해보면 다음과 같다.

$r$이 0일때 $b$가 4이므로 1460과 1037의 최대공약수는 4이다.

• $1000 ≤ x_1, y_1, x_2, y_2, c_y, c_x ≤ 1000$
• $1 ≤ r ≤ 1000$
• $1 ≤ n ≤ 50$
• 좌표와 반지름은 모두 정수

행성계를 꼭 통과해야 하는 조건을 먼저 찾는. 출발점이나 도착점이 행성계 안에 있을 경우 무조건 그 항성계를 통과해야 한다. 출발점이나 도착점을 포함하지 않고 있는 행성계는 어떻게든 피해갈 수 있기 때문이다.

한 점이 원 안에 포함되어있는지 확인하려면, 원의 반지름과 원의 중심과 그 점 사이의 거리를 비교하면 된다. 원의 반지름이 더 크다면 그 점은 무조건 원 안에 위치하게 되고, 원의 중심과 그 점 사이의 거리를 비교하면 그 점은 원 밖에 위치하게 된다.

t = int(input())
for _ in range(t):
    cnt = 0
    x1, y1, x2, y2 = map(int, input().split())
    n = int(input())
    for _ in range(n):
        c_x, c_y, r = map(int, input().split())
        r = r ** 2
        dis1 = (c_x - x1) ** 2 + (c_y - y1) ** 2
        dis2 = (c_x - x2) ** 2 + (c_y - y2) ** 2
        if (dis1 < r and dis2 < r) or (dis1 > r and dis2 > r):
            continue
        else:
            cnt += 1
    print(cnt)

div = list(map(int, input().split()))
min, max = float('inf'), float('-inf')
for d in div:
    if min > d : min = d
    if max < d : max = d
print(min * max)

print = sys.stdout.write

n = int(input())
cnt_list = [[] for i in range(200002)]
for _ in range(n):
    x, y = map(int, input().split())
    cnt_list[x + 100000].append(y)

for x, ys in enumerate(cnt_list):
    if ys:
        if len(ys) == 1:
            print(f"{x - 100000} {ys[0]}\n")
        else:
            for y in sorted(ys):
                print(f"{x - 100000} {y}\n")

2번 문제도 마찬가지로 진행하되 y를 기준으로 배열을 만들어 x좌표를 append해준다.

import sys
input = sys.stdin.readline
print = sys.stdout.write

n = int(input())
cnt_list = [[] for i in range(200002)]
for _ in range(n):
    x, y = map(int, input().split())
    cnt_list[y + 100000].append(x)

for y, xs in enumerate(cnt_list):
    if xs:
        if len(xs) == 1:
            print(f"{xs[0]} {y - 100000}\n")
        else:
            for x in sorted(xs):
                print(f"{x} {y - 100000}\n")

print = sys.stdout.write

n = int(input())
len_cnt = [set() for i in range(51)]
for _ in range(n):
    word = input().strip()
    len_cnt[len(word)].add(word)

for words in len_cnt:
    if words:
        if len(words) == 1:
            print(f"{list(words)[0]}\n")
        else:
            for w in sorted(list(words)):
                print(f"{w}\n")

num = input().strip()
cnt_dict = {str(n):0 for n in range(9, -1, -1)}
for i in num:
    cnt_dict[i] += 1
ans = ''
for i in cnt_dict:
    for _ in range(cnt_dict[i]):
        ans += i

print(ans)

9~0까지의 수를 key로 가지고 value가 0인 dictionary를 만들고 수가 얼마나 나왔는지 count 한다. 이후 dictionary의 key 순서대로(내림차순) count 된 수만큼 문자를 붙여가며 답을 완성한다.

print = sys.stdout.write

n = int(input())
nums = []
d = defaultdict(int)

for _ in range(n):
    d[int(input())] += 1

for num in sorted(d):
    for _ in range(d[num]):
        print(f'{str(num)}\n')

예를 들어, A = { 1, 2, 4 } 이고, B = { 2, 3, 4, 5, 6 } 라고 할 때,  A-B = { 1 } 이고, B-A = { 3, 5, 6 } 이므로, 대칭 차집합의 원소의 개수는 1 + 3 = 4개이다.

첫째 줄에 집합 A의 원소의 개수와 집합 B의 원소의 개수가 빈 칸을 사이에 두고 주어진다. 둘째 줄에는 집합 A의 모든 원소가, 셋째 줄에는 집합 B의 모든 원소가 빈 칸을 사이에 두고 각각 주어진다. 각 집합의 원소의 개수는 200,000을 넘지 않으며, 모든 원소의 값은 100,000,000을 넘지 않는다.

첫째 줄에 대칭 차집합의 원소의 개수를 출력한다.

대칭 차집합의 정의에 따라 그대로 코드로 작성하면 되는 문제다. 대칭 차집합의 각 차집합 (A-B)와 (B-A)는 교집합이 무조건 공집합이므로 각 차집합의 원소 개수를 더하는 것으로 대칭 차집합의 원소 개수를 구할 수 있다.

input()
a = set(map(int, input().split()))
b = set(map(int, input().split()))
print(len(a - b) + len(b - a))