ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ชจ์
๊ณผ์ผ ์ฅ์
๋ฌธ์ ์ค๋ช
๊ณผ์ผ ์ฅ์๊ฐ ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ๊ณ ์์ต๋๋ค. ์ฌ๊ณผ๋ ์ํ์ ๋ฐ๋ผ 1์ ๋ถํฐ k์ ๊น์ง์ ์ ์๋ก ๋ถ๋ฅํ๋ฉฐ, k์ ์ด ์ต์ํ์ ์ฌ๊ณผ์ด๊ณ 1์ ์ด ์ตํํ์ ์ฌ๊ณผ์ ๋๋ค. ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ ๋ค์๊ณผ ๊ฐ์ด ๊ฒฐ์ ๋ฉ๋๋ค.
- ํ ์์์ ์ฌ๊ณผ๋ฅผ m ๊ฐ์ฉ ๋ด์ ํฌ์ฅํฉ๋๋ค.
- ์์์ ๋ด๊ธด ์ฌ๊ณผ ์ค ๊ฐ์ฅ ๋ฎ์ ์ ์๊ฐ p (1 ≤ p ≤ k)์ ์ธ ๊ฒฝ์ฐ, ์ฌ๊ณผ ํ ์์์ ๊ฐ๊ฒฉ์ p * m์ ๋๋ค.
๊ณผ์ผ ์ฅ์๊ฐ ๊ฐ๋ฅํ ๋ง์ ์ฌ๊ณผ๋ฅผ ํ์์ ๋, ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ ๊ณ์ฐํ๊ณ ์ ํฉ๋๋ค.(์ฌ๊ณผ๋ ์์ ๋จ์๋ก๋ง ํ๋งคํ๋ฉฐ, ๋จ๋ ์ฌ๊ณผ๋ ๋ฒ๋ฆฝ๋๋ค)
์๋ฅผ ๋ค์ด, k = 3, m = 4, ์ฌ๊ณผ 7๊ฐ์ ์ ์๊ฐ [1, 2, 3, 1, 2, 3, 1]์ด๋ผ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด [2, 3, 2, 3]์ผ๋ก ๊ตฌ์ฑ๋ ์ฌ๊ณผ ์์ 1๊ฐ๋ฅผ ๋ง๋ค์ด ํ๋งคํ์ฌ ์ต๋ ์ด์ต์ ์ป์ ์ ์์ต๋๋ค.
- (์ต์ ์ฌ๊ณผ ์ ์) x (ํ ์์์ ๋ด๊ธด ์ฌ๊ณผ ๊ฐ์) x (์์์ ๊ฐ์) = 2 x 4 x 1 = 8
์ฌ๊ณผ์ ์ต๋ ์ ์ k, ํ ์์์ ๋ค์ด๊ฐ๋ ์ฌ๊ณผ์ ์ m, ์ฌ๊ณผ๋ค์ ์ ์ score๊ฐ ์ฃผ์ด์ก์ ๋, ๊ณผ์ผ ์ฅ์๊ฐ ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ ์ฌํญ
- 3 ≤ k ≤ 9
- 3 ≤ m ≤ 10
- 7 ≤ score์ ๊ธธ์ด ≤ 1,000,000
- 1 ≤ score [i] ≤ k
- ์ด์ต์ด ๋ฐ์ํ์ง ์๋ ๊ฒฝ์ฐ์๋ 0์ return ํด์ฃผ์ธ์.
์ ์ถ๋ ฅ ์
k | m | score | result |
3 | 4 | [1, 2, 3, 1, 2, 3, 1] | 8 |
4 | 3 | [4, 1, 2, 2, 4, 4, 4, 4, 1, 2, 4, 2] | 33 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ฌธ์ ์ ์์์ ๊ฐ์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ค์๊ณผ ๊ฐ์ด ์ฌ๊ณผ ์์๋ฅผ ํฌ์ฅํ์ฌ ๋ชจ๋ ํ๋ฉด ์ต๋ ์ด์ต์ ๋ผ ์ ์์ต๋๋ค.
์ฌ๊ณผ ์์ | ๊ฐ๊ฒฉ |
[1, 1, 2] | 1 x 3 = 3 |
[2, 2, 2] | 2 x 3 = 6 |
[4, 4, 4] | 4 x 3 = 12 |
[4, 4, 4] | 4 x 3 = 12 |
- ๋ฐ๋ผ์ (1 x 3 x 1) + (2 x 3 x 1) + (4 x 3 x 2) = 33์ return ํฉ๋๋ค.
์ ์ถ
import Foundation
func solution(_ k:Int, _ m:Int, _ score:[Int]) -> Int {
var result = 0
let mod = score.count % m
let score = score.sorted(by: >)[0..<score.count - mod]
for i in stride(from: 0, to: score.count, by: m) {
result += Array(score[i..<i+m]).min()! * m
}
return result
}
mod ์์๋ฅผ ์ ์ธํ์ฌ score ๋ณ์์ ํฌ๊ธฐ์์ m์ ๋๋ ๋๋จธ์ง ๊ฐ์ ์ ์ฅํ๋ค.
score๋ฐฐ์ด์ ์ ๋ ฌํ ๋ค 0๋ถํฐ (score ๋ฐฐ์ด์ ํฌ๊ธฐ - mod)๊น์ง score ์์์ ์ ์ฅํ๋ค. (score๋ m์ ๋ฐฐ์์ ํฌ๊ธฐ๋ฅผ ๊ฐ๋๋ค)
i๋ฅผ 0๋ถํฐ score์ ํฌ๊ธฐ๊น์ง m ๋งํผ์ฉ ์ฆ๊ฐ์ํค๋ฉฐ ๋ฐ๋ณตํ๋ค.
score ๋ฐฐ์ด์์ i๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ i+m๊น์ง ์ธ๋ฑ์ค๊น์ง์ ์์๋ค ์ค์์ ์์ ๊ฐ์ ๊ณจ๋ผ m์ ๊ณฑํ ํ result ๋ณ์์ ๋ํ๋ค.
๋ค๋ฅธ ํ์ด
import Foundation
func solution(_ k:Int, _ m:Int, _ score:[Int]) -> Int {
var answer = 0
var score = score.sorted(by: >)
var start = m-1
while start < score.count {
answer += m*score[start]
start += m
}
return answer
}
score๋ฐฐ์ด์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
start ๋ณ์์๋ m-1์ ์ ์ฅํ๋ค.
start๊ฐ score๋ฐฐ์ด์ ํฌ๊ธฐ๋งํผ ์์ ๊ฒฝ์ฐ์๋ง ๋ฐ๋ณต๋ฌธ์ด ์คํ๋๋ค.
answer ๋ณ์์ m*score [start] ๊ฐ์ ๋ํ ํ start๋ณ์์ m์ ๋ํ๋ค.
(ex - m์ด 3์ด๊ณ score๊ฐ [4, 1, 2, 2, 4, 4, 4, 4, 1, 2, 4, 2] ์ผ ๋
score๋ฅผ ์ ๋ ฌํ๋ฉด [4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 1, 1]์ด๊ณ , start ๋ณ์์ ๊ฐ์ 2์ด๋ค.
answer ๋ณ์์๋ 3*score [2]=12, 3*score [5]=12, 3*score [8]=6, 3*score [11]=3์ด ๋ํด์ง๋ฉฐ, ๊ฒฐ๋ก ์ ์ผ๋ก 33์ด ์ ์ฅ๋๋ค.)
'โจ๏ธ Language > swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift] ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ช ์์ ์ ๋น (1) (0) | 2023.03.15 |
---|---|
[Swift] ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ (0) | 2023.03.15 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ํธ๋ ํ์ดํธ ๋ํ (0) | 2023.03.12 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ํ๋ฒ๊ฑฐ ๋ง๋ค๊ธฐ (1) | 2023.03.12 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์น์์ด(2) (0) | 2023.03.10 |