๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
โŒจ๏ธ Language/swift

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค LV.1] ๊ณผ์ผ ์žฅ์ˆ˜

by hyebin (Helia) 2023. 3. 13.
๋ฐ˜์‘ํ˜•
ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค 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์ด ์ €์žฅ๋œ๋‹ค.)

 

๋ฐ˜์‘ํ˜•