👉 오늘 한 일

• 코드 스니펫 정리
• 코테 문제풀이

코드 스니펫

Built-in function

list

# 리스트 메서드
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',  
 'clear',  
 'copy',   
 'count', 
 'extend', 
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

• append : 리스트 끝에 원소를 추가

# append
x = [1,2,3,4]
x.append([3,4])
print(x)

>> [1, 2, 3, 4, [3, 4]]

• extend : 리스트 끝에 모든 원소 추가

# extend 
x = [1,2,3,4]
x.extend([3,4])
print(x)

>> [1, 2, 3, 4, 3, 4]

• clear : 리스트 안의 원소 모두 삭제

x = [1, 2, 3, 4, 5]
print(x)
x.clear()
print(x)

>> [1, 2, 3, 4, 5]
>> []

• count(a) : 리스트 안에 원소 a의 개수 반환

x = [1, 6, 3, 6, 5, 6, 7]
x.count(6)

>> 3

• index : 리스트 값의 위치를 반환

x = [5, 8, 3]
x.index(8)

>> 1

• insert (a,b): 리스트의 a위치에 b 원소 삽입

x = [1, 7, 2, 8, 4]
x.insert(2,5)
x

>> [1, 7, 5, 2, 8, 4]

• pop : 리스트의 지정한 위치의 원소 삭제

x = [0, 2, 4, 6, 8]
x.pop(1)
x

>> [0, 4, 6, 8]

• remove : 리스트에 들어있는 원소 중 지정한 원소 삭제

x = [0, 2, 4, 6, 8]
x.remove(6)
x

>> [0, 2, 4, 8]

format( )

• format(value, format_spec)
• 형식 지정자가 제어하는 주어진 값의 형식화 된 표현을 출력

# 단위 : 원
format(10000000000, ',')

>> '10,000,000,000'

# 지수
format(10000000000, 'e')

>> '1.000000e+10'

# 16진수
format(10000000000, 'x')
# hex(10000000000) <- 16진수로 변환 

>> '2540be400'

# 오른쪽 정렬 
format(100000, '0>020,.4f')
# 왼쪽 정렬 
format(100000, '0<020,.4f')
# 가운데 정렬 
format(100000, '0=020,.4f')

>> '00000000100,000.0000'
>> '100,000.000000000000'
>> '000,000,100,000.0000'

filter( )

• filter(function, iterable)
• iterable의 각 요소가 true인지 아닌지 확인후 출력

# 0~19에서 짝수만 출력(lambda)
list(filter(lambda x : True if x % 2 ==0 else False, range(20)))

# 0~19에서 짝수만 출력(리스트 컴프리헨션)
[i for i in range(20) if i % 2 == 0]

>> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

map( )

map(function, iterable, ...)

• 주어진 function를 iterable의 각 항목에 적용하고 결과 목록을 출력

# 0~19에서 짝수인지 아닌지 bool 형태로 출력
list(map(lambda x: x % 2 == 0, range(20)))

>> [True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False]

zip( )

• zip(*iterables)
• iterables을 가져와 튜플로 집계하여 출력

x = ['a','b','c']
y = [1,3,2]

z = list(zip(x,y))
print(z)

>> [('a', 1), ('b', 3), ('c', 2)]

# 쌍이 맞다면 리스트와 문자열을 묶을 수도 있다
list(zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4], [10, 20, 30, 40], 'ABCD'))
set(zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4], [10, 20, 30, 40], 'ABCD'))

>> [('a', 1, 10, 'A'), ('b', 2, 20, 'B'), ('c', 3, 30, 'C'), ('d', 4, 40, 'D')]
>> {('a', 1, 10, 'A'), ('b', 2, 20, 'B'), ('c', 3, 30, 'C'), ('d', 4, 40, 'D')}

max/min( )

• max(iterable, *iterables, key, default)
• min(arg1, arg2, *args, key)
• iterable에서 가장 큰 항목을 반환
• min(iterable, *iterables, key, default)
• max(arg1, arg2, *args, key)
• iterable에서 가장 작은 항목을 반환

# 'key' 파라미터를 이용해 딕셔너리나 튜플이 들어간 리스트에서 
# key, value 중 어떤 값을 기준으로 추출할지 선택할 수 있음

# 딕셔너리
x = {8: 1, 3: 9, -2: 1, 10:-1}

result1 = max(x) # key값의 min
print(result1) 
 
result2 = max(x, key = lambda k: x[k])
print(result2)   # value가 큰 key 값  
print(x[result2])# key 값을 적용시킨 value

>> 10
>> 3
>> 9

# 튜플
arr = [(0,10),(1,14),(2,2),(3,24)]
str = max(arr,key = lambda x:x[1])

sort( )

• sort : 리스트의 원본을 직접 정렬

x = [10, 5, 8]
y = x.sort() # 변수에 할당되지 않음. copy 이용

print(x)
print(y)

>>[5, 8, 10]
>> None

• sorted : 리스트의 원본은 그대로 보존하고 정렬된 값을 반환

# 'key' 파라미터를 이용해 정렬 조건을 줄 수 있음
# reverse = True => 내림차순
testCaseOne = ['abc', 'def', 'hello world', 'hello', 'python']
testCaseTwo = 'Life is too short, You need python'.split()
testCaseThree = list(zip('anvfe', [1, 2, 5, 4, 3]))

sorted(testCaseOne, key=len, reverse=True)
sorted(testCaseTwo, key=str.lower)
sorted(testCaseThree, key=lambda x:x[1])
sorted(testCaseThree, key=lambda x:x[0])

>> ['hello world', 'python', 'hello', 'abc', 'def']
>> ['is', 'Life', 'need', 'python', 'short,', 'too', 'You']
>> [('a', 1), ('n', 2), ('e', 3), ('f', 4), ('v', 5)]
>> [('a', 1), ('e', 3), ('f', 4), ('n', 2), ('v', 5)]

reversed( )

• reverse : 리스트 원본 순서를 거꾸로 뒤집기

x = [10, 5, 8]
y = x.reverse() # sort와 마찬가지로 변수에 할당되지 않음 
print(x)
print(y)

>> [8, 5, 10]
>> None

• reversed : 리스트의 원본은 그대로 보존하고 순서를 거꾸로 뒤집기

x = [10, 5, 8]
y = reversed(x)
print(list(x))
print(list(y))

>> [10, 5, 8]
>> [8, 5, 10]

set( )

• set(iterable)
• 중복을 제거하고자 할 때도 사용함
• set의 메서드로 집합연산 가능

# 단톡방에 x마리의 동물이 대화를 하고 있습니다.
# 각각의 동물들이 톡을 전송할 때마다 서버에는 아래와 같이 저장됩니다.
# 1. 단톡방에는 모두 몇 마리의 동물이 있을까요? 톡은 무조건 1회 이상 전송합니다.
# 2. 단톡방에 동물들마다 몇 번의 톡을 올렸을까요?

serverData = '개리 라이캣 개리 개리 라이캣 자바독 자바독 파이 썬'

len(set(serverData.split()))

d = {}
for i in set(serverData.split()):
    print(i, serverData.split().count(i))
    d[i] = serverData.split().count(i)
d

>>
라이캣 2
썬 1
파이 1
자바독 2
개리 3

# 집합 연산
판콜에이 = {'A', 'B', 'C'}
타이레놀 = {'A', 'B', 'D'}

print(판콜에이.difference(타이레놀)) #차집합
print(판콜에이.intersection(타이레놀)) #교집합
print(len(판콜에이.intersection(타이레놀))) #교집합
print(판콜에이.union(타이레놀)

>>
{'C'}
{'B', 'A'}
2
{'B', 'A', 'D', 'C']

split( )

• split(separator, maxsplit)
• 문자열 메서드임

# maxsplit 파라미터로 나누는 횟수 지정 가능(디폴트는 -1 => 나눌 수 있을만큼 다 나눔)
text = 'Hello, world, python'
strings = text.split(',', 1)
print(strings)

>> ['Hello', ' world, python']

enumerate( )

• enumerate(iterable, start=0)
• iterable에 counter 추가하고 출력한다

x = ['one','two','three']
# 원소를 하나만 할당했을 때는 기본적으로 튜플 형태로 출력
for iterable in enumerate(x):
    print(iterable)

# 인덱스와 원소를 각각 다른 변수에 할당하고 싶다면 unpacking(인자 풀기)
for counter , value in enumerate(x):
    print(counter, value)

>> (0, 'one')
>> (1, 'two')
>> (2, 'three')

>> 0 one
>> 1 two
>> 2 three

# start 파라미터값을 조정해서 시작 인덱스 변경 가능
x = [10,20,30,40,50]

for i , j in enumerate(x,2):
    print(i , j)

>> 2 10
>> 3 20
>> 4 30
>> 5 40
>> 6 50

abs( )

• abs(num)
• 주어진 숫자의 절대 값을 출력

abs(-1)

>> 1

프로그래머스 문제풀이

1. 두 정수 사이의 합🌟

https://school.programmers.co.kr/learn/courses/30/lessons/12912

def solution(a, b):
    return sum(range(min(a,b), max(a,b)+1))

2. 문자열 내 p와 y의 개수🌟

https://school.programmers.co.kr/learn/courses/30/lessons/12916

def solution(s):
    p = s.lower().count("p")
    y = s.lower().count("y")
    return True if p == y else False

3. 나머지가 1이 되는 수 찾기🌟

https://school.programmers.co.kr/learn/courses/30/lessons/87389

def solution(n):
    for x in range(1, n+1):
        if n % x == 1:
            return x

4. 부족한 금액 계산하기🌟

https://school.programmers.co.kr/learn/courses/30/lessons/82612

def solution(price, money, count):
    p = []
    for n in range(1, count+1):
        p.append(price*n)
        
    if money >= sum(p):
        return 0
    elif money < sum(p):
        return sum(p) - money

5. 신규 아이디 추천 (정규표현식)🌟🌟

https://school.programmers.co.kr/learn/courses/30/lessons/72410

import re

def solution(new_id):
    new_id = new_id.lower()
    new_id = re.sub("[^a-z0-9-_\.]", "", new_id)
    new_id = re.sub("[\.]{2,}", ".", new_id)
    new_id = re.sub("^\.", "", new_id)
    new_id = re.sub("\.$", "", new_id)
    if new_id == "":
        new_id = "a"
    if len(new_id) >= 16:
        new_id = new_id[:15]
        new_id = re.sub("\.$", "", new_id)
    elif len(new_id) <= 2:
        while len(new_id) < 3:
            new_id += new_id[-1]
    
    return new_id

6. 올바른 괄호(스택&큐) 🌟🌟

https://school.programmers.co.kr/learn/courses/30/lessons/12909

def solution(s):
    stack = []
    for i in s:
        if i == "(":
            stack.append(i)
        else:
            if stack == []:
                return False
            else:
                stack.pop()
    return len(stack) == 0

7. 같은 숫자는 싫어(스택&큐)🌟🌟

https://school.programmers.co.kr/learn/courses/30/lessons/12906

def solution(arr):
    stack = []
    result = [arr[0]]
    for n in arr:
        if stack:
            curr = stack.pop()
            if curr != n:
                result.append(n)

        stack.append(n)
    return result