파이썬의 자료형

정수형, 실수형, 복소수형, 문자열, 리스트, 튜플, 사전 등이 있다.
많이 사용되는 정수, 실수에 대해서 알아보자.

1. 정수형

# 양의 정수
a = 1000
print(a)

# 음의 정수
a = -7
print(a)

# 0
a = 0
print(a)

1000
-7
0

2. 실수형

# 양의 실수
a = 157.93
print(a)

# 음의 실수
a = -73.2
print(a)

# 소수부가 0이면 생략 가능
a = 5.
print(a)

# 정수부가 0이면 생략 가능
a = -.7
print(a)

157.93
-73.2
5.0
-0.7

지수 표현 방식

파이썬에서는 e나 E를 이용한 지수 표현 방식을 사용할 수 있다.
1e9 = 10의 9제곱으로 표현 가능하다!

# 1,000,000,000
a = 1e9
print(a)

a = int(1e9)
print(a)

# 752.5
a = 75.25e1
print(a)

# 3.954
a = 3954e-3
print(a)

1000000000.0
1000000000
752.5 (= 75.25 10^1)
3.954 (= 3954 10^-3)

실수 정확성의 한계

데이터를 저장하기 위해서는 4바이트, 8바이트의 고정된 크기의 메모리에 값을 저장하게 된다. 이때 10진수를 2진수로 변환하여 비트에 저장할 때, 대부분의 소수는 변환 시 무한 소수로 표현되는 경우가 많다. 따라서 실수의 값을 정확히 표현할 수가 없는 것이다. 이로 인해서 미세한 오차가 발생한다.

a = 0.3
b = 0.6
print(a+b)

if a + b == 0.9:
  print(True)
else:
  print(False)

0.899999999999999
False

round 함수

실수 정확성의 한계를 극복하기 위해서 반올림 함수를 사용한다.

a = 0.3
b = 0.6

# 소수점 5번째 자리에서 반올림
print(round(a + b, 4))

if round(a + b, 4) == 0.9:
  print(True)
else:
  print(False)

0.9
True

3. 수 자료형의 연산

수학 라이브러리를 사용하지 않아도 기본적으로 제공되는 연산자들이 있다.

나누기 연산자(/)

나누기 연산자는 나눠진 결과를 실수형으로 반환한다.

나머지 연산자(%)

a가 홀수인지 아닌지 확인하는 경우

몫 연산자(//)

몫을 정수형으로 반환한다.

거듭제곱 연산자(**)

거듭제곱 결과를 정수형으로 반환한다.

a = 7
b = 3

# 나누기
print(a / b)

# 나머지
print(a % b)

# 몫
print(a // b)

# 거듭제곱
print(a ** b)

2.3333333333333335
1
2
343

4. 리스트 자료형

여러 개의 데이터를 연속적으로 담아 처리하는 자료형이다.
C++의 Vector나 Java의 ArrayList와 유사하며 배열, 테이블이라고도 부른다.

1. 대괄호([])안에 원소를 넣어 초기화하며, 쉼표(,)로 원소를 구분한다.
2. 비어있는 리스트를 선언할 때, list() 혹은 []을 이용할 수 있다.
3. 리스트 원소의 접근할 때는 인덱스 값을 괄호([])안에 넣는다.
4. 인덱스는 0부터 시작한다!!!

# 직접 데이터를 넣어 초기화
a = [1,2,3,4,5,6,7,8,9]
print(a)

# 4번째 원소 출력
print(a[3])

# 크기가 10인 0으로 초기화된 1차열 배열
n = 10
a = [0] * n
print(a)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
4
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

인덱싱

인덱스 값을 입력하여 특정한 원소에 접근하는 것

# 직접 데이터를 넣어 초기화
a = [1,2,3,4,5,6,7,8,9]
print(a)

# 8번째 원소
print(a[7])

# 뒤에서 1번째 원소
print(a[-1])

# 뒤에서 3번째 원소
print(a[-3])

# 4번째 원소 값 변경
a[3] = 7
print(a)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
8
9
7
[1, 2, 3, 7, 5, 6, 7, 8, 9]

슬라이싱

연속적인 위치를 갖는 원소들을 가져와야 할 때는 슬라이싱을 이용한다.
(파이썬이 코딩 테스트에서 유리한 이유 중 하나이다!)
대괄호 안에 콜론(:)을 넣어서 시작 인덱스부터 끝 인덱스까지 가져올 수 있다.
끝 인덱스는 시작 인덱스보다 1을 더 크게 설정한다.

# 직접 데이터를 넣어 초기화
a = [1,2,3,4,5,6,7,8,9]

# 2번째 원소부터 4번째 원소까지
# 1 index ~ 3 index
print(a[1:4])

[2,3,4]

리스트 컴프리헨션

리스트를 초기화하는 방법 중 하나로 대괄호([])안에 반복문, 조건문을 사용하여 원하는 조건으로 리스트를 초기화하는 방법이다.

# 0 ~ 19까지의 수 중 홀수만 포함하는 리스트

# 리스트 컴프리헨션
array = [i for i in range(20) if i % 2 == 1]
print(array)

# 일반적인 구현 방법
array = []
for i in range(20):
  if i % 2 == 1:
    array.append(i)
print(array)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

2차원 리스트

올바른 방법 : array = [[0] * m for _ in range(n)]

잘못된 방법 : array = [[0] m] n
위의 경우, 전체 리스트 안에 포함된 각 리스트들이 모두 같은 객체로 인식된다.

# N X M 2차원 리스트 초기화
print("1번")
n = 4
m = 3
array = [[0] * m for _ in range(n)]
print(array)

array[1][1] = 5
print(array)

# 잘못된 초기화 방법 
print("\n2번")
array = [[0] * m] * n
print(array)

array[1][1] = 5
print(array)

1번
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 5, 0], [0, 0, 0], [0, 0, 0]]

2번
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 5, 0], [0, 5, 0], [0, 5, 0], [0, 5, 0]]

반복문에서 언더바(_)를 사용하는 이유

반복 수행은 하되 변수의 값을 무시하고자 할 때, 사용됩니다.

# 1 ~ 9까지의 자연수를 더하기
answer = 0
for i in range(1, 10):
  answer += i
print(answer)

# 5번 출력하기
for _ in range(5):
  print("Hello World")

리스트 관련 기타 메서드

appned

리스트의 맨 뒤에 값을 추가

sort

오름차순 정렬

a = [1, 4, 3]
print("기본 : " , a)

# 리스트에 원소 삽입
a.append(2)
print("삽입 : ", a)

# 오름차순 정렬
a.sort()
print("오름차순 : ", a)

# 내림차순 정렬
a.sort(reverse = True)
print("내림차순 : ", a)

기본 : [1, 4, 3]
삽입 : [1, 4, 3, 2]
오름차순 : [1, 2, 3, 4]
내림차순 : [4, 3, 2, 1]

reverse

원소들을 전부 뒤집는다.

insert

특정 인덱스 자리에 데이터 추가

count

리스트 내의 특정 값 개수 출력

remove

특정 값 제거

a = [4, 3, 2, 1]

# 원소 뒤집기
a.reverse()
print("뒤집기 : ", a)

# 특정 인덱스에 데이터 추가
a.insert(2, 3)
print("2 index에 3 추가 : ", a)

# 특정 값 개수 세기
print("값이 3인 데이터의 개수 : ", a.count(3))

# 특정 값 삭제
a.remove(1)
print("값이 1인 데이터 삭제 : ", a)

뒤집기 : [1, 2, 3, 4]
2 index에 3 추가 : [1, 2, 3, 3, 4]
값이 3인 데이터의 개수 : 2
값이 1인 데이터 삭제 : [2, 3, 3, 4]

특정 값을 가지는 원소 모두 제거

remove는 원소 하나만 제거하기 때문에 아래와 같은 코드를 이용한다.

a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5} # 제거 대상

# remove_set에 포함되지 않는 값들만 저장한다.
result = [i for i in a if i not in remove_set]
print(result)

[1, 2, 4]

5. 문자열 자료형

문자열을 초기화할 때는 큰 따옴표(")나 작은 따옴표(')를 이용한다.

data = "Hello World"
print(data)

# 큰 따옴표로 초기화하였기에 작은 따옴표 사용이 가능하다.
data = "Don't you know \"Python\"?"
print(data)

data = "Hello World"
print(data)

data = "Don't you know \"Python\"?"
print(data)

문자열 연산

1. 덧셈 : 문자열이 더해지면서 연결이 된다.
2. 곱셈 : 특정한 양의 정수와 곱하는 경우, 문자열이 그 값만큼 더해진다.
3. 인덱싱과, 슬라이싱 사용이 가능하지만 특정 인덱스의 값 변경은 불가능하다.

a = "Hello"
b = "World"
print(a + " " + b)

# 3번 더한다.
a = "String"
print(a * 3)

# index 2 ~ 3까지 출력
a = "ABCDEF"
print(a[2 : 4])

Hello World
StringStringString
CD

튜플 자료형

리스트와 유사하지만 아래와 같은 차이점이 존재한다.

1. 한 번 선언된 값을 변경할 수 없다.
2. 리스트는 대괄호([])를 이용하지만 튜플은 소괄호(())를 이용한다.
3. 리스트에 비해 상대적으로 공간 효율적이다.

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)

# 4번째 원소 출력
print(a[3])

# 2 ~ 4번째 원소까지
print(a[1 : 4])

4
(2, 3, 4)

기능이 제한적인데 어떤 경우에 사용해야할까?

1. 서로 다른 성질의 데이터를 묶어서 관리해야할 때
   ex) 최단 경로 알고리즘 (비용, 노드번호)의 형태로 자주 사용한다.
   ex) 학생 정보 (학번, 이름)의 형태
2. 데이터의 나열을 해싱의 키 값으로 사용해야할 때
3. 공간 복잡도가 높아서 메모리를 효율적으로 사용해야할 때

사전 자료형

1. 키(Key)와 값(Value)의 쌍을 데이터로 가지는 자료형이다.
2. 원하는 변경 불가능한 자료형을 키로 사용할 수 있다.
3. 파이썬의 사전 자료형은 내부적으로 해시 테이블을 이용하므로 데이터 조회 및 수정에 있어서 O(1) 시간으로 처리가 가능하다.

# 키와 값을 매칭시킨다.
data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'
print(data)

if '사과' in data:
  print("'사과'를 키로 가지는 데이터가 존재한다.")
else:
  print("'사과'를 키로 가지는 데이터가 존재하지 않는다.")

{'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
'사과'를 키로 가지는 데이터가 존재한다.

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

print(data)

# 키 데이터만 담은 리스트
key_list = data.keys()
print(key_list)

# 키 데이터를 이용해서 값 출력하기
for key in key_list:
  print(data[key])
  
# 값 데이터만 담은 리스트
value_list = data.values()
print(value_list)
print(list(value_list))

{'사과': 'Apple', '바나나': 'Banana', '코코넛': 'Coconut'}
dict_keys(['사과', '바나나', '코코넛'])
Apple
Banana
Coconut
dict_values(['Apple', 'Banana', 'Coconut'])
['Apple', 'Banana', 'Coconut']

집합 자료형

1. 중복을 허용하지 않는다.
2. 순서가 없다.
3. 데이터 조회 및 수정에 있어서 O(1)의 시간에 처리가 가능하다.

# 집합 초기화 1번
data = set([1, 1, 2, 3, 4, 4, 5])
print(data)

# 집합 초기화 2번
data = {1, 1, 2, 3, 4, 4, 5}
print(data)

{1, 2, 3, 4, 5}

집합 자료형의 연산

a = set([1,2,3,4,5])
b = set([3,4,5,6,7])

# 합집합
print(a | b)

# 교집합
print(a & b)

# 차집합
print(a - b)

{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}

집합 자료형 관련 함수

data = set([1,2,3])

# 새로운 원소 추가
data.add(4)
print(data)

# 새로운 원소 여러 개 추가
data.update([5,6])
print(data)

# 특정 값 원소 삭제
data.remove(3)
print(data)

{1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6}

사전 자료형과 집합 자료형의 특징

리스트나 튜플은 순서가 존재하므로 인덱싱을 통해서 값을 얻을 수 있다.
하지만 사전 자료형과 집합 자료형은 순서가 없기 때문에 인덱싱이 아닌 사전의 키(Key)나 집합의 원소(Element)를 이용해서 O(1)의 시간으로 조회할 수 있다.

파이썬의 기본 입출력

표준 입력

입력의 개수가 정해진 경우

a, b, c = map(int, input().split())
print( a, b,c )

입력의 개수가 정해지지 않은 경우

# 데이터의 개수 입력
n = int(input())

# 각 데이터를 공백을 기준으로 구분한다.
data = list(map(int, input().split()))

입력을 최대한 빠르게 받아야 하는 경우

입력의 개수가 매우 많은 경우에 사용한다.
ex) 이진탐색, 정렬, 그래프 등에서 많이 사용된다.

import sys

# 문자열 입력 받기
# Enter가 줄 바꿈 기호로 입력되므로 rstrip을 함께 사용한다.
data = sys.stdin.readline().rstrip() 
print(data)

표준 출력

print() 함수는 콤마(,)를 이용하여 띄어쓰기로 구분이 가능하고
기본적으로 줄 바꿈을 수행하므로 'end'속성을 이용하여 변경할 수 있다.

a = 1
b = 2
print(a, b) # 자동으로 줄 바꿈 수행
print(7, end = " ") # 공백 수행
print(8, end = "!") # !수행

1 2
7 8!

answer = 7
# 문자열과 정수형에 대한 연산이 불가능하므로 형변환을 해야한다.
print("정답은 " + str(answer) + "입니다.")

# 접두사 f를 붙여 사용하면 중괄호 안의 변수명을 기입하여 사용할 수 있다.
print(f"정답은 {answer}입니다.")

정답은 7입니다.
정답은 7입니다.

조건문

if, elif, else

90점 이상 : A
80점 이상 90점 미만 : B
70점 이상 80점 미만 : C
70점 미만 : F

a = 75

if a >= 90:
  print("A")
elif a >= 80:
  print("B")
elif a >= 70:
  print("C")
else:
  print("F")

C

비교 연산자

논리 연산자

0 <= a <= 20을 아래와 같이 나타낼 수 있다.

a = 15
if a <= 20 and a >= 0:
  print(a)

# 파이썬에서는 수학의 부등식을 그대로 사용할 수 있다.
if 0 <= a <= 20:
  print(a)
 

15
15

기타 연산자

in / not in 연산자

a = [1,2,3,4,5]
print(3 in a) # a안에 3이 있는가
print(7 in a) # a안에 7이 있는가
print(3 not in a) # a안에 3이 없는가

b = "Apple"
print('A' in b) # b안에 'A'가 있는가
print('s' not in b) # b안에 's'가 없는가

True
False
False
True
True

pass 키워드

아무것도 하지 않고 넘어갈 수 있도록 하는 키워드

a = 75

if a >= 90:
  print("A")
elif a >= 80:
  print("B")
elif a >= 70:
  pass
else:
  print("F")

출력 없음.

조건문의 간소화

# 조건문의 실행 코드를 줄 바꿈을 사용하지 않고 표현할 수 있다.
a = 85
if a >= 80: result = "Success"
else : result = "Fail"
print(result)

# 조건부 표현식은 if ~ else문을 한줄에 작성할 수 있다.
a = 85
result = "Success" if a >= 80 else "Fail"
print(result)

Success
Success

반복문

While문

i = 1
result = 0

# i가 9 이하일 때 아래 코드 반복
while i <= 9:
  result += i
  i += 1 # i가 1씩 증가

print(result)

45

무한 루프

x = 10
while x > 5:
  print(x)

# 무한 루프
while Ture:
  print(x)

코딩 테스트에서 무한 루프를 구현할 일은 없으니 항상 반복문을 만들면 탈출 할 수 있는지를 확인해야한다.

For문

array = [1, 2, 3, 4, 5]
for x in array:
  print(x)

1
2
3
4
5

range 함수

for i in range(0,10,1):
  print(i)

for i in range(10):
  print(i)

같은 출력

# 0부터 9까지 2씩 증가한다.
for i in range(0,10,2):
  print(i)

0
2
4
6
8

Continue

특정 조건을 만족했을 때, 건너뛰는 역할을 한다.

result = 0
for i in range(1, 10):
  # 짝수인 경우, 건너뛴다.
  if i % 2 == 0:
    continue
  # 홀수인 경우, 더한다.
  result += i
print(result)

25

Break

반복문을 탈출하고자할 때 사용한다.

i = 1
# 무힌 루프
while True:
  print(i)
  # i가 5가 되는 순간 탈출
  if i == 5:
    break;
  i += 1 # 1씩 증가

1
2
3
4
5

이중 for문

구구단 만들기

# 구구단 출력
for i in range(1, 10):
  for j in range(1, 10):
    print(i, "X", j, "=", i * j)
  print() # 공백 처리

함수

1. 내장 함수: 파이썬이 기본적으로 제공하는 함수
2. 사용자 정의 함수 : 개발자가 직접 정의하여 사용할 수 있는 함수

# 함수 정의
def add(a, b): # a, b는 인수
  return a + b # a+ b는 반환값

print(add(3,7))

# 변수를 지정해줄 수 있다.
print(add(b = 7, a = 3))

10
10

global 변수

global 키워드로 변수를 지정하면 해당 함수는 지역 변수를 만들지 않고 함수 바깥에 선언된 변수를 참조하게 된다.

a = 0

def func():
  global a
  a += 1

for i in range(10):
  func()

print(a)

10

지역 변수가 우선적으로 실행되므로 전역 변수 a는 그대로 0이다.

a = 0

def func():
  a = 0
  a += 1

for i in range(10):
  func()

print(a)

0

리스트의 경우에도 마찬가지이다.
아래의 경우는 전역 리스트에 직접 참조할 수 있지만

array = [1, 2, 3, 4, 5]

def func():
  array.append(6)
  print(array)

func()
print(array)

[1, 2 ,3, 4, 5, 6].
[1, 2, 3, 4, 5, 6]

아래 같은 경우는 함수 내부의 array를 우선적으로 처리하여 전역 리스트는 그대로이다.

array = [1, 2, 3, 4, 5]

def func():
  array = [3, 4, 5]
  array.append(6)
  print(array)

func()
print(array)

[3, 4, 5, 6].
[1, 2, 3, 4, 5]

여러 개의 반환 값을 가지는 함수

# 여러 반환 값을 가지는 함수
def oprator(a, b):
  add = a + b
  sub = a - b
  mul = a * b
  dev = a / b
  return add, sub, mul, dev

a, b, c, d = oprator(7, 3)
print(a, b, c, d)

10 4 21 2.33333333333335

람다 표현식

함수를 간단한게 작성할 수 있다.

# 함수 정의
def add(a, b): # a, b는 인수
  return a + b # a+ b는 반환값

print(add(3,7))

# 람다 표현식
print((lambda a, b : a + b)(3, 7))

10
10

array = [('홍길동', 50), ('이순신' , 32), ('아무개' , 74)]

# 2번째 원소인 숫자를 반환한다.
def my_key(x):
  return x[1]

# 숫자를 key로 정렬한다.
print(sorted(array, key = my_key))

# 람다 표현식 사용
print(sorted(array, key = lambda x : x[1]))

[('이순신', 32), ('홍길동', 50), ('아무개', 74)].
[('이순신', 32), ('홍길동', 50), ('아무개', 74)]

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

# 각 리스트의 원소끼리 더해진다.
# map = 각각의 원소에 어떠한 함수를 적용하고자 할 때 사용한다!!
result = map(lambda a, b: a + b, list1, list2)

print(list(result))

[7, 9, 11, 13, 15]

실전에서 유용한 표준 라이브러리

1. 내장 함수
2. itertools : 순열과 조합 라이브러리 포함하고 있다.
3. heapq : 힙 자료구조를 제공한다. (우선순위 큐, 다익스트라)
4. bisect : 이진 탐색 기능을 제공한다.
5. collection : deque와 Counter 등의 자료구조를 포함한다.
6. math : 수학적 기능을 제공한다. (팩토리얼, 제곱근, 최대공약수, 삼각함수 등)

내장 함수

# sum
result = sum([1,2,3,4,5])
print(result)

# min, max
min_result = min(7,3,5,2)
print(min_result)
max_result = max(7,3,5,2)
print(max_result)

# eval - 사칙 연산을 고려해서 계산해준다.
result = eval("3+5*7")
print(result)

15
2
7
38

# sorted
result = sorted([9,1,8,5,4])
print(result)
result_reverse = sorted([9,1,8,5,4], reverse=True)
print(result_reverse)

# sorted with key
array = [('홍길동', 50), ('이순신' , 32), ('아무개' , 74)]
# 각 원소에서 2번째 원소를 기준으로 정렬한다. 즉, 숫자를 기준으로 정렬한다.
print(sorted(array, key = lambda x : x[1])) 
# 각 원소를 1번째 원소를 기준으로 오름차순 정렬한다. 즉, 한글을 기준으로 정렬한다.
print(sorted(array, key = lambda x : x[0])) 

[1, 4, 5, 8, 9].
[9, 8, 5, 4, 1].
[('이순신', 32), ('홍길동', 50), ('아무개', 74)].
[('아무개', 74), ('이순신', 32), ('홍길동', 50)]

순열과 조합

1. 순열 : 서로 다른 n개에서 서로 다른 r개를 선택하여 일렬로 나열하는 경우
2. 조합 서로 다름 n개에서 순서에 상관없이 서로 다른 r개를 선택하는 경우
   

순열

from itertools import permutations

arr = ['A', 'B', 'C']
# 'A', 'B', 'C' 중 서로 다른 2개를 선택하여 나열하는 경우
result = list(permutations(arr, 2))
print(result)

# 'A', 'B', 'C' 중 서로 다른 3개를 선택하여 나열하는 경우
result = list(permutations(arr, 3))
print(result)

[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')].
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

조합

from itertools import combinations

arr = ['A', 'B', 'C']
# 'A', 'B', 'C' 중 서로 다른 2개를 선택하는 경우
result = list(combinations(arr, 2))
print(result)

# 'A', 'B', 'C' 중 서로 다른 3개를 선택하는 경우
result = list(combinations(arr, 3))
print(result)

[('A', 'B'), ('A', 'C'), ('B', 'C')].
[('A', 'B', 'C')]

중복 순열과 중복 조합

from itertools import product

arr = ['A', 'B', 'C']
# 'A', 'B', 'C' 중 중복을 허용하여 2개를 선택하여 나열하는 경우
result = list(product(arr, repeat = 2))
print(result)


from itertools import combinations_with_replacement

# 'A', 'B', 'C' 중 중복을 허용하여 2개를 선택하는 경우
result = list(combinations_with_replacement(arr, 2))
print(result)

[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')].
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

Counter

반복 가능한 객체가 주어졌을 때 내부의 원소가 몇 번 등장했는지 알려준다.

from collections import Counter

counter = Counter(['red', 'blue', 'red', 'green', 'blue', 'blue'])

print(counter['red'])
print(counter['blue'])
print(counter['green'])
print(dict(counter))

2
3
1
{'red': 2, 'blue': 3, 'green': 1}

Math

최대 공약수와 최소 공배수

A,B의 최대공약수 = G, 최소공배수 = L이라고 하자.

A = Ga, B = Gb (a와 b는 서로소이다.)

L = Gab = AB/G

GL = ab

따라서 최소 공배수 L = a*b/G 이다.

즉, 두 수를 곱한 후, 최소 공약수로 나눠주면 최소 공배수가 된다.

import math

# 최소 공배수 함수
def lcm(a, b):
  return a * b // math.gcd(a, b)

a = 21
b = 14

print(math.gcd(21, 14))
print(lcm(21, 14))

7
42

참고자료

이코테 2021 1편
이것이 코딩 테스트다 교재