바다에 퐁당 Ꙭ̮ ꉂ ◡̈⋆*

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

문제 개요

• 장르 별로 가장 많이 재생된 노래 2개씩 => 베스트 앨범
• 곡의 고유번호는 genres의 index.

1. 장르 정렬: 곡수
2. 장르 내 곡 정렬: 재생량 / 같으면 고유번호 낮은 거 먼저.

입력 2개: 노래 장르 list, 노래별 재생횟수 list
return: 베스트앨범 내 노래 고유번호 list

코드

def solution(genres, plays):
  gen_type = set(genres)
  gen_dict = {hash(a):0 for a in gen_type} #dictionary comprehension
  
  genres = [hash(b) for b in genres] #list comprehension
  zipped = list(enumerate(list(zip(genres, plays)))) #enumerate 통해 index 반환
  
  for item in zipped:
    gen_dict[item[1][0]] += item[1][1]
  gen_dict = sorted(gen_dict.items(), key=lambda x : x[1], reverse=True) #how to sort dictionary #method 'sort' is not available
  gen_sort = [x for x in list(map(lambda x: x[0], gen_dict))] #곡 재생수가 가장 큰 순으로 장르 나열
  answer=[]
  for gen in gen_sort:
    a=[] #장르별 곡 리스트
    for zips in zipped:
      if zips[1][0]==gen:
        a.append(zips)
      else:
        continue
    a.sort(key=lambda x: x[1][1], reverse=True)
    answer+=[x for x in list(map(lambda x: x[0], a[:2]))]

  return answer

주요 도구

- 알고리즘: 해시(딕셔너리, 파이썬 hash 함수)

- dictionary comprehension: 딕셔너리 생성하여 각 장르를 key, 장르별 곡 재생수의 총합을 value로 정리함

- zip(리스트1, 리스트2)에 list를 한번 더 씌워야 함 => 각 튜플에도 다중 인덱스로 접근 가능

- index 정보를 반환해주는 enumerate에도 list를 한번 더 씌워야 함 => 마찬가지, 각 원소에 다중 인덱스로 접근 가능

- 기존에 value값이 0으로 저장된 딕셔너리에 [] 인덱스 통해 => 적절한 key값을 입력해줌

- 특정 기준으로 iterable 정렬하기: sorted & key & lambda의 조합! lambda 통해 iterable의 '각 원소'에 구체적으로 접근 가능.

- 딕셔너리 정렬: 메서드 sort 대신 함수 sorted, 단 .items() 메소드 붙여야 함!

- map & lambda 조합 역시 중요: 주어진 이터러블 '각 원소'에 '동시에' 특정 함수를 적용하고 싶을 때.

   map(함수, 이터러블) => map(lambda x: x~~, 이터러블)

   마찬가지 map 이후 list 한번 더 씌워야 함.

- continue는 for문 처음으로 다시 돌아가는 것 vs return은 for문을 포함하여 함수 전체를 종료시키는 것

- indentation 아주 중요함. 엄밀한 논리 & 초반에 정확한 설계

다른 사람의 모범 풀이

def solution(genres, plays):
    answer = []
    d = {e:[] for e in set(genres)}
    for e in zip(genres, plays, range(len(plays))):
        d[e[0]].append([e[1] , e[2]])
    genreSort =sorted(list(d.keys()), key= lambda x: sum( map(lambda y: y[0],d[x])), reverse = True)
    for g in genreSort:
        temp = [e[1] for e in sorted(d[g],key= lambda x: (x[0], -x[1]), reverse = True)]
        answer += temp[:min(len(temp),2)]
    return answer

def solution(genres, plays):
    answer = []
    dic = {}
    album_list = []
    for i in range(len(genres)):
        dic[genres[i]] = dic.get(genres[i], 0) + plays[i]
        album_list.append(album(genres[i], plays[i], i))

    dic = sorted(dic.items(), key=lambda dic:dic[1], reverse=True)
    album_list = sorted(album_list, reverse=True)



    while len(dic) > 0:
        play_genre = dic.pop(0)
        print(play_genre)
        cnt = 0;
        for ab in album_list:
            if play_genre[0] == ab.genre:
                answer.append(ab.track)
                cnt += 1
            if cnt == 2:
                break

    return answer

class album:
    def __init__(self, genre, play, track):
        self.genre = genre
        self.play = play
        self.track = track

    def __lt__(self, other):
        return self.play < other.play
    def __le__(self, other):
        return self.play <= other.play
    def __gt__(self, other):
        return self.play > other.play
    def __ge__(self, other):
        return self.play >= other.play
    def __eq__(self, other):
        return self.play == other.play
    def __ne__(self, other):
        return self.play != other.play