ํ๋ก๊ทธ๋๋จธ์ค ๋ฒ ์คํธ ์จ๋ฒ Swift
Source Code
import Foundation | |
func solution(_ genres:[String], _ plays:[Int]) -> [Int] { | |
//์ฅ๋ฅด์ ์ฅ๋ฅด์ ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง ๋์ ๋๋ฆฌ | |
var genresAndPlays = [String:[Int]]() | |
//์ฅ๋ฅด์ ์ฅ๋ฅด ํ๋ ์ด ํ ํ์ ์๋ฅผ ๊ฐ์ง ๋์ ๋๋ฆฌ๋ค์ ๊ฐ์ง๊ณ ์๋ ๋ฐฐ์ด | |
var total = [[String:Int]]() | |
//์ ๋ต ๋ฐฐ์ด | |
var answer = [Int]() | |
//play์์ ํ์ํด์ค๋๋ค. | |
for (current,play) in plays.enumerated() { | |
//์ฅ๋ฅด์์ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ key๋ก ํฉ๋๋ค. | |
let key = genres[current] | |
//๋ง์ฝ genresAndPlays๊ฐ nil์ด๋ผ๋ฉด | |
if genresAndPlays[key] == nil { | |
//ํ์ฌ genresAndPlays์ ์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํด์ค๋๋ค. | |
genresAndPlays[key] = [current] | |
//total์๋ ์๋ก์ด key์ play์๊ฐ์ ๊ฐ์ง๋ ๋์ ๋๋ฆฌ๋ฅผ ๋ฃ์ด์ค๋๋ค. | |
total.append([key:play]) | |
continue | |
} | |
//genresAndPlays๋ฅผ ํ์ํด์ค๋๋ค. | |
for (j,index) in genresAndPlays[key]!.enumerated() { | |
//๋ง์ฝ ํ์ฌ ์ธ๋ฑ์ค์ play๊ฐ genresAndPlays[key]์์ ์๋ play๋ณด๋ค ํฌ๋ค๋ฉด | |
if plays[index] < plays[current] { | |
//๊ทธ ์๋ฆฌ์ ์ฝ์ ํด์ค๋๋ค. | |
genresAndPlays[key]?.insert(current, at: j) | |
//๋ง์ฝ genresAndPlays[key]์ ์๊ฐ 2๋ณด๋ค ํฌ๋ค๋ฉด | |
if genresAndPlays[key]!.count > 2 { | |
//๊ฐ์ฅ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ์ญ์ ํด์ค๋๋ค. | |
genresAndPlays[key]?.removeLast() | |
} | |
break | |
//๋ง์ฝ ํ์ฌ ์ธ๋ฑ์ค์ play๊ฐ genresAndPlays[key]์์ ์๋ play๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค๋ฉด | |
}else{ | |
//๋ง์ฝ genresAndPlays[key]๊ฐ 2๋ณด๋ค ์๋ค๋ฉด | |
if genresAndPlays[key]!.count < 2 { | |
//๊ฐ์ฅ ๋ค์ ๋ฃ์ด์ค๋๋ค. | |
genresAndPlays[key]?.append(current) | |
} | |
} | |
} | |
//total์ ๋์ ๋๋ฆฌ ์ค ํ์ฌ key๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋์ ๋๋ฆฌ๊ฐ ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฐพ์์ค๋๋ค. | |
let tIndex = total.firstIndex { (dictionary) -> Bool in | |
dictionary.first?.key == key | |
} | |
//์ฐพ์ ์ธ๋ฑ์ค์์ key๊ฐ ์๋ ๊ณณ์ play๋ฅผ ๋ํด์ค๋๋ค. | |
total[tIndex!][key]! += play | |
} | |
//total์ ๋์ ๋๋ฆฌ๋ฅผ ํ๋์ฉ ๊ฐ์ง๊ณ ์๋ ๋ฐฐ์ด์ด๋ฏ๋ก ๊ฐ ๋์ ๋๋ฆฌ์ ๋ฐธ๋ฅ๊ฐ์ ๊ธฐ์ค์ผ๋ก ํฐ ๊ฐ์ผ๋ก ์ ๋ ฌํด์ค๋๋ค. | |
let song = total.sorted {$0.first!.value > $1.first!.value} | |
//ํ ํ์๋๋ก ๋ฐ๋ณตํด์ค๋๋ค. | |
for i in 0...total.count-1 { | |
//answer์ genresAndPlays์ song์ ์ฒซ๋ฒ์งธ key๊ฐ ๊ฐ์ง๊ณ ์๋ ์ธ๋ฑ์ค๋ค์ ๋ฃ์ด์ค๋๋ค. | |
answer.append(contentsOf: genresAndPlays[song[i].first!.key]!) | |
} | |
//์ธ๋ฑ์ค๋ฅผ ๋ฐํํด์ค๋๋ค. | |
return answer | |
} |
Solution
ํด๋น ๋ฌธ์ ๋ ํด์ฌ๋ฌธ์ ์๋ค.(Swift๋ก ๋ฐ์ง๋ฉด Dictionary๋ฅผ ์ฌ์ฉํด ํ์ด์ผํ๋ ๋ฌธ์ )
1. ๊ฐ ์ฅ๋ฅด๋ฅผ ํค๊ฐ์ผ๋ก ์ฅ๋ฅด๊ฐ ์๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐธ๋ฅ๊ฐ์ผ๋ก ๋์ ๋๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ๋ด์์ค๋ค.
2. 1์์ ๋ด์ ์ธ๋ฑ์ค๋ค์ ํ๋ ์ด ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ฐ์ฅ ํฐ 2๊ฐ์ ์ธ๋ฑ์ค๋ง ๋ด์์ค๋ค.
3. ๊ฐ ์ฅ๋ฅด๋ฅผ ํค๊ฐ์ผ๋ก ํ๊ณ ๊ฐ ์ฅ๋ฅด์ ์ธ๋ฑ์ค๊ฐ ์๋ ํ๋ ์ด ๊ฐ์ ์ดํฉ์ ๋ฐธ๋ฅ๊ฐ์ผ๋ก ๊ฐ๋ ๋์ ๋๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ๋ด์์ค๋ค.
4. ์ดํฉ์ด ๊ฐ์ฅ ๋์ ์์ผ๋ก ๋์ ๋๋ฆฌ๋ฅผ ์ ๋ ฌํด์ค๋ค ์ธ๋ฑ์ค๋ฅผ ๋ด๊ณ ์๋ ๋ฐธ๋ฅ๊ฐ๋ค์ ๊ฐ ์ฅ๋ฅด๋ณ๋ก ๋ชจ์์ค ๋ค์ ๋ฐํํด์ค๋ค.
Problem
์ฝ๋ฉํ ์คํธ ์ฐ์ต - ๋ฒ ์คํธ์จ๋ฒ
์คํธ๋ฆฌ๋ฐ ์ฌ์ดํธ์์ ์ฅ๋ฅด ๋ณ๋ก ๊ฐ์ฅ ๋ง์ด ์ฌ์๋ ๋ ธ๋๋ฅผ ๋ ๊ฐ์ฉ ๋ชจ์ ๋ฒ ์คํธ ์จ๋ฒ์ ์ถ์ํ๋ ค ํฉ๋๋ค. ๋ ธ๋๋ ๊ณ ์ ๋ฒํธ๋ก ๊ตฌ๋ถํ๋ฉฐ, ๋ ธ๋๋ฅผ ์๋กํ๋ ๊ธฐ์ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค. ์ํ ๋ ธ๋๊ฐ
programmers.co.kr
์๋กญ๊ฒ ์๊ฒ ๋ ๊ฒ
๋์ ๋๋ฆฌ๋ฅผ ๋ด์๋ฐฐ์ด์ ์ธ๋ฑ์ค๊ฐ ์๊ณ ์์๋ ๋๋ค์ผ๋ก ๋ฐฐ์น๋๋ค.
๊ณ ๋ก ๋ฐฐ์ด์ ๋์ ๋๋ฆฌ๋ฅผ ๋ด์์ ์ ๋ ฌ์ ํด์ฃผ์ด์ผ ๋๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
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
|
import Foundation
class Album {
var index : Int
var playTime : Int
init(_ index : Int, _ playTime : Int) {
self.index = index
self.playTime = playTime
}
}
func solution(_ genres:[String], _ plays:[Int]) -> [Int] {
var albumDic = [String : [Album]]()
plays
.enumerated()
.map { (genres[$0], Album($0, $1)) }
.forEach { albumDic[$0, default: [Album]() ].append($1) }
return albumDic
.sorted {
$0.value.reduce(0, { $0 + $1.playTime }) > $1.value.reduce(0, { $0 + $1.playTime })
}
.map { _, albums -> [Int] in
guard albums.count > 1 else { return [albums[0].index] }
let sorted = albums.sorted(by: { $0.playTime > $1.playTime} )
return [sorted[0].index, sorted[1].index]}
.reduce(into: [Int]()) { $0.append(contentsOf : $1) }
}
|
ํ ์คํธ ์ผ์ด์ค ํจ์จ์ฑ ๋น๊ต
์ข์ธก ๋ด ์ฝ๋ ์ฐ์ธก ๋ค๋ฅธ ์ฌ๋ ์ฝ๋


๊ทธ๋๋ ์ด๋ฒ์๋ ๋น์ท๋น์ทํ๊ฒ ๋์๋ค.