728x90
Last update : 2023.06.27
# 기본 입출력 빠르게 하기
• import sys
• input = sys.stdin.readline : 끝에 () 넣지 말 것!!
• print = sys.stout.write : 끝에 항상 print(f'{}...{}...\n') 처리
- print가 무조건 string으로 받고, 끝에는 \n 붙여야함!
정리하자면
1. input()보다는 sys.readline()을 쓰자.
2. 빈 리스트에 append()로 추가하는 것보단 입력 받을 개수 만큼 초기화된 리스트에 인덱스를 이용해서 접근해서 그 위치에 직접 입력받자.
3. 줄바꿈 할때엔 print()가 아니라 '\n', for문 마다 출력하지 말고 문자열 변수에 저장해놓고 한 번에 출력하자.
# lambda의 사용
• 형식 = lambda 인자 : 인자로 표현된 식
• 인자 넣기 = (lambda x : x+10)(1) --> print 없이 바로 실행
• 인자 2개 넣기 = (lambda x,y : x+y)(1,2)
• if 사용하기 = check_pass = lambda x : 'pass' if x>= 80 else 'fail'
• 2. 리스트의 정렬 key 사용 : x는 리스트의 각 원소
a = [(1, 2), (5, 1), (0, 1), (5, 2), (3, 0)]
• key 인자를 정하지 않고 그냥 sorted를 쓰면 튜플 순서대로 우선순위 기본 할당
b = sorted(a)
b = [(0, 1), (1, 2), (3, 0), (5, 1), (5, 2)]
• key인자에 함수를 넘겨주면 우선순위가 정해짐
c = sorted(a, key = lambda x : x[0])
c = [(0, 1), (1, 2), (3, 0), (5, 1), (5, 2)]
d = sorted(a, key = lambda x : x[1])
d = [(3, 0), (5, 1), (0, 1), (1, 2), (5, 2)]
• 비교할 아이템이 요소가 복수 개일 경우, 튜플로 우선순위를 정할 수 있음 (-를 붙이면 반대차순으로 정렬됨)
e = sorted(a, key = lambda x : (x[0], -x[1]))
=> [(0, 1), (1, 2), (3, 0), (5, 2), (5, 1)]
f = sorted(a, key = lambda x : -x[0])
=> [(5, 1), (5, 2), (3, 0), (1, 2), (0, 1)])
• 뒤에 문자순 정렬
s = ['2 A', '1 B', '4 C', '1 A']
s.sorted(s, key=lambda x: (x.split()[1], x.split()[0]))
=> ['1 A', '2 A', '1 B', '4 C']
a_list = ['a', 'b', 'd', 'd', 'b','s']
a_counter = Counter(a_list).most_common()
=> [('b', 2), ('d', 2), ('a', 1), ('s', 1)]
• 문자 역순(아스키 값 이용)
sorted(a_counter, key=lambda x: (-x[1], -ord(x[0])))
=> [('d', 2), ('b', 2), ('s', 1), ('a', 1)]
• 3. map 람다 표현식
• list(map(lambda x: x로 이루어진 표현식, lst))
list(map(lambda x: x+10, [1,2,3]))
=> [11, 12, 13]
• 4. filter() : 조건식의 bool값이 True인 요소만 반환
a = [8, 4, 2, 5, 2, 7, 9, 11, 26, 13]
result = list(filter(lambda x : x > 7 and x < 15, a))
=> [8, 9, 11, 13]
• 5. reduce() 표현식 : 값을 누적시킴
from functools import reduce t = [47, 11, 42, 13]
result = reduce(lambda x, y : x + y, t)
=> 113
• 대문자인지 확인
• x.isupper() : 대문자일 경우 True 반환
• 소문자인지 확인
• x.islower() : 소문자일 경우 True 반환
• 알파벳인지 확인하기
• x.isalpha() : x가 알파벳인지 확인
• ord : 문자 -> 숫자
• chr : 숫자 -> 문자
• A : 65 ~ Z : 90 / a : 97 ~ z: 122
• 서로 다른 print문끼리 연결 : end 옵셥
• 하나의 print문 안에서 요소끼리 연결 : sep 옵션
• 자료형을 대조할 때 : is를 사용
• if type(v) is bool:
• join 함수 : 리스트 안의 원소(string)들을 구분자로 연결 -> 문자열로 반환
• '구분자'.join(리스트)
• lst = ['a','b','c','d']
• print(''.join(리스트))
• ', '로 연결하고 싶을 때 : join으로 연결 (다만 list안의 원소들은 string으로 연결해야 함)
• print("<"+", ".join(list(map(str,array)))+ ">" )와 같이
• 리스트 안의 문자열 원소 통합 --> 문자열로 출력하고 싶을 때
• print(''.join(list))
• TypeError: sequence item 0: expected str instance, int found
• string이 아니라 int들을 합칠 때 발생하는 오류
• ''.joint(list(map(str,array)))
• return이 없는 함수 (print로 바로 출력) : 함수만 호출하면 바로 출력
• reuturn이 있는 함수 (print를 따로 써줘야함): return값을 받는 변수를 생성 -> 그 변수를 print해서 함수 호출
• 차집합 (list로 구현시)
• lst = [ x for x in set_a if x not in set_b]
• a에 있으면서 b에 없는 원소를 count : a-b
• 차집합 (set으로 구현시)
• set(map(int,input().split())) 으로 입력받기
• a - b or a.differnce(b)
• Asterisk(*)의 사용법
• 곱셈 및 거듭제곱 연산으로 사용
• 리스트형 컨테이너 타입의 데이터를 반복 확장
• 컨테이너 타입의 데이터를 unpacking 할 때 (*list 처럼)
• list, tuple, dict, set 형태의 데이터를 순서대로 데려옴
• print(*array, sep = '\n')와 같이 sep 옵션과 응용가능
• print(*sorted(list))와 같이 응용도 가능
• 함수의 return
• return (값) 이 나오면 continue 처럼 이후의 작업은 시행하지 않고 return값만 반환하고 끝남
• if graph[x][y] == 0 :
• graph[x][y] =1
• dfs(x-1,y)
• dfs(x,y-1)
• dfs(x+1,y)
• dfs(x,y+1)
• return True
• return False
• 이처럼 위의 return True가 시행되면 아래의 return False는 시행되지 않는다
• 예외처리시 continue의 역할 :
• 예외 발생시 임시 저장소에서 끝 (최종 저장소로 옮기지 않음)
• nx나 ny에 뭔가가 저장되도 어차피 새롭게 assign되면 의미 없음
• list의 이웃하는 원소끼리 비교할 때 : i & i+1 사용하되 원래 range에서 1뻬기
• lst[i] < lst[i+1] for i in range(len(lst)-1)로 처리
• global (변수명) : 함수 '안'에서 사용
• 최대 재귀 한도 에러 :
• import sys
• sys.setrecursionlimit(10**n)
• DFS에서 한 group 안의 노드 개수 구하기 :
• 맨 마지막 재귀함수 아래에 cnt+=1 & 출력하는 print문에서 result.append(cnt) ; cnt = 0으로 초기화
• DFS에서 group의 총 개수 구하기 :
• dfs(x,y)가 True일 경우 -> num+=1 해주기
• BFS에서 정답에 해당하는 case 발견시 : break 바로 해주기
• for i in range(n,0,-1) : i가 n에서 1까지임 (두 번째 숫자 0 까지가 아님)
• 함수를 종료하고 싶을 때 : return
• return 뒤에 아무것도 쓰지 않으면 ok
• 조건문 안에 'and'나 'if'가 있는 경우
• 왼쪽 조건부터 판단(검사)하기 때문에 좌측에 '선제조건'을 넣어줘야 함
• while (left<= end and array[pivot] >= array[left]) : 이건 되고
• while (array[pivot] >= array[left] and left<= end ) : 이건 안되는 이유?
• 만약 left가 100이고 end가 100이여서 통과가 됐다면 -> left가 101이 되는데 아래꺼는 런타임에러(인덱스 오류)가 발생
• 산술 연산자 : %는 나머지 & //는 몫
• 리스트 슬라이싱
• [:] = 처음부터 끝까지
• [start:] = start부터 끝까지
• [:end] = 처음부터 end-1 까지
• [start : end] = start부터 end-1 까지
• [start : end : step] = step만큼 문자를 건너뛰면서, 위와 동일하게 추출
• 정렬 with revese 옵션 넣기
• sorted(lst, reverse = True)
• lst.sort(reverse = True)
• 함수에서 예외처리시 : return None / return False / continue 등과 같이 처리
• 리스트 뺄셈 (같은 요소끼리) :
• for x,y in zip(lst_x,lst_y) :
• print(x-y)
• [ x-y for x,y in zip(lst_x,lst_y)]
• 리스트 - 리스트 (차집합) :
• [ i for i in sub_a if i not in sub_b]
• lst = Counter(lst_x)-Counter(lst_y)
• print(list(lst.keys()))
• while 조건문 / 재귀함수 사용시 주의할 점 : 반드시 종료조건을 명시해줄 것!!
• list에서 최대 / 최소값을 구하는 경우 :
• sort메소드를 이용해서 [0]이나 [-1]으로 찾아도 되고
• max(array) 나 min(array)를 사용해도 ok
• 1차원 리스트로 주어진 숫자 받기
array = list(map(int,st.readline().split()))
dp = []
idx = 0
• 입력받은 숫자들을 일정한 기준으로 끊어서 2차원 리스트 만들기
for i in range(n) :
• 한번 입력받을 때 한 행 전체를 다 입력받기
dp.append(array[idx:idx+m])
idx += m
• readlines로 받을 떼 : 한 줄씩 list의 원소로 들어감
• split으로 처리
• index slicing으로 처리
• split의 역할 : 문자열을 maxsplit 횟수만큼 sep의 구분자를 기준으로 구분
--> 나눈 값은 list 안에 하나씩 들어가게 됨
• string.split() :공백(스페이스, 탭, 엔터 등)을 기준으로 문자열을 나누어 줌
• string.split('구분자') : 괄호 안의 값을 구분자로 해서 문자열을 나누어 줌
• string.split('구분자', 분할횟수)
• string.split(sep = '구분자', maxsplit = 분할횟수)
• 처음부터 input으로 받으면 처음~끝까지 '하나의 블록'으로 처리함
• split함수가 띄어쓰기를 '분리자(기준)'로 해서 하나의 커다란 블록을 잘게 분리함
• ex ) 2 3 4 이렇게 입력을 하면 input함수는 '2 3 4' 이렇게 인식을 하지만 split함수가 이를 띄어쓰기 단위로 분리함
string = "word1 word2 word3 word4 "
• split() : 공백이 1개,2개,..여러 개여도 모두 1개의 공백으로
> ['word1', 'word2', 'word3', 'word4']
• split(" ") : 공백 1개, 1개를 모두 공백으로 따로따로 처리
> ['word1', 'word2', '', 'word3', '', '', 'word4', '', '', '', '']
• 공백을 기준으로 구분된 데이터를 입력 받을 때 (map에 list)
• list(map(int, input().split())) : 정수형으로 list를 형성
• list(map(int, stdin.readline().split())) : 정수형으로 list를 형성
• list(input().split()) , input().split() : 문자열대로 list를 형성
• lst = [list(map(int,st.readline().split())) for _ in range(meeting_number)]
• : 공백 기준으로 구분된 데이터를 여러 줄 받을 때
• 공백을 기준으로 구분된 데이터가 많지 않을 때 (map only)
• a,b,c = map(int, input().split())
• 공백없이 구분된 데이터를 list로 입력 받을 때
• list(map(int,input()))
• 자료형을 대조할 때 : is를 사용
• if type(v) is bool:
• 제거(remove,pop)와 반복문(for, while)을 같이 사용하지 말 것
• remove / pop 으로 인덱스에 변화를 주면 :
• for문과 같이 쓰면 인덱스가 달라짐
• 즉 원래 인덱스 값을 유지하는 것을 copy해서 copy한 놈의 인덱스 값을 참조
• for - else 구문 & while - else 구문
• for/while문에서 모든 원소를 반복했을 경우에 else구문 실행
• for/while문이 중간에 중단됐을 경우 : else구문 실행
• 2중 for문 사용시 유용 point (j열의 반복을 i번 할 수 있음)
for i in range(n) :
for j in range(i)
• range 함수 중 내림차순으로 사용시 :
for i in range(n,k,-1) -> k가 아니라 k+1까지!! (하나 전!)
• 이중 for문
• break : 가장 안 쪽 loop 전체를 빠져나옴
• continue : 1회성 안 쪽 loop만 빠져나옴
• 2차원 리스트 보기 쉽게 정리하기
lst = [ [0]*3 for _ in range(3)]
print(lst)
• 2차원 리스트 눈에 보기 쉽도록 정리하기
• 순서대로 1번, 2번
for i in lst : • 1번
print(*i)
for i in lst : • 2번
for j in i :
print(j, end = ' ')
print()
• .index(값) : 해당 값의 index를 반환
• .remove(값) : 해당 값 중 가장 먼저 나오는 놈을 제거
• round 함수 (반올림)
• round(n,digits)
• n : 내가 넣는 숫자
• digits : 반올림하고 싶은 자리'까지' (소수 0번째 자리까지가 기본)
num = 12345.6789
print("기존 값 : ", num)
print("1 의 자리까지 반올림 : ", round(num, -1))
print("10 의 자리까지 반올림 : ", round(num, -2))
print("100 의 자리까지 반올림 : ", round(num, -3))
print("1000 의 자리까지 반올림 : ", round(num, -4))
print("소수 0번째 자리까지 반올림 : ", round(num))
print("소수 1번째 자리까지 반올림 : ", round(num, 1))
print("소수 2번째 자리까지 반올림 : ", round(num, 2))
print("소수 3번째 자리까지 반올림 : ", round(num, 3))
• Output
• 기존 값 : 12345.6789
• 1 의 자리까지 반올림 : 12350.0
• 10 의 자리까지 반올림 : 12300.0
• 100 의 자리까지 반올림 : 12000.0
• 1000 의 자리까지 반올림 : 10000.0
• 소수 0번째 자리까지 반올림 : 12346
• 소수 1번째 자리까지 반올림 : 12345.7
• 소수 2번째 자리까지 반올림 : 12345.68
• 소수 3번째 자리까지 반올림 : 12345.679
• 주의) round_half_even 방식 사용 : 정확하게 half 지점에 있을 때 짝수쪽으로 근사를 해줌
• print(round(4.50000)) -> 4반환
• print(round(5.50000)) -> 6반환
• print(round(4.51000)) -> 5반환
• 해결법 : a+=0.5 후 int로 형변환 (round_half_up)
• f-string으로 숫자에 3자리마다 콤마 넣기
• print(f"{num:,}")
• tuple
• 리스트에 비해 공간 효율적
• 순서O, 중복O, 수정X, 삭제X
• append method 사용 불가
• list.append(tuple)은 가능하다!!!
• for i,j,k...등 in (iterable data structure)
• 입력하는 변수명과 반복문에 들어가는 변수 (i,j,k...등)이 같으면 안됨!!
• ex) n, k = map(int, input().split())
• for k in range(len(list)) : 어쩌구...
• 가능한 합/차 등..의 모든 case를 구하는 경우
• 2중, 3중...for문을 이용해서 '완전탐색'을 구현할 수도 있다!!
• zip method
• 여러개의 iterable한 자료형에서 "index 순서대로" 요소를 묶어서 새로운 iterable 자료형 만들기
• 길이를 다르게 한다면 가장 짧은 길이의 인자에 맞춰지고 나머지는 버려지게 됨
• zip(iterable한 자료형 여러개 : list 여러 개, tuple 여러 개 등..)
• "여러개"의 iterable 자료형(list,tuple, dict, set)등 반복가능한 자료형)이 개수가 "동일"할 때
• 자료형의 각각의 요소를 나눈 후 "순서대로" 묶어서 요소 개수만큼 새로운 iterable한 자료형 생성
• iterable자료형
num = [1, 2, 3]
fruit = ['apple', 'banana', 'orange']
color = ['red', 'yellow', 'orange']
• zip함수로 묶어줌
zip_list = zip(num, fruit, color)
print(zip_list, type(zip_list))
<zip object at 0x0000020180766048> <class 'zip'> • zip 타입으로 출력
• print(list(zip_list)) • list 타입으로 변환
[( 1, 'apple', 'red'), (2, 'banana', 'yellow'), (3, 'orange', 'orange')]
• 1. 반복문 활용
• for x, y in zip(range(10), range(10)): • 두개의 0~9까지 숫자모음
print(x, y)
• 2. 전치행렬 생성하기
• [ list(x) for x in zip(*lst)]
• list(x) for x in zip(여러개의 list들) : 여러개의 list들의 같은 index를 모아서 여러개의 list로 반환
• 3. dict 만들기
• A = ['name', 'age', 'phone', 'gender']
• B = ['CHAN', 28, '010-XXXX-YYYY', 'male']
• d = dict(zip(A, B))
• print(d)
>>>
{'name': 'CHAN', 'age': 28, 'phone': '010-XXXX-YYYY', 'gender': 'male'}
• float 자료형 양의 무한대, 음의 무한대 --> 주의) 정수에 적용할 수 없음
float('inf') • 가장 큰 값 : 무한대
float('-inf') • 가장 큰 값 : 무한대
• int자료형 정수 최대와 최소 값
maximum = sys.maxint
minimum = sys.miniint
• int 자료형 정수 최대와 최소 값
maximum = sys.maxsize
minimum = -(sys.maxsize+1)
• for문 돌면서 index값도 같이 참조해야 할 때 : enumerate 사용
• enumerate의 특징 :
시작 index값을 변경할 수 있음 by adding start parameter
• for idx, data in enumerate(array, start = k)
k 정수부터 인덱스값 +1
• 자릿수의 합 구하는 코드 :
• result = sum(int(i) for i in string)
• def digit_sum(x) :
sum = 0
while x>0 :
sum+=x%10
x//=10
• count함수 : 'string' / lst에서 사용가능
• list의 원소 중복여부 체크시 사용
• lst.count(원소) > 1 : ~
• dict안에 tuple을 key나 value로 넣고 싶다면 그냥 괄호()가 아니라 tuple()로 묶어줘야 함
• res.update({tuple(i[:size]) : tuple(i[size:])}) (O)
• res.update({(i[:size]) : (i[size:]) }) (X)
• 두 개의 dict를 병합하고 싶을 때
• update
• dict1.update(dict2) : dict1에 dict2를 병합 (없는 키의 경우 추가, 있을 경우 dict2껄로 덮어씀)
• Counter 모듈
• dict(Counter(dict1) + Counter(dict2)) : 없는 키의 경우 추가, 있을 경우 각자의 value를 합함
• 최빈값 / 빈도수 구하기 : Counter함수는 리스트나 튜플에서 각 데이터가 등장한 횟수를 사전형식으로 반환
• 시간복잡도 = O(N)
• from collections import Counter
• colors = ['red', 'blue', 'red', 'green', 'blue', 'blue']
• cnt = Counter(colors)
• print(cnt)
>>> Counter({'blue': 3, 'red': 2, 'green': 1})
• most_common() method는 등장한 횟수를 내림차순으로 정리하여 보여줌
• >>> numbers = [1, 2, 3, 3, 4, 4, 4, 5, 5]
• >>> from collections import Counter
• >>> cnt = Counter(numbers)
• >>> cnt.most_common()
• [(4, 3), (3, 2), (5, 2), (1, 1), (2, 1)]
• cnt.most_common(x) : 상위 x개의 결과만을 원할 때
>>> mode = cnt.most_common(1)
>>> mode
[(4, 3)]
• 최빈값을 원할 때
>>> mode[0][0]
• 만약 빈도수가 같다면 (x[1]이 같다면) : x[0]의 순서는 '입력순'으로 주어짐!! (오름차순이나 내림차순 아님)
• replace 함수의 사용 :
• variable.replace(old, new, [count])
• old : 변경하고 싶은 문자
• new : 새로 바꿀 문자
• count : 변경할 횟수 , 따로 입력하지 않으면 문자열 전체를 변경함
• 중요) ---> 방향으로 바꾸는 거!!!
• find 함수의 사용
• str.find('특정 문자' or '특정 문자열')
• 처음으로 특정 값이 나온 index를 반환
• 만약 찾는 문자나 문자열이 없을 경우 -1을 반환!!
• 에라스토테네스의 채 : array의 0,1번째 index를 따로 False처리!! (소수가 아님)
• 집합 자료형
• 차집합 : set1-set2, set1.difference(set2)
• 대칭차집합 : set1 ^ set2
• f-string으로 소수점 제한
• print(f"문자열 {변수:.nf}") --> {변수:소수점자리수f}
• n은 출력하고 싶은 소수점'까지'
• print(f'f-string example1 : {num1:.0f}') : 0번째 자리까지
• print(f'f-string example2 : {num1:.1f}') : 1번째 자리까지
• print(f'f-string example3 : {num1:.2f}') : 2번째 자리까지
• print(f'f-string example4 : {num1:.3f}') : 3번째 자리까지
• print(f'f-string example5 : {num1:.4f}') : 4번째 자리까지
• dictionary comprehension
• {array[i] : i for i in range(len(array))} 와 같이 사용가능
• 자기자신보다 작은 원소의 개수 check : 중복제거후 정렬한 리스트에서 index 번호가 답!
• sorted(list(set(array))) : 인덱스 번호 체크
• 한 문장 안에 if else 사용하기 with end 옵션
• res = 1 if num in cards else 0
• print(res, end = ' ')
• in 함수 사용할 때 시간복잡도
• list, tuple
Average : O(n)
하나하나 순회하기 때문에 O(n)만큼의 시간복잡도를 갖는다
• set, dictionary
Average : O(1), Worst : O(n)
내부적으로 hash를 통해 저장하므로 접근하는 시간은 O(1)이다. 하지만 해쉬의 충돌이 많아 성능이 떨어지는 경우 O(n)이 걸릴 수도 있다.
• .isdigit() : 모든 숫자형을 True로 인식 (2^31도 True로 인식)
• .isdecimal() : 0~9까지의 정수를 True로 인식
• string 앞에 있는 모든 '0'들을 제거 -> 정수로 만들기 : int(string.lstrip('0'))
• 합이 일정 & 두 수가 합을 이룰 때 : 그 쌍은 중앙값을 기준 대칭으로 형성 -> 두 수의 차가 최소가 되려면 중앙값+/-i 값부터 확인
• Deque methods 정리 <list method에 존재여부>
• q.append(item) : 오른쪽 끝에 삽입 <O>
• q.appendleft(item) : 왼쪽 끝에 삽입 <X>
• q.pop() : 가장 오른쪽으 요소 반환 및 삭제 <O>
• q.popleft() : 가장 왼쪽의 요소 반환 및 삭제 <X>
• q.extend(array) : 주어진 array를 q의 오른쪽에 추가 <O>
• q.extendleft(array) : 주어진 array를 q의 왼쪽에 추가 <X>
• q.remove(item) : 해당 item을 q에서 찾아 삭제 <O>
• q.rotate(숫자) : 해당 숫자만큼 회전 (양수:->, 음수:<-) <X>
• deuque에 원소 넣기
• for문을 이용해서 deque.append(i)해서 일일이 넣기
• array = deque(list(map(int, input().split() )))와 같이 deque안에 list를 넣기
• deuque은 정렬이 불가능하다!
• 다만 정렬한 후 리스트가 되는데, 이를 다시 deque해주면 된다!
• 순열, 조합, 팩토리얼 끝의 0의 개수 찾기
• = 뒤에 10이 곱해진 개수 = min(2가 곱해진 개수, 5가 곱해진 개수)
• 팩토리얼 끝의 0 개수 = min(count_5(x),count_2(x))
• 순열 끝의 0 개수 = min(count_5(m)-count_5(m-n),count_2(m)-count_2(m-n))
• 조합 끝의 0 개수 = min(count_5(m)-coun_5(n)-count_2(m-n),count_2(m)-coun_5(n)-count_2(m-n))
• 정수론 :
• 1~x까지의 정수 중 n의 배수 개수 = [x/n]
• = [x/n] = n의 배수 중에 x보다 작거나 같은 수의 개수
• n!에서 소수 p의 최대 개수 = n!이 p를 인수로 몇개나 갖고 있는가 = r
• r = [n/p] + [n/p^2] + [n/p^3] + ....
• while n!= 0 :
n//=p
cnt+=n
• 3개 이상의 수에 대한 최대공약수 구하기
from math import gcd
ans = res[0]
for i in range(1,len(res)) :
ans = gcd(res[i],ans)
print(ans)
• -n진수 구하기
• 일반적으로 10진수 -> n진수 변환과 똑같음
• 다만 나머지는 always >0 여야 하므로 n%2==0 일때와 n%2!=0 일 때 몫이 달라짐
• 2로 나누어지지 않으면 int(n//2+1) , 나누어지면 n//2로 처리
• Stack 및 Queue의 응용
• if문이나 while문에 'and' , 'or'조건 결합 가능
• while stack and i>stack[-1][1] 와 같이 사용
• if - else문에 동일한 코드가 둘 다 들어갈 경우 -> 최적화 여부 의심!
• stack이나 queue안에 list를 넣어 2차원 리스트로 구성가능
• 이 경우 stack.pop() = num, value 와 같이 인자를 2개씩 받을 수 있음
• for문에 enumerate함수를 이용하여 idx,i를 적재적소에 사용가능
• list 초기화 with 1~n까지의 수
• [i for i in range(1,n+1)]
• list(range(n+1)) : range함수 사용 & 이 방법도 알아두기!!
• for문에서의 범위
• / 연산은 float 반환 , // 연산이 int를 반환
• index range를 n/2 로 하지 말 것!
• index range를 n//2 연산을 해야 '정수'로 나옴
• while문 사용시 주의할 점 : and, or의 사용
• 탈출할 조건을 먼저 생각
• 그 후에 여집합을 걸어서 while(조건문) 안에 조건문 넣기
• map 함수 : list(map(function, iterable한 자료구조))
• print(list(map(conv_abs,[1,-3,2,0,-5,6])))
• print(list(map(lambda x : abs(x) ,[1,-3,2,0,-5,6])))
• filter(func_name,test_case) :
• test_case중 함수 조건에 맞는 놈들만 호출
• map(func_name, test_case) :
• test_case 모두가 함수를 거친 결과를 반환
• input().split() 만 해도 이미 list안에 알아서 저장됨
• list (크기 +1) 하는 이유 : '숫자 i or i번째 수'가 중요할 때!
• list를 (크기+1) 시킨 후, 맨 앞에 임의의 숫자 추가 : 특히 구간합 구할 때는 0을 추가!
• i번째 원소 = index[i]로 할당하고 싶기 때문
• 숫자 i를 i번째 index에 할당하고 싶을 때
• 합 배열 구하기 -> 구간합 구하기 문제
- index 번호 = i번째 수 : 맞추기 위해 합 배열의 [0]은 임의의 값 집어넣기 (list의 크기를 +1)
- 원 배열 A는 크기 n으로 해도 상관없음
- 합 배열 D는 크기를 반드시 +1 해줘야 함!!
< 합 배열 리스트 >
- 1차원 리스트 초기화시 : [0] * (n+1) or [0] & append
- 2차원 리스트 초기화시 : [[0]*(n+1) for _ in range(n+1)]
• '합'에 관한 나머지 연산 : 합 배열, 원 배열들의 원소들을 미리 나누고 시작해도 ok
• (a+b)%c = ((a%c) + (b%c))%c 와 같음
• 특정 구간 수들의 나머지 연산을 더해 나머지 연산을 한 값과 이 구간 합의 나머지 연산을 한 값은 동일
• (S[i] - S[j-1]) % M = (a[j] + a[j+1] + .... + a[i]) % M = (a[j]%M + a[j+1]%M + .... + a[i]%M) % M = (S[i]%M - S[j-1]%M) %M
• 즉, (S[i] - S[j-1]) % M = (S[i]%M - S[j-1]%M) %M : 부분합 리스트의 각 원소를 M으로 미리 나누고 시작
• 배열 안의 두 원소가 같은 경우의 수 구하기 : nC2의 합
- 이중 for문으로 완전 탐색하기
- Dp 테이블로 해당 원소(index) 등장할 때마다 Dp[index]값에 +1 (횟수카운팅) -> Dp 테이블의 각 index를 참조하면서 값(n)을 이용해 nC2의 합 계산
• if __name__ == "__main__" :
• 스크립트 파일이 메인 프로그램으로 사용될 때와, 모듈로 사용될 때를 구분하기 위한 용도라 생각하면 됨
• 가져다 쓸 때 메인이 아니라 파일 이름이 돼서 불러온 모듈에서는 실행x
• __name__ : 모듈의 이름이 저장되는 변수 & import 했을 때 모듈의 이름이 들어감
• 즉, 어떤 스크립트 파일이든, 파이썬 인터프리터가 최초로 실행한 스크립트 파일의 __name__ 변수에는 '__main__'이 들어가는 것
• 파이썬은 최초로 시작하는 스크립트 파일과 모듈의 차이가 없습니다.
• 어떤 스크립트 파일이든, 시작점이 될 수 있고, 모듈도 될 수 있는 것입니다.
• 함수를 정의할 때 주의할 점!! with 지역/전역 변수
• def sub_array_x(array,x) :
global dp,sum..등
• 인자들(arguments) : 새롭게 함수 내에서만 정의
• 인자들(arguments)를 제외한 함수식에 있는 변수들 : global로 전역변수 처리해줄 필요
• dp table에서 입력 받자마자 갱신하는 코드
for _ in range(n) :
dp[int(input())]+=1
• Deque + 슬라이딩 윈도우 -> 정렬을 O(N)으로 구현할 수 있음
- Deque이 다음과 같음
• Priority Queue : 우선순위 큐
• from queue import PriorityQueue
• myQueue = PriorityQueue() : 크기가 무한대
• myQueue = PriorityQueue(maxsize=n) : 크기가 n
• 데이터 추가의 순서는 상관없지만 제거될 때는 오름차순으로 제거한다
- 자동으로 오름차순 정렬하고 [0]을 제거
• 우선순위 큐에 원소 추가 :
- myQueue.put(x) : 정수 추가
- myQueue.put( (우선순위1, 우선순위2, 우선순위3,..., item) ) : 우선순위를 지정하고 우선순위에 의해 삭제순서 지정
-> 튜플 형태로 저장 & if last 우선순위 == item일 경우는 item을 굳이 안 써도 됨
• 우선순위 큐에 원소 삭제 : myQueue.get() --> 우선순위의 오름차순으로 데이터 삭제
• 우선순위 큐의 크기 확인 : myQueue.qsize()
• 우선순위 큐가 비어있는지 확인 : myQueue.empty()
• 우선순위 큐가 꽉 찼는지 확인 : myQueue.full()
# 함수 안에서 break 처럼 중간에 끝내고 싶을 때 :
• return 단독으로 쓰면 됨
• 왠만하면 /(나눗셈)연산 지양
• /보다 //(몫)연산 or int(/연산) 우선 사용!
• graph, visited 를 제외한 새로운 check list 가하기
• check[i] = (check[v]+1)%2
• check list에 기록시 0이면 1, 1이면 0으로 처리해주는 tool
• 이중 for문을 즉시 멈추고 싶다면 :
• sys.exit() code를 실행
• 함수의 return with 재귀함수
• 보시다시피 리턴문이 없으면 함수는 제일 마지막 줄에서 끝이 나게 됩니다.
• 리턴문으로 인해 해당 함수를 실행한 결과를 반환하고 함수 실행이 종료 되는데,
• 리턴문이 없으면 결과를 반환하지 못한 채 함수가 종료되기 때문에 해당 함수는 아무것도 없는 빈 값인 None이 찍히게 되는 겁니다.
• % 연산의 특징
• n%k에서 :
• n > k 일 경우 우리가 일반적으로 아는 mod 연산
• n < k 일 경우 그냥 "n반환"
• Python 기본 연산의 시간복잡도
• 세트/딕셔너리는 삽입,제거,탐색,포함여부 확인 메소드가 O(1)이라 O(N)인 리스트보다 유리하다.
• 반면 리스트는 순서가 있거나 index로 요소에 접근할 필요가 있을 때 활용하면 좋다.
• title method : 각 단어의 첫 글자를 대문자화함
name = input("What's your name? ")
name = name.strip().title()
print(f"hello, {name}")
• f-string으로 숫자에 3자리마다 콤마 넣기
• print(f"{num:,}")
x = float(input("What’s x? "))
y = float(input("What’s y? "))
z = round(x + y)
print(f"{z:,}")
• 리스트 자료형(순서O, 중복O, 수정O, 삭제O)
• 튜플 자료형(순서O, 중복O, 수정X,삭제X)
• 집합(Sets) 자료형(순서X, 중복X)
• 딕셔너리 자료형(순서X, 키 중복X, 수정O, 삭제O)
• list의 값 제거 방법
• lst.remove(제거할 놈)
• del lst[idx 번호]
• lst.pop(idx 번호)
• list의 copy
array = []
array.copy()
new_array = list(array) • 이 방법도 알아둘 것
• dictionary
• add items
• dict[key] = value : 속성 값으로 추가
• dict.update({key : value}) : update method로 추가
• remove items
• dict.pop(key)
• dict.popitem() : 가장 마지막으로 추가된 item제거
• del dict[key]
• dict.clear()728x90
