![[코딩 테스트] 코딩 테스트에서 필요한 Python 문법 정리](https://img1.daumcdn.net/thumb/R750x0/?scode=mtistory2&fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FcobziJ%2FbtrvI4livMM%2FHZHeDEKi04Q1IXAAlHlvz0%2Fimg.png)
반응형
본 포스팅은 코딩테스트를 치뤄보면서 필요한 문법들을 정리해 본 글입니다.
지극히 주관적일 수 있으니 보충 및 수정이 필요하다면 댓글로 남겨주세요.
숫자관련 문법
숫자와 관련하여 반올림, factorial, 최소공배수 등 다양한 연산 및 계산이 필요한 경우가 있다. 그래서 숫자 연산과 관련된 문법을 아래와 같이 정리해보려고 합니다.
< 기본연산 >
- 더하기[ A+B ] : A와 B를 더한 값을 계산한다.
- 빼기[ A-B ] : A에 B를 뺀 값을 계산한다.
- 곱하기[ A*B ] : A에 B를 곱한 값을 계사한다.
- 나누기[ A/B ] : A에 B를 나눈 값을 계산한다.
- 몫[ A//B ] : A에 B를 나눴을때의 몫을 계산한다.
- 나머지[ A%B ]: A에 B를 나누고 난 나머지를 계산한다.
- 거듭제곱[ A**B ] : A에 B만큼 거듭 곱한값을 계산한다.
- 절대값[ abs(A-B) ] : A와 B 사이의 크기를 반환한다.
a = 7
b = 3
#더하기
print(a+b) # 10
# 빼기
print(a-b) # 4
# 곱하기
print(a*b) # 21
# 나누기
print(a/b) # 2.3333333333333335
# 몫
print(a//b) # 2
# 나머지
print(a%b) # 1
# 거듭제곱
print(a**b) # 343
# 절대값(수와 수 사이의 차이)
print(abs(a-b)) # 4< 어림 계산 >
- 반올림[ round(숫자,자릿수) ] : 자릿수까지 4까지는 버리고 5부터는 올리는 계산을 한다.
- 올림[ math.ceil(숫자) ] : 소수점 이하값을 정수로 올린다.
- 내림[ math.floor(숫자) ] : 양수/음수 모드 현재의 값에서 소수점을 버리면서 작은 정수로 만든다.
- 버림[ math.trunc(숫자) ] : 소수점 이하값을 버린다.
a = 7
b = 3
# 반올림(소수점 둘째자리까지 반올림)
print(round(a/b,2)) # 2.3333333333333335 -> 2.33
# 올림
print(math.ceil(a/b)) # 4
# 내림
# 양수/음수 모두 현재의 값에서 소수점을 버리면서 작은 정수로 내려버린다.
print(math.floor(a/b)) # 2.3333333333333335 -> 2
a*=-1
print(math.floor(a/b)) # 2.3333333333333335 -> -3
# 버림
print(math.trunc(a/b)) # 2.3333333333333335 -> 2
print(int(a/b)) # 2.3333333333333335 -> 2
print(math.trunc(a/b)) # 2.3333333333333335 -> -2
print(int(a/b)) # 2.3333333333333335 -> -2< 응용연산 >
math 라이브러리를 활용하여 수학 수식을 빠르게 계산 결과를 반환하는 메서드들입니다.
- 팩토리얼[ math.factorial(숫자) ] : 1에서 숫자까지의 모든 자연수의 곱한 값을 계산한다.
- 거듭제곱[ math.pow(숫자,거듭제곱수) ] : 숫자를 거듭제곱수 만큼 곱한 값을 계산한다.
- 제곱근[ math.sqrt(숫자) ] : 숫자의 제곱근(제곱이 되도록 하는 값)을 계산한다.
- 최대공약수[ math.gcd(숫자1,숫자2...) ] : 입력한 숫자들의 최대공약수를 계산한다.
- 최소공배수[ math.lcm(숫자1,숫자2...) ] : 입력한 숫자들의 최소공배수를 계산한다.
import math
# 팩토리얼
print(math.factorial(5)) # 25
# 거듭제곱
parint(math.pow(2,3)) # 8.0
# 제곱근
print(math.sqrt(25)) # 5.0
# 최대공약수
print(math.gcd(25,15)) # 5
# 최소공배수
print(math.lcm(7,11)) # 77< 리스트 숫자 연산 >
리스트형일때 연산 가능한 메서드들입니다.
- 합계[ sum(list) ] : list안의 요소들의 합계를 계산한다.
- 평균[ sum(list)/len(list) ] : list안의 요소의 합의 평균을 계산한다.
- 갯수[ list.count(숫자) ] : list안에 숫자의 갯수를 반환한다.
numbers = [ i+1 for i in range(10) ]
print(numbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 합계
print(sum(numbers)) # 55
# 평균
print(sum(numbers)/len(numbers)) # 5.5
numbers = []
# 1부터 5까지 숫자 갯수만큼 numbers에 추가하기
for i in range(5):
for x in range(i+1):
numbers.append(i+1)
print(numbers)
# [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]
# 리스트 안 개수 확인
print(numbers.count(3)) # 3문자관련 문법
- 대문자로 변환[ string.upper() ] : 소문자를 대문자로 변환한다.
- 소문자로 변환[ string.lower() ] : 소문자를 대문자로 변환한다.
- 치환[ string.replace(바꿀문자,바뀔문자) ] : 바꿀문자를 바뀔문자로 치환한다.
- 왼쪽부터 인덱스값 찾기[ string.index(변수),string.find(변수) ] : 문자에서 변수와 일치하는 값의 인덱스를 반환한다.
변수와 일치하는 값이 없을경우 index는 error find는 -1를 반환한다. - 오른쪽 부터 인덱스 값 찾기[ string.rfind(변수) ] : 문자에서 변수와 일치하는 값의 인덱스를 반환한다.
- 특정문자로 시작하는지 확인[ string.startswith(문자,시작인덱스,끝인덱스) : 문자가 특정 문자로 시작하는지 확인하여 시작하면 True 아니면 False를 반환
- 특정문자로 끝나는지 확인[ string.endswith(문자,시작인덱스,끝인덱스) : 문자가 특정 문자로 끝나는지 확인하여 끝나면 True 아니면 False를 반환
rainbow = 'Red,Orange,Yellow,Green,Blue,Indigo,Purple'
# 대문자로 변환
print(rainbow.upper())
# RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,PURPLE
# 소문자로 변환
print(rainbow.lower())
# red,orange,yellow,green,blue,indigo,purple
# 치환
print(rainbow.replace(',','/'))
# Red/Orange/Yellow/Green/Blue/Indigo/Purple
# 왼쪽부터 인덱스 값 찾기
print(rainbow.index('u')) # 26
print(rainbow.find('u')) # 26
# 오른쪽부터 인덱스 값 찾기
print(rainbow.rfind('u')) # 37
# 특정 문자로 시작하는지 확인
print(rainbow.startswith('r')) # False
print(rainbow.startswith('R')) # True
print(rainbow.startswith('r',5)) # True
# 특정 문자로 끝나는지 확인
print(rainbow.endswith('E')) # False
print(rainbow.endswith('e')) # True
print(rainbow.endswith('p',0,len(rainbow)-2)) # False
# 공백 제거
text = ' Water boils at 100 degrees '
print('[' + text.rstrip() + ']') # [ Water boils at 100 degrees]
print('[' + text.lstrip() + ']') # [Water boils at 100 degrees ]
print('[' + text.strip() + ']') # [Water boils at 100 degrees]
# 동일문자 모두 제거
text = '0000000Water boils at 100 degrees 000'
print(text.lstrip('0')) # Water boils at 100 degrees 000
print(text.rstrip('0')) # 0000000Water boils at 100 degrees
print(text.strip('0')) # Water boils at 100 degrees
# 여러문자 모두 제거
text = ",,,,,123.....water....pp"
print(text.lstrip(',123.p')) # water....pp
print(text.rstrip(',123.p')) # ,,,,,123.....water
print(text.strip(',123.p')) # water리스트 관련 문법
- 인덱싱 : 리스트의 위치에 있는 값을 반환한다.
- 슬라이싱 : 시작점과 끝점을 []안에 넣을 수 있으며, 시작점부터 끝점전까지 값을 리스트형으로 반환한다.
- 변경 : 리스트의 인덱스값을 다른 값으로 변경할 수 있다.
- 뒤에 추가[ list.append(변수) ] : 리스트에 마지막에 변수를 추가할 수 있다.
- 앞에 추가[ list.insert(0,변수) ] : 리스트의 앞에 변수를 추가할 수 있다.
- 맨 뒤에값 제거[ list.pop() ] : 리스트의 마지막 값을 제거하고 그 값을 반환한다.
- 맨 앞에값 제거[ list.pop(0) ] : 리스트의 맨 앞에 값을 제거하고 그 값을 반환한다.
- 원하는 값 제거[ list.remove(0) ] : 리스트에 원하는 값이 있다면 해당 왼쪽부터 값을 찾아 하나만 없앤다.
- 원하는 값 index 확인[ list.index(변수) ] : 리스트에 입력한 변수의 인덱스를 반환한다.(값이 없을경우 에러 발생)
numbers = [ i+1 for i in range(10) ]
# 인덱싱
print(numbers[0]) # 1
print(numbers[-1]) # 10
print(numbers[-2]) # 9
# 슬라이싱
print(numbers[1:3]) # [2, 3]
print(numbers[:-1]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[1:-1]) # [2, 3, 4, 5, 6, 7, 8, 9]
# 변경
numbers[3] = 5
print(numbers) # [1, 2, 3, 5, 5, 6, 7, 8, 9, 10]
# 뒤에 추가
numbers.append(11)
print(numbers) # [1, 2, 3, 5, 5, 6, 7, 8, 9, 10, 11]
# 앞에 추가
numbers.insert(0,0)
print(numbers) # [0, 1, 2, 3, 5, 5, 6, 7, 8, 9, 10, 11]
# 맨 뒤에값 제거
numbers.pop()
print(numbers) # [0, 1, 2, 3, 5, 5, 6, 7, 8, 9, 10]
# 맨 앞에 값 제거
numbers.pop(0)
print(numbers) # [1, 2, 3, 5, 5, 6, 7, 8, 9, 10]
# 원하는 값 제거
numbrers.remove(5)
print(numbers) # [1, 2, 3, 5, 6, 7, 8, 9, 10]
# 왼쪽부터 일치하는 index 반환
print(numbers.index(5)) # 3Set 관련 문법
- Set(집합) 선언 : list나 dict의 경우 대괄호나 중괄호로 선언할 수 있다.
- Set 원소 확인 : in 함수를 사용하여 Set 안에 해당 원소가 있는지 없는지를 boolean 타입으로 확인이 가능하다.
- Set update : 보통 Set의 값에 여러데이터를 한번에 추가할때 사용한다.
- Set의 원소 제거 : Set에 포함된 원소 중 하나의 값을 제가한다.
- Set 복사 : Set의 원소를 다른 값에 복사한다.
- Set의 연산자 : 합집합,교집합,차집합,대칭차집합 등을 연산자로 구할 수 있다.
lst = [1,2,3,4,5,5,4,3]
# List to Set
setLst = set(lst)
print(setLst) # {1, 2, 3, 4, 5}
# Set 원소 확인
print(5 in setLst) # True
print(3 not in setLst) # False
# Set의 원소 추가
setLst.add(10)
print(setLst) # {1, 2, 3, 4, 5, 10}
# Set의 update
setLst.update([7,8,9,10])
print(setLst) # {1, 2, 3, 4, 5, 7, 8, 9, 10}
# Set 원소 제거
print(setLst.remove(5))
print(setLst) # {1, 2, 3, 4, 7, 8, 9, 10}
# Set 복사
copySet = setLst.copy()
print(copySet) # {1, 2, 3, 4, 7, 8, 9, 10}
# Set 연산자
a = {1,2,3,4,5}
b = {4,5,6,7,8}
c = a | b
print("a:{0}\nb:{1}\nc:{2}".format(a,b,c))
# 합집합
# a:{1, 2, 3, 4, 5}
# b:{4, 5, 6, 7, 8}
# c:{1, 2, 3, 4, 5, 6, 7, 8}
c = a & b
print("a:{0}\nb:{1}\nc:{2}".format(a,b,c))
# 교집합
# a:{1, 2, 3, 4, 5}
# b:{4, 5, 6, 7, 8}
# c:{4, 5}
c = a - b
print("a:{0}\nb:{1}\nc:{2}".format(a,b,c))
# 차집합
# a:{1, 2, 3, 4, 5}
# b:{4, 5, 6, 7, 8}
# c:{1, 2, 3}
c = a ^ b
print("a:{0}\nb:{1}\nc:{2}".format(a,b,c))
# 대칭차집합
# a:{1, 2, 3, 4, 5}
# b:{4, 5, 6, 7, 8}
# c:{1, 2, 3, 6, 7, 8}
출력
코딩테스트 문제를 풀다보면 디버그를 위해서 변수 혹은 리스트를 출력해야할 때가 있습니다. 그때 아래와 같이 출력 방법을 사용하여 출력하면 될것 같습니다.
# 직접 문자열 연결하기
print("2 단 "+str(2)+" x "+str(9)+" = "+str(2*9))
# 인덱스로 대입하기
print("2 단 {0} x {1} = {2}".format(2,9,2*9))
# 자료형으로 대입하기
print("2 단 %d x %d = %d"%(2,9,2*9))형변환
- int(숫자로 변환 가능한 문자) : 숫자로 변환 가능한 문자를 정수 형태로 만든다.
- str(변수) : 입력된 변수를 문자형태로 만든다.
- ord(문자형) : 문자형을 ASCII Code로 변환한다.
- chr(숫자형) : ASCII Code를 문자형으로 변환한다.
- list(map(자료타입,리스트형)) : 리스트의 요소를 자료 타입으로 형변환 하여 리스트로 반환한다.
print(str(125)) # '125'
print(int('25')) # 25
alphabet = 'a'
print(ord(alphabet)) # 97
ascii = 97
print(chr(ascii)) # a
numbers = [i+1 for i in range(10) ]
print(numbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 숫자형 리스트 -> 문자형 리스트
strings = list(map(str,numbers))
print(strings)
# ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
# 문자형 리스트 -> 숫자형 리스트
stringToNumbers = list(map(int,strings))
print(stringToNumbers)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]정렬관련 문법
- 원본변환 정렬형[ list.sort(revers=False) ] : 원본 요소들도 변환하여 정렬한다.
(reverse의 기본값은 False이며, True일 경우 역방향으로 정렬된다.) - 정렬 반환형[ sorted(list,reverse=False) ] : 원본 요소들을 변환하지 않고 정렬한 리스트만 반환한다.
(reverse의 기본값은 False이며, True일 경우 역방향으로 정렬된다.) - 원하는 방식으로 정렬형[ sorted(list,key=lambda,reverse=False) ] : key lambda식을 정렬식에 넘겨서 정의한 기준대로 요소들을 정렬한다.
(reverse의 기본값은 False이며, True일 경우 역방향으로 정렬된다.)
# 정렬 변환형
numbers = [15,222,8,79,10]
numbers.sort()
print(numbers) # [8, 10, 15, 79, 222
numbers.sort(reverse=True)
print(numbers) # [222, 79, 15, 10, 8]
strings = ['좋은하루','good_morning','굿모닝','niceday']
strings.sort()
print(strings) # ['good_morning', 'niceday', '굿모닝', '좋은하루']
strings.sort(reverse=True)
print(strings) # ['좋은하루', '굿모닝', 'niceday', 'good_morning']
# 정렬순서 반환형
numbers = [11,2,42,6,78,55]
print(sorted(numbers)) # [2, 6, 11, 42, 55, 78]
print(sorted(numbers,reverse=True)) # [78, 55, 42, 11, 6, 2]
strings = ['bat','cow','animal','cat','elephant','zoo','snake']
print(sorted(strings))
print(sorted(strings,reverse=True))
# 사용자정의 함수 정렬형
animal = ['cat','snake','elephant','chicken','horse','fox','puma','tiger','duck']
# 글자 길이대로 정렬
print(sorted(animal,key = lambda x:len(x)))
# ['cat', 'fox', 'puma', 'duck', 'snake', 'horse', 'tiger', 'chicken', 'elephant']
# 첫글자 기준으로 정렬
print(sorted(animal,key = lambda x:x[0]))
# ['cat', 'chicken', 'duck', 'elephant', 'fox', 'horse', 'puma', 'snake', 'tiger']
# 알파벳 순서로 s를 생성
alphabet = list(map(chr,range(ord('a'),ord('z')+1)))
print(alphabet)
# ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# 지정한 숫자 순서대로 정렬
sorting = [1,25,3,4,5,6,7,20,9,10,11,15,13,14,12,16,17,18,19,8,21,22,23,24,2,26]
def numOrd(n):
return sorting[alphabet.index(n)]
print(sorted(alphabet,key=numOrd))
# ['a', 'y', 'c', 'd', 'e', 'f', 'g', 't', 'i', 'j', 'k', 'o', 'm', 'n', 'l', 'p', 'q', 'r', 's', 'h', 'u', 'v', 'w', 'x', 'b', 'z']
# 지정한 알파벳 순서대로 정렬
sorting = ['z', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'k', 'j', 'i', 'l', 'm', 'n', 'o', 'q', 'p', 'r', 's', 't', 'w', 'v', 'u', 'x', 'y', 'a']
def rtn(n):
return alphabet.index(n)
# 위에서 정한 sorting 기준으로 정렬
print(sorted(alphabet,key=rtn))
# ['z', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'k', 'j', 'i', 'l', 'm', 'n', 'o', 'q', 'p', 'r', 's', 't', 'w', 'v', 'u', 'x', 'y', 'a']경우의 수 관련 문법
< 순열 >
- permutations는 리스트와 같은 iterable 객체에서 n개의 데이터를 뽑아 일렬로 나열하는 모든 경우(순열)을 계산해준다.
- 첫번째 인자에 리스트 인자를 두번째 인자에 뽑을 데이터의 갯수를 입력한다.
- permutations는 클래이스이므로 객체 초기화 이후에는 리스트 자료형으로 변환하여 사용해야한다.
import itertools
item = ['A','B','C']
print(list(itertools.permutations(item,1)))
# [('A',), ('B',), ('C',)]
print(list(itertools.permutations(item,2)))
"""
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
"""
print(list(itertools.permutations(item,3)))
"""
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'),
('C', 'B', 'A')]
"""< 조합 >
- combinations는 리스트와 같은 iterable 객체에서 n개의 데이터를 뽑아 순서와 상관없이 나열한 모든 경우(조합)을 계산한다.
- combinations도 첫번째 인자는 리스트형, 두번째 인자는 뽑을 개수를 넣는다.
- combinations도 클래스 이므로 리스트 자료형으로 변환하여 사용한다.
import itertools
item = ['A','B','C','D']
print(list(itertools.combinations(item,1)))
# [('A',), ('B',), ('C',), ('D',)]
print(list(itertools.combinations(item,2)))
# [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')]
print(list(itertools.combinations(item,3)))
# [('A', 'B', 'C'), ('A', 'B', 'D'), ('A', 'C', 'D'), ('B', 'C', 'D')]
print(list(itertools.combinations(item,4)))
# [('A', 'B', 'C', 'D')]< 중복순열 >
- product는 permutations와 같이 리스트와 같은 iterable 객체에서 n개의 데이터를 뽑아 일렬로 나열하는 모든 경우(순열)를 계산한다. 다만 원소를 중복하여 뽑는다.
- product는 첫번째 인자에 뽑을 리스트를 두번째 인자에 뽑을 데이터의 수를 repeat 속성값으로 넣어준다.
- product는 클래스이므로 리스트 자료형으로 변환하여 사용한다.
- 서로 다른 문자의 중복순열값도 반환 할 수 있다.
import itertools
item = ['A','B','C']
print(list(itertools.product(item,repeat=1)))
# [('A',), ('B',), ('C',)]
print(list(itertools.product(item,repeat=2)))
"""
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'),
('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
"""
print(list(itertools.product(item,repeat=3)))
"""
[('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A', 'C'), ('A', 'B', 'A'), ('A', 'B', 'B'),
('A', 'B', 'C'), ('A', 'C', 'A'), ('A', 'C', 'B'), ('A', 'C', 'C'), ('B', 'A', 'A'),
('B', 'A', 'B'), ('B', 'A', 'C'), ('B', 'B', 'A'), ('B', 'B', 'B'), ('B', 'B', 'C'),
('B', 'C', 'A'), ('B', 'C', 'B'), ('B', 'C', 'C'), ('C', 'A', 'A'), ('C', 'A', 'B'),
('C', 'A', 'C'), ('C', 'B', 'A'), ('C', 'B', 'B'), ('C', 'B', 'C'), ('C', 'C', 'A'),
('C', 'C', 'B'), ('C', 'C', 'C')]
"""
# 서로다른 문자들의 중복순열값도 확인 할 수 있다.
strings = ['123','ABC','abc']
print(list(itertools.product(*strings)))
"""
[('1', 'A', 'a'), ('1', 'A', 'b'), ('1', 'A', 'c'), ('1', 'B', 'a'), ('1', 'B', 'b'),
('1', 'B', 'c'), ('1', 'C', 'a'), ('1', 'C', 'b'), ('1', 'C', 'c'), ('2', 'A', 'a'),
('2', 'A', 'b'), ('2', 'A', 'c'), ('2', 'B', 'a'), ('2', 'B', 'b'), ('2', 'B', 'c'),
('2', 'C', 'a'), ('2', 'C', 'b'), ('2', 'C', 'c'), ('3', 'A', 'a'), ('3', 'A', 'b'),
('3', 'A', 'c'), ('3', 'B', 'a'), ('3', 'B', 'b'), ('3', 'B', 'c'), ('3', 'C', 'a'),
('3', 'C', 'b'), ('3', 'C', 'c')]
"""< 중복조합 >
- combinations_with_replacement는 combinations와 같이 리스트와 같은 iterable 객체에서 n개의 데이터를 뽑아 순서를 고려하지 않고 나열하는 모든 경우(조합)을 계산한다. 다만 원소를 중복해서 뽑는다.
- combinations_with_replacement는 첫번째 인자를 리스트 객체를 두번째 인자를 중복해서 뽑을 갯수를 숫자로 입력한다.
- combinations_with_replacement는 클래스이므로 리스트 자료형으로 변환하여 사용한다.
import itertools
item = ['A','B','C']
print(list(itertools.combinations_with_replacement(item,1)))
# [('A',), ('B',), ('C',)]
print(list(itertools.combinations_with_replacement(item,2)))
# [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
print(list(itertools.combinations_with_replacement(item,3)))
"""
[('A', 'A', 'A'), ('A', 'A', 'B'), ('A', 'A', 'C'), ('A', 'B', 'B'), ('A', 'B', 'C'),
('A', 'C', 'C'), ('B', 'B', 'B'), ('B', 'B', 'C'), ('B', 'C', 'C'), ('C', 'C', 'C')]
"""
혹시라도 정정할 내용이나 추가적으로 필요하신 정보가 있다면 댓글 남겨주시면 감사하겠습니다.
오늘도 Jindory 블로그에 방문해주셔서 감사합니다.
반응형