๐ ์ฝ๋ฉํ ์คํธ ๋ฌธ์ ํ์ด
โ๐ป ๋ฌธ์ ํ์ด github ๋งํฌ
๋ฌธ์ ์ค๋ช
๊ฒฝํ๋ ๊ณผ์์์์ ๊ทค์ ์ํํ์ต๋๋ค. ๊ฒฝํ๋ ์ํํ ๊ทค ์ค 'k'๊ฐ๋ฅผ ๊ณจ๋ผ ์์ ํ๋์ ๋ด์ ํ๋งคํ๋ ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ ์ํํ ๊ทค์ ํฌ๊ธฐ๊ฐ ์ผ์ ํ์ง ์์ ๋ณด๊ธฐ์ ์ข์ง ์๋ค๊ณ ์๊ฐํ ๊ฒฝํ๋ ๊ทค์ ํฌ๊ธฐ๋ณ๋ก ๋ถ๋ฅํ์ ๋ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ์ ์๋ฅผ ์ต์ํํ๊ณ ์ถ์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ฒฝํ๊ฐ ์ํํ ๊ทค 8๊ฐ์ ํฌ๊ธฐ๊ฐ [1, 3, 2, 5, 4, 5, 2, 3] ์ด๋ผ๊ณ ํฉ์๋ค. ๊ฒฝํ๊ฐ ๊ทค 6๊ฐ๋ฅผ ํ๋งคํ๊ณ ์ถ๋ค๋ฉด, ํฌ๊ธฐ๊ฐ 1, 4์ธ ๊ทค์ ์ ์ธํ ์ฌ์ฏ ๊ฐ์ ๊ทค์ ์์์ ๋ด์ผ๋ฉด, ๊ทค์ ํฌ๊ธฐ์ ์ข ๋ฅ๊ฐ 2, 3, 5๋ก ์ด 3๊ฐ์ง๊ฐ ๋๋ฉฐ ์ด๋๊ฐ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ๊ฐ ์ต์์ผ ๋์ ๋๋ค.
๊ฒฝํ๊ฐ ํ ์์์ ๋ด์ผ๋ ค๋ ๊ทค์ ๊ฐ์ k์ ๊ทค์ ํฌ๊ธฐ๋ฅผ ๋ด์ ๋ฐฐ์ด tangerine์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๊ฒฝํ๊ฐ ๊ทค k๊ฐ๋ฅผ ๊ณ ๋ฅผ ๋ ํฌ๊ธฐ๊ฐ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ์ ์์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 1 ≤ k ≤ tangerine์ ๊ธธ์ด ≤ 100,000
- 1 ≤ tangerine์ ์์ ≤ 10,000,000
์ ์ถ๋ ฅ ์
k | tangerine | result |
6 | [1, 3, 2, 5, 4, 5, 2, 3] | 3 |
4 | [1, 3, 2, 5, 4, 5, 2, 3] | 2 |
2 | [1, 1, 1, 1, 2, 2, 2, 3] | 1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ณธ๋ฌธ์์ ์ค๋ช ํ ์์์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๊ฒฝํ๋ ํฌ๊ธฐ๊ฐ 2์ธ ๊ทค 2๊ฐ์ 3์ธ ๊ทค 2๊ฐ ๋๋ 2์ธ ๊ทค 2๊ฐ์ 5์ธ ๊ทค 2๊ฐ ๋๋ 3์ธ ๊ทค 2๊ฐ์ 5์ธ ๊ทค 2๊ฐ๋ก ๊ทค์ ํ๋งคํ ์ ์์ต๋๋ค. ์ด๋์ ํฌ๊ธฐ ์ข ๋ฅ๋ 2๊ฐ์ง๋ก ์ด ๊ฐ์ด ์ต์๊ฐ ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- ๊ฒฝํ๋ ํฌ๊ธฐ๊ฐ 1์ธ ๊ทค 2๊ฐ๋ฅผ ํ๋งคํ๊ฑฐ๋ 2์ธ ๊ทค 2๊ฐ๋ฅผ ํ๋งคํ ์ ์์ต๋๋ค. ์ด๋์ ํฌ๊ธฐ ์ข ๋ฅ๋ 1๊ฐ์ง๋ก, ์ด ๊ฐ์ด ์ต์๊ฐ ๋ฉ๋๋ค.
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ k:Int, _ tangerine:[Int]) -> Int {
var dic = [Int:Int]()
var k = k, count = 0
for i in tangerine {
dic[i] = ( dic[i] ?? 0 ) + 1
}
for i in dic.values.sorted(by: >){
k -= i
count += 1
if k <= 0 {
return count
}
}
return 0
}
tangerine ๊ธธ์ด์ ์ต๋๊ฐ์ด 100,000 ์ด์๊ธฐ ๋๋ฌธ์ ๋ฐ๋ณต๋ฌธ์ ํ ๋ฒ๋ง ๋์์ ํ ์ ์๋๋ก ํด์ผํ๋ค. ๊ฒฐ๊ตญ ํ ๋ฒ์ ๊ฐ ์ซ์๋ค์ ๊ฐ์๋ฅผ ์ฐพ์์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ฆฌ๋ฅผ ํด์ผํ๋๋ฐ, ์ด๋, ๋น๊ต๊ฐ ์๊ฐ์ด ๊ฐ์ฅ ์งง์ ๋์ ๋๋ฆฌ๋ก ํํ๋ค. ํ๋ฒ์ for๋ฌธ์ ๋๋ฉฐ ๋์ ๋๋ฆฌ์ ํด๋น ํฌ๊ธฐ๋ค์ ๊ฐ์๋ฅผ ์ป๊ณ , ํด๋น ํฌ๊ธฐ๋ค์ ๊ฐ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ํ์ฌ ๊ทธ ๊ฐ๋ค์ k์์ ํ๋์ฉ ๋นผ์ k๊ฐ 0๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ์ for๋ฌธ์ ๋น ์ ธ๋์ด๊ณผ ๋์์ ๋ต์ ์ถ๋ ฅํ๋๋ก ํ์๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
func solution(_ k: Int, _ tangerine: [Int]) -> Int {
return Dictionary(grouping: tangerine) { $0 }.values
.sorted { $0.count > $1.count }
.reduce((0, 0)) { acc, array in acc.1 >= k ? acc : (acc.0 + 1, acc.1 + array.count) }
.0
}
๋๋ ์ฒ์์ reduce๋ก ํ๋ ค๊ณ ํ๋๋ฐ, ์ค๊ฐ์ if๋ฌธ์ ๋น ์ ธ๋์ฌ ์ ์์ด์ ์ฐ์ง ๋ชปํ๋ค.
ํ์ง๋ง, ํด๋ก์ ์์ return์ ์ฃผ๋ ๊ฒ์ด ์๋ return ๊ฐ ๋ค์ reduce๋ผ๋ ๋ฌธ์ฅ์ ํ๋ฒ์ ์จ์ ๋์ ๋๋ฆฌ๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ํ๋์ฉ ๊ฐ์ ๋ํ ๋ ์ด ๊ฐ์ด k๋ณด๋ค ํฌ๋ค๋ฉด ์๋ฌด๊ฒ๋ ๋ํ์ง ์๊ณ , k๋ณด๋ค ์๋ค๋ฉด ๊ฐฏ์๋ฅผ ํ๋ ์ฌ๋ฆฌ๊ณ , ๊ฐ์ ๊ณ์ ๋ํ๋ ๊ฒ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ถ๊ธํ ๊ฑด acc.1์ด k๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ์ ๋ค์ acc ๋์ด์์ ๋ฐ๋ณต๋ฌธ์ ๋์ง ์๊ณ ๊ทธ๋๋ก ๋น ์ ธ๋์ค๋ ๊ฒ์ธ๊ฐ ์๋ ๋ฐ๋ณต๋ฌธ์ ๊ณ์ ๋์ง๋ง, ๊ณ์ฐ์ ์ํ๋ ๊ฒ์ธ๊ฐ?
reduce๋ ์ค๊ฐ์ ๋ฐฐ์ด ๊ฐ์ ๋น ์ ธ๋์ค์ง ์๊ธฐ ๋๋ฌธ์ 100,000๊ฐ์ ๋ฐฐ์ด์์ 2๋ฒ์งธ ์์์์ ํด๋น ์กฐ๊ฑด์ ๋ง์กฑํ๋ค๊ณ ํ๋๋ผ๋ ์๋ฌด ์ฐ์ฐ์ด ์ผ์ด๋์ง ์์ง๋ง ๋๋จธ์ง 99,998๊ฐ์ ๋ฐฐ์ด์ ๋ค ๋๋ค๊ณ ํ์๋ค. ๊ทธ๋ผ ๋ ๋นํจ์จ์ ์ธ๊ฒ ์๋๊ฐ!!!!
์ค์ํ ๊ฐ๋
Dictionary(grouping: ๊ทธ๋ฃนํํ ๋ฐฐ์ด, by: ๊ทธ๋ฃนํํ ๊ธฐ์ค)
let students = ["Kofi", "Abena", "Efua", "Kweku", "Akosua"]
let studentsByLetter = Dictionary(grouping: students, by: { $0.first! })
// ["E": ["Efua"], "K": ["Kofi", "Kweku"], "A": ["Abena", "Akosua"]]
Dictionary์์ ํด๋น ๊ฐ์ ๊ทธ๋ฃนํํ๋ฉด ๊ทธ๋ฃนํ๋ ๊ฐ๋ค์ด ๋ฐฐ์ด๋ก ๋์ ๋๋ฆฌ์ ์ ์ฅ์ด ๋๋ค!
์์ผ๋ก ์์ฃผ ์ธ ๋ฏ!ใ