Hash

  • 데이터를 다루는 기법 중에 하나
  • 검색과 저장이 아주 빠르게 진행
  • 데이터를 검색할 때 사용할 key와 실제 데이터의 값이 (value가) 한 쌍으로 존재하고, key값이 배열의 인덱스로 변환
  • 검색과 저장의 평균적인 시간 복잡도가 O(1)에 수렴

완주하지 못한 선수

1차 답안

1
2
3
4
5
6
def solution(participant, completion):
    for member in participant:
        if member in completion:
            completion.remove(member)
        else:
            return member

비효율적인 코드여서 효율성 통과 X

2차 답안

sort() : 정렬, 기본값은 오름차순 정렬, reverse옵션 True는 내림차순 정렬

1
2
3
4
5
6
7
a = [1, 10, 5, 7, 6]
a.sort()
a
# [1, 5, 6, 7, 10]
a.sort(reverse=True)
a
# [10, 7, 6, 5, 1]
1
2
3
4
5
6
7
8
def solution(participant, completion): 
    participant.sort() 
    completion.sort() 
    for i in range(len(completion)): 
        if participant[i] != completion[i]: 
            return participant[i] 
    
    return participant[i+1]

전화번호 부

find(찾을문자, 찾기시작할위치)

1
2
3
4
5
6
def solution(phone_book):
    for i in range(len(phone_book)):
        for j in range(i+1, len(phone_book)):
            if phone_book[i].find(phone_book[j]) == 0 or phone_book[j].find(phone_book[i]) == 0:
                return False
    return True

startswith(시작하는문자, 시작지점)

1
2
3
4
5
6
def solution(phone_book):
    for i in range(len(phone_book)):
        for j in range(i+1, len(phone_book)):
            if phone_book[i].startswith(phone_book[j]) == True or phone_book[j].startswith(phone_book[i]) == True:
                return False
    return True

다른사람 풀이

sort() : 정렬, 기본값은 오름차순 정렬, reverse옵션 True는 내림차순 정렬

1
2
3
4
5
6
7
a = [1, 10, 5, 7, 6]
a.sort()
a
# [1, 5, 6, 7, 10]
a.sort(reverse=True)
a
# [10, 7, 6, 5, 1]
1
2
3
4
5
6
def solution(phone_book):
    phone_book.sort() 
    for i in range(len(phone_book)-1): 
        if phone_book[i] in phone_book[i+1]: 
            return False 
    return True

위장

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def solution(clothes):
    closet = {}
    result = 1
    for element in clothes:
        key = element[1]
        value = element[0]
        if key in closet:
            closet[key].append(value)
        else:
            closet[key] = [value]
            
     # {'headgear': ['yellow_hat', 'green_turban'], 'eyewear': ['blue_sunglasses']}
    
    for key in closet.keys():
        result = result * (len(closet[key]) + 1)
    return result - 1

다른사람 풀이

1
2
3
4
5
6
def solution(clothes):
    from collections import Counter
    from functools import reduce
    cnt = Counter([kind for name, kind in clothes])
    answer = reduce(lambda x, y: x*(y+1), cnt.values(), 1) - 1
    return answer

Counter
컨테이너에 동일한 값의 자료가 몇개인지를 파악하는데 사용하는 객체이다.

1
2
3
4
5
import collections
lst = ['aa', 'cc', 'dd', 'aa', 'bb', 'ee']
print(collections.Counter(lst))

# Counter({'aa': 2, 'cc': 1, 'dd': 1, 'bb': 1, 'ee': 1})

reduce
reduce(집계 함수, 순회 가능한 데이터[, 초기값])

1
2
3
4
5
6
7
8
9
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 
# 15

reduce(lambda x, y: x+y, [1, 2, 3, 4, 5], 10) 
# 25

reduce(lambda x, y: x*y, range(1, 6)) 
# 120

베스트 앨범

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
def solution(genres, plays):

    list_dict = {}
    music = {}

    for i in range(len(genres)):
        if genres[i] in music.keys():
            music[genres[i]] += plays[i]
            list_data = [i, plays[i]]
            list_dict[genres[i]].append(list_data)
        else:
            music[genres[i]] = plays[i]
            list_data = [[i, plays[i]]]
            list_dict[genres[i]] = list_data


    res = sorted(music.items(), key=(lambda x: x[1]), reverse = True)

    first_genres = []
    second_genres = []

    max = 0
    second_value = 0
    first = 0
    second = 0

    for idx in list_dict[res[0][0]]:
        print(idx)
        if max < idx[1]:
            if max !=0:
                second_value = max
                second = first
            first = idx[0]
            max = idx[1]
        elif second_value < idx[1]:
            second = idx[0]
            second_value = idx[1]
        first_genres = [first, second]

    max = 0
    second_value = 0
    first = 0
    second = 0

    for idx in list_dict[res[1][0]]:
        if max < idx[1]:
            if max !=0:
                second_value = max
                second = first
            first = idx[0]
            max = idx[1]
        elif second_value < idx[1]:
            second = idx[0]
            second_value = idx[1]
        second_genres = [first, second]
    return first_genres + second_genres
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def solution(genres, plays):
    genre_cnt_dict = {}
    for genre, play in zip(genres, plays):
        if genre in genre_cnt_dict.keys():
            genre_cnt_dict[genre] += play
        else:
            genre_cnt_dict[genre] = play
    print(genre_cnt_dict)

    info_dict = {}
    for idx, info in enumerate(zip(genres, plays)):
        genre, play_cnt = info[0], info[1]
        genre_cnt = genre_cnt_dict[genre]
        if genre in info_dict.keys():
            if len(info_dict[genre]) >= 2:
                info_dict[genre].append([genre_cnt, play_cnt, idx])
                info_dict[genre] = sorted(info_dict[genre], key=lambda x: -x[1])[:2]
            else:
                info_dict[genre].append([genre_cnt, play_cnt, idx])
        else:
            info_dict[genre] = [[genre_cnt, play_cnt, idx]]

    final_list = sum(info_dict.values(), [])
    ffinal_list = sorted(final_list, key=lambda x: (-x[0], -x[1], x[2]))

    return [i[2] for i in ffinal_list]

    answer = 0

zip()

시퀸스 자료형을 튜플로 묶어 리스트로 만든다.

1
2
3
4
5
a = [1,2,3]
b = "123"
c = ("a","b","c")
zip(a,b,c)
# [(1,'1','a'), (2,'2','b'), (3,'3','c')]

enumerate()
인덱스 번호와 컬렉션의 원소를 tuple형태로 반환합니다.

1
2
3
4
5
6
7
8
9
t = [1, 5, 7, 33, 39, 52]
for p in enumerate(t):
    print(p)
#(0, 1)
#(1, 5)
#(2, 7)
#(3, 33)
#(4, 39)
#(5, 52)