11-alstjr7437

[alstjr7437]

🔗 문제 링크

베스트 앨범

✔️ 소요된 시간

40분

📜 문제 설명

각 노래별 장르와 재생된 횟수가 저장되어 있습니다.

0	1	2	3	4
classic	pop	classic	classic	pop
500	600	150	800	2500

위 표와 같이 각 장르와 재생 횟수가 주어지면

1. 각 장르별 재생횟수 먼저 선정
   classic : 500 + 150 + 800 = 1450
   pop : 600 + 2500 = 3100
   으로 pop장르가 더 많이 재생되었습니다.
2. 장르내 많이 재생된 곡 선정
   그렇게 되서 pop장르의 재생순으로 2곡을 먼저 [4,1]
   그리고 classic장르의 재생순으로 2곡을 뽑아서 [4,1,3,0]이 나오게 됩니다.
3. 재생 횟수가 같으면 고유번호가 낮은 노래 먼저 선정

✨ 수도 코드

그렇게 위 문제를 이용해서 수도코드를 먼저 짜면

1. 각 장르와 재생횟수를 가져와 딕셔너리로 만든다

   • 형태는 {'장르' : [[재생횟수,인덱스]], 'pop' : [[600, 1], [2500, 4]]}

2. 해당 딕셔너리의 재생횟수와 인덱스 부분을 재생횟수별로 정렬해준다.

   • {'pop' : [[2500, 4], [600, 1]]}

3. 각 key를 가지고 총합을 계산해준다.(각 장르별 총 재생횟수)

4. 총합을 가지고 딕셔너리를 재정렬 해준다.

   • pop이 더 많으니 pop이 먼저오게

5. 정답에 각 딕셔너리별로 2개씩 들고와서 추가한다.

   • 대신 한개면 하나만 추가하도록 한다.

이렇게 수도코드는 잘 나왔는데 구현 부분에서 막히는 부분이 많았습니다..

1번, 3번, 5번은 어떻게 잘 됐지만 2번,4번에서 아직 lambda함수가 익숙하지 않아서 막히는 부분이 많았습니다..
그냥 lambda만 있으면 어떻게 잘 쓸 수 있겠지만 반복문까지 같이 쓰려고 하니까 참 힘들더라구요

def solution(genres, plays):
    answer = []
    dict = {}

    # 1. 딕셔너리 만들기
    for i in range(len(genres)):
        if genres[i] not in dict :
            dict[genres[i]] = [[plays[i], i]]
        else :
            dict[genres[i]].append([plays[i],i])
            
    
    # 2. 딕셔너리 안에 재생회수로 재정렬
    for genres, plays in dict.items():
        dict[genres] = sorted(plays, key=lambda x: x[0], reverse=True)

    # 3. 각 장르 총합 계산
    totals = {i: sum(j[0] for j in songs) for i, songs in dict.items()}

    # 4. 총합 기준으로 딕셔너리 순서 변경
    sorted_data = {k: v for k, v in sorted(dict.items(), key=lambda item: totals[item[0]], reverse=True)}


    # 5. 정답 인덱스 추가 부분
    for i in sorted_data.values():
        answer.append(i[0][1])
        if len(i) != 1:
            answer.append(i[1][1])
        
    return answer

📚 새롭게 알게된 내용

lambda함수에 관해서 한번 정리를 해야할 것 같습니다.. 해시를 어느정도 풀 수 있다고 생각했는데 소마 코테에서 쉽게 나왔는데 lambda를 잘 못쓰니까 막히는 부분이 있기도 하더라구요

그리고 코테 등 문제를 풀때 어떤 식으로 풀지 우선 하나씩 적어두고 푸는 습관을 가지려고 합니다 오늘 코드와 같이!
그렇게 안하니까 중간에 막히는 부분에서 어디서 막혔는지 몰라서 생각을 다시 다하는 참사가 발생했었습니다..

[SeongHoonC]

저는 합계랑 수록곡 관리를 따로 해주었는데 하나로 해서 2개씩 가져오는 방법도 있겠군요.. 흠
덕분이 sortWith 을 더 공부할 수 있었습니다.

fun solution(genres: Array<String>, plays: IntArray): IntArray {
        val genresSum = linkedMapOf<String, Int>()
        val genreMusics = linkedMapOf<String, MutableList<Pair<Int, Int>>>()
        val answer = mutableListOf<Int>()
        
        for (i in genres.indices) {
            val genreName = genres[i]
            // 처음 넣는거면 초기화
            if (genreMusics[genreName] == null) {
                genreMusics[genreName] = mutableListOf()
                genresSum[genreName] = 0
            }
            // 합계 올리기 + 음악 추가하기
            genresSum[genres[i]] = genresSum[genres[i]]!! + plays[i]
            genreMusics[genres[i]]!!.addMusic(i to plays[i])
        }
        // 합계로 정렬
        val sortedGenres = genresSum.toList().sortedByDescending { it.second }.toMap()

        // 정렬된 장르 순서로 index 값 가져와서 더하기
        sortedGenres.keys.forEach {
            answer += genreMusics[it]!!.map { music -> music.first }
        }
        return answer.toIntArray()
    }

    // 음악 추가할 때
    // play 순 내림차순 정렬, index 순 오름차순 정렬
    // 3 이상이면 뒤에 자르기
    private fun MutableList<Pair<Int, Int>>.addMusic(music: Pair<Int, Int>) {
        add(music)
        sortWith(compareBy({ -it.second }, { it.first }))
        if (size >= 3) {
            removeLast()
        }
    }

[fnzksxl]

문제 설명 옆의 이모티콘이 메이플 주문서 같아서 좀 흠칫했습니다.

# 1. 딕셔너리 만들기
for i in range(len(genres)):
    if genres[i] not in dict :
        dict[genres[i]] = [[plays[i], i]]
    else :
        dict[genres[i]].append([plays[i],i])

저는 딕셔너리에 추가하는 이 부분을 set 자료형으로 장르를 하나씩만 남기게 해서 구현했습니다.
풀이 잘 봤어요!

def solution(genres, plays):
    answer = []
    dict_for_album = dict()
    
    # 장르를 set 자료형으로 하나씩만 남겨놓기
    set_genres = set(genres)
    
    # 딕셔너리[장르]로 초기화
    for genre in set_genres:
        dict_for_album[genre] = [0,[]]
    
    # 장르, 노래 별 재생 수 기록
    for i in range(len(genres)):
        dict_for_album[genres[i]][0] += plays[i]
        dict_for_album[genres[i]][1].append((plays[i], i))
    
    # 장르 별 재생 수, 장르 내 노래 별 재생 수로 정렬
    # 장르 별로 두 개씩 정답에 추가(하나의 노래더라도 슬라이싱으로 처리해서 잘 됨)
    for _ , lists in sorted(dict_for_album.items(), key=lambda x : -x[1][0]):
        for index in sorted(lists[1], key=lambda x : -x[0])[:2]:
            answer.append(index[1])
    
    return answer

[9kyo-hwang]

저의 경우 장르를 set에 집어넣어서 종류 별로 하나씩만 필터링한 후, 그거를 키 값으로 하는 딕셔너리 생성했습니다.

playlist_by_genre = {genre : [] for genre in set(genres)}
for i, (genre, play) in enumerate(zip(genres, plays)):
    playlist_by_genre[genre].append((play, i))

다른 분 코드 보니까 극도로 압축시킨 코드가 있길래 저도 들고왔습니다 ㅋㅋ

sorted_genre = sorted(playlist_by_genre.keys(), key=lambda x: sum(map(lambda y: y[0], playlist_by_genre[x])), reverse=True)

장르 목록(x)을 정렬하는데, 각 장르 목록 별 곡 정보(재생 시간, 인덱스) 리스트(playlist_by_genre[x])에서 play 시간의 합 기준으로 내림차순 정렬합니다.

for genre in sorted_genre:
    temp = [index for play, index in sorted(playlist_by_genre[genre], key=lambda x: (-x[0], x[1]))]
    answer += temp[:2]

마지막으로 위에서 정렬한 장르 순서대로, 장르 별 곡 정보(재생시간, 인덱스)를 순회해서 1. 재생시간 많고(-x[0]) 2. 낮은 고유번호 우선으로(x[1]) 앞 2개만 추출해서 answer에 추가합니다.

전체 코드

def solution(genres, plays):
    playlist_by_genre = {genre : [] for genre in set(genres)}
    for i, (genre, play) in enumerate(zip(genres, plays)):
        playlist_by_genre[genre].append((play, i))
                                      
    sorted_genre = sorted(playlist_by_genre.keys(), key=lambda x: sum(map(lambda y: y[0], playlist_by_genre[x])), reverse=True)
    
    answer = []
    for genre in sorted_genre:
        temp = [index for play, index in sorted(playlist_by_genre[genre], key=lambda x: (-x[0], x[1]))]
        answer += temp[:2]
    return answer

[wkdghdwns199]

def solution(genres, plays):
    answer = []
    classified_plays = {genre : [] for genre in genres}
    genre_play_count = { genre : 0 for genre in genres}

    plays = list(enumerate(plays))
    for idx in range(len(genres)):
        genre_play_count[genres[idx]] = genre_play_count[genres[idx]] + plays[idx][1]
        classified_plays[genres[idx]].append(plays[idx])

    for classified_genre in classified_plays.keys() :
        classified_plays[classified_genre].sort(key=lambda x : -x[1])
    
    sorted_genre_play_count = sorted(genre_play_count, key=lambda x : -genre_play_count[x])
    
    limit = 2
    for sorted_genre in sorted_genre_play_count :
        answer.extend([idNum[0] for idNum in classified_plays[sorted_genre][:limit]])
    return answer

아직 python 의 함수들을 보고 풀기는 하지만 그래도 풀이법은 혼자서 생각해 냈어요! 아싸 🥳