유용한 문법

global 키워드

a = 0
array = [1, 2, 3]

def func():
    global a # 전역 변수를 사용하겠다.
    a += 1
    
    array.append(4) # 배열은 global 없이 사용 가능하다.

for i in range(10):
    func()

print(a) // 10
print(array) # [1, 2, 3, 4]

 

우선 순위: 지역 > 전역

함수 내에서 전역 변수를 사용하고 싶다면, global로 해당 변수를 함수 스코프로 가져와야 함.

 

배열은 global 없이도 사용 가능하다.

그러나 함수 내에 같은 이름의 배열이 있다면, 지역 배열 우선이다.

 

packing, unpacking

def operator(a, b):
    add_var = a + b
    subtract_var = a - b
    multiply_var = a * b
    divide_var = a / b
    return add_var, subtract_var, multiply_var, divide_var

a, b, c, d = operator(7, 3)
print(a, b, c, d) # 10, 7, 21, 2.33333

 

Python은 한 번에 여러 개의 값을 return 할 수 있다. 이것이 packing.

return된 값들을 한 번에 여러 개의 변수에 할당할 수 있다. 이것이 unpacking.

 

람다 표현식

def add(a, b):
    return a + b
 
# 일반적인 함수 표현식
print(add(3, 7)) # 10

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

 

간단한 함수의 경우, 함수의 정의 없이 lambda 표현식을 사용하여 표현할 수 있다.

자바스크립트의 arrow 표현식이나, Swift의 closure와 비슷한 듯하다.

 

sort 혹은 map 함수에 자주 쓰인다.

# 정렬할 때
array = [("홍길동", 50), ("이순신", 32), ("아무개", 74)]

def my_key(x):
    return x[1]

print(sorted(array, key = my_key)) # [("이순신", 32), ("홍길동", 50), ("아무개", 74)]
print(sorted(array, key = lambda x: x[1]) # [("이순신", 32), ("홍길동", 50), ("아무개", 74)]
# 여러 개 리스트에
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = map(lambda a, b: a + b, list1, list2)
print(list(result)) # [7, 9, 11, 13, 15]

 

 

표준 라이브러리

내장 함수

입출력, 정렬 등 기본 함수 제공.

 

itertools

반복되는 형태의 데이터를 처리.

순열, 조합, 중복 순열, 중복 조합 등

 

heapq

힙(heap, 최대값 or 최소값을 빠르게 찾아내기 위한 완전이진트리) 자료구조 제공.

일반적으로 우선순위 큐 기능을 구현하기 위해 사용.

 

bisect

이진 탐색(Binary Search) 기능 제공.

 

collections

deque, counter 등

 

math

수학적 기능 제공,.

팩토리얼, 제곱근 최대공약수(GCD), 삼각함수 등 함수.

pi 등 상수.

 

내장 함수

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

# min, max
min_res = min(7, 3, 5, 2)
max_res = max(7, 3, 5, 2)
print(min_res, max_res) # 2, 7

# eval
result = eval("(3 + 5) * 7") # 띄어쓰기 해도 된다. 짱이썬.
print(result) # 56
# sorted()
# 기본적으로 오름차순
result = sorted([9, 1, 8, 5 , 4]) # [1, 4, 5, 8, 9]
reverse_result = sorted([9, 1, 8, 5, 4], reverse = True) # [9, 8, 5, 4, 1]

# sorted() with key
array = [("홍길동", 50), ("이순신", 32), ("아무개", 74)]
result = sorted(array, key = lambda x: x[1], reverse = True) # [("이순신", 75), ("아무개", 50), ("홍길동", 35)]

 

itertools

# 순열(permutation)
from itertools import permutations

data = ["A", "B", "C"]
result = list(permutations(data, 3))
# [('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]
# 조합(combinations)
from itertools import combinations  

data = ["A", "B", "C"]
result = list(combinations(data, 2))

print(result)
# 중복 순열(product)
from itertools import product  

data = ["A", "B", "C"]
result = list(product(data, repeat = 2))

print(result)
# [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
# 중복 조합(combinations_with_replacement)
from itertools import combinations_with_replacement  

data = ["A", "B", "C"]
result = list(combinations_with_replacement(data, 2))

print(result)
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

 

Collections - Counter

# Counter
from collections import Counter

counter = Counter(["red", "blue", "red", "green", "blue", "blue"])
counter_dict = dict(Counter(["red", "blue", "red", "green", "blue", "blue"]))
print(counter) # Counter({'blue': 3, 'red': 2, 'green': 1})
print(counter_dict) # {'red': 2, 'blue': 3, 'green': 1}

 

math

import math

def lcm(a, b): # lcm(최소공약수)의 성질을 이용해 구하는 함수
    return a * b // math.gcd(a, b) # gcd는 최대공약수

print(lcm(21, 14))

 

 

출처

이것이 취업을 위한 코딩 테스트다 with 파이썬, 나동빈, 2021

https://softeer.ai/practice/6289


회고

현대오토에버 코테를 준비하기 위해, 출제 플랫폼인 소프티어에서 맛 좀 봤다.
가장 놀라운 것은 Swift 채점을 지원하지 않는다 ...!
그래서 예전 기억을 더듬거리며 Python으로 풀었다.

- 소프티어의 특징은, 입력값을 직접 받아야 한다.
    - 코딜리티와 프로그래머스와는 다르다.
    - 따라서 Swift로 입력값 받는 연습을 해야겠다.
- 코드를 수동으로 저장해야 한다.
- 공식 문서가 제공된다.
- 에러 내용이 제공된다.
- 자동 완성을 지원한다.

문제 자체는 LV.3인데도 불구하고 쉬웠다.
그래프를 생성해서, 인접한 노드와 값을 비교하기만 하면 되는 문제였다.

접근

N, M
N: 각 회원이 들 수 있는 무게
M: 친분 관계

N명의 회원을 탐색하며, (인접 리스트로 구현한다, 방향이 없는 무향 그래프가 되어야 한다)
연결된 모든 회원과 비교
비교 결과, 자기 자신이 가장 높으면 ans += 1

인접 리스트와 인접 행렬 중에서, 인접 리스트를 선택한 이유는 아래와 같다.

노드 최대 개수(N): 10 ** 5
간선 최대 개수(E): 10 ** 5
인접 행렬: 공간 복잡도 O(N^2) / 노드 하나당 시간 복잡도 O(N); 항상 O(N)
인접 리스트: 공간 복잡도 O(E) / 노드 하나당 시간 복잡도 O(E); 모든 노드가 O(E)인 경우는 드물다.

나의 풀이

import sys

n, m = map(int, input().split())
recordArr = list(map(int, input().split()))
adjancyList = [[] for _ in range(n+1)] # 아래에 입력될 노드 번호가 1~5이므로, indexError를 방지하기 위해 n+1
ans = 0

# 연결 리스트 생성
for i in range(m):
    a, b = map(int, input().split())
    # 방향이 없으므로 양쪽 모두 연결
    adjancyList[a].append(b)
    adjancyList[b].append(a)

# 모든 회원 탐색하며 비교
for i in range(1, n+1):
    isBiggest = True
    for adjElem in adjancyList[i]:
        if recordArr[adjElem - 1] >= recordArr[i - 1]: # Biggest 해야 하니까 같은 기록이 있는 경우도 안 된다
            isBiggest = False
            break
    
    if isBiggest:
        ans += 1

print(ans)

+ Recent posts