ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ชจ์
๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ
๋ฌธ์ ์ค๋ช
์ซ์๋๋ผ ๊ธฐ์ฌ๋จ์ ๊ฐ ๊ธฐ์ฌ์๊ฒ๋ 1๋ฒ๋ถํฐ number๊น์ง ๋ฒํธ๊ฐ ์ง์ ๋์ด ์์ต๋๋ค. ๊ธฐ์ฌ๋ค์ ๋ฌด๊ธฐ์ ์์ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํ๋ ค๊ณ ํฉ๋๋ค.
๊ฐ ๊ธฐ์ฌ๋ ์์ ์ ๊ธฐ์ฌ ๋ฒํธ์ ์ฝ์ ๊ฐ์์ ํด๋นํ๋ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํ๋ ค ํฉ๋๋ค. ๋จ, ์ด์๋๋ผ์์ ํ์ฝ์ ์ํด ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๋ฅผ ์ ํ๊ณ , ์ ํ์์น๋ณด๋ค ํฐ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํด์ผ ํ๋ ๊ธฐ์ฌ๋ ํ์ฝ๊ธฐ๊ด์์ ์ ํ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง๋ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, 15๋ฒ์ผ๋ก ์ง์ ๋ ๊ธฐ์ฌ๋จ์์ 15์ ์ฝ์๊ฐ 1, 3, 5, 15๋ก 4๊ฐ ์ด๋ฏ๋ก, ๊ณต๊ฒฉ๋ ฅ์ด 4์ธ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํฉ๋๋ค. ๋ง์ฝ, ์ด์๋๋ผ์์ ํ์ฝ์ผ๋ก ์ ํด์ง ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๊ฐ 3์ด๊ณ ์ ํ์์น๋ฅผ ์ด๊ณผํ ๊ธฐ์ฌ๊ฐ ์ฌ์ฉํ ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ์ด 2๋ผ๋ฉด, 15๋ฒ์ผ๋ก ์ง์ ๋ ๊ธฐ์ฌ๋จ์์ ๋ฌด๊ธฐ์ ์์ ๊ณต๊ฒฉ๋ ฅ์ด 2์ธ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํฉ๋๋ค. ๋ฌด๊ธฐ๋ฅผ ๋ง๋ค ๋, ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ 1๋น 1kg์ ์ฒ ์ด ํ์ํฉ๋๋ค. ๊ทธ๋์ ๋ฌด๊ธฐ์ ์์ ๋ฌด๊ธฐ๋ฅผ ๋ชจ๋ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ฒ ์ ๋ฌด๊ฒ๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๋ ค ํฉ๋๋ค.
๊ธฐ์ฌ๋จ์์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ number์ ์ด์๋๋ผ์ ํ์ฝ์ผ๋ก ์ ํด์ง ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๋ฅผ ๋ํ๋ด๋ ์ ์ limit์ ์ ํ์์น๋ฅผ ์ด๊ณผํ ๊ธฐ์ฌ๊ฐ ์ฌ์ฉํ ๋ฌด๊ธฐ์ ๊ณต๊ฒฉ๋ ฅ์ ๋ํ๋ด๋ ์ ์ power๊ฐ ์ฃผ์ด์ก์ ๋, ๋ฌด๊ธฐ์ ์ ์ฃผ์ธ์ด ๋ฌด๊ธฐ๋ฅผ ๋ชจ๋ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ฒ ์ ๋ฌด๊ฒ๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํ์์ค.
์ ํ ์ฌํญ
- 1 ≤ number ≤ 100,000
- 2 ≤ limit ≤ 100
- 1 ≤ power ≤ limit
์ ์ถ๋ ฅ ์
number | limit | power | result |
5 | 3 | 2 | 10 |
10 | 3 | 2 | 21 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- 1๋ถํฐ 5๊น์ง์ ์ฝ์์ ๊ฐ์๋ ์์๋๋ก [1, 2, 2, 3, 2] ๊ฐ์ ๋๋ค. ๋ชจ๋ ๊ณต๊ฒฉ๋ ฅ ์ ํ ์์น์ธ 3์ ๋์ง ์๊ธฐ ๋๋ฌธ์ ํ์ํ ์ฒ ์ ๋ฌด๊ฒ๋ ํด๋น ์๋ค์ ํฉ์ธ 10์ด ๋ฉ๋๋ค. ๋ฐ๋ผ์ 10์ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- 1๋ถํฐ 10๊น์ง์ ์ฝ์์ ๊ฐ์๋ ์์๋๋ก [1, 2, 2, 3, 2, 4, 2, 4, 3, 4] ๊ฐ์ ๋๋ค. ๊ณต๊ฒฉ๋ ฅ์ ์ ํ์์น๊ฐ 3์ด๊ธฐ ๋๋ฌธ์, 6, 8, 10๋ฒ ๊ธฐ์ฌ๋ ๊ณต๊ฒฉ๋ ฅ์ด 2์ธ ๋ฌด๊ธฐ๋ฅผ ๊ตฌ๋งคํฉ๋๋ค. ๋ฐ๋ผ์ ํด๋น ์๋ค์ ํฉ์ธ 21์ return ํฉ๋๋ค.
์ ์ถ
import Foundation
func solution(_ number:Int, _ limit:Int, _ power:Int) -> Int {
var result = 0
for n in 1...number{
var i = 1, cnt = 0
while i*i <= n{
if n%i == 0{
cnt += n/i == i ? 1 : 2
}
i += 1
}
result += cnt <= limit ? cnt : power
}
return result
}
1๋ถํฐ number๊น์ง ์ฝ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด n์ 1์ฉ ์ฆ๊ฐ์ํจ๋ค.
i๋ฅผ 1๋ก ์ด๊ธฐํํ์ฌ ์ ์ธํ ํ i๋ฅผ √n๊น์ง 1์ฉ ์ฆ๊ฐ์ํค๋ฉฐ whie๋ฌธ์ ๋ฐ๋ณตํ๋ค. (i*i <= n)
n%i๊ฐ 0์ธ๊ฒฝ์ฐ i๋ n์ ์ฝ์์ด๋ค.
cnt ๋ณ์์ n/i ๊ฐ i๋ผ๋ฉด 1์ ์๋๋ผ๋ฉด 2๋ฅผ ๋ํ๋ค.
(ex - n์ด 25์ผ ๋ i๊ฐ 1์ด๋ผ๋ฉด 1, 25 2๊ฐ์ ์ฝ์๊ฐ ์์ ์ด๋ฃจ๊ธฐ ๋๋ฌธ์ 2๋ฅผ ์ฆ๊ฐํ๋ค.
i๊ฐ 5๋ผ๋ฉด, 5 ํ ๊ฐ๋ง ์ฝ์์ด๊ธฐ ๋๋ฌธ์ 1์ ์ฆ๊ฐ์ํจ๋ค. (25/5 = 5))
result ๋ณ์์ ์ฝ์์ ๊ฐ์๋ฅผ ๋ด์ cnt ๋ณ์๊ฐ limit ๋ณด๋ค ๊ฐ๊ฑฐ๋ ์๋ค๋ฉด cnt๋ฅผ ์๋๋ผ๋ฉด power๋ฅผ ๋ํ๋ค
๋ค๋ฅธ ํ์ด
import Foundation
func solution(_ number:Int, _ limit:Int, _ power:Int) -> Int {
var attack = [Int](repeating: 0, count: number+1)
for i in 1...number {
var c = i
while c <= number {
attack[c] += 1
c += i
}
}
attack = attack.map { $0 > limit ? power : $0 }
return attack.reduce(0, +)
}
์ฝ์์ ๊ฐ์๋ฅผ ๋ด๊ธฐ ์ํ Intํ ๋ฐฐ์ด attack์ ์ ์ธํ๋ค.
attack์ number+1์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ ๋ชจ๋ 0์ผ๋ก ์ด๊ธฐํํ๋ค.
1๋ถํฐ n๊น์ง์ ์ฝ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด i๋ฅผ 1์ฉ ์ฆ๊ฐ์ํจ๋ค.
๋ณ์ c๋ฅผ i๋ก ์ด๊ธฐํํ์ฌ ์ ์ธํ๋ค.
c๊ฐ number๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฝ์ฐ์๋ง while ๋ฌธ์ ์คํํ๋ค.
attack[c]๋ฅผ 1 ์ฆ๊ฐ์ํจ ํ c๋ฅผ i๋งํผ ์ฆ๊ฐ์ํจ๋ค.
(ex - n์ด 4์ธ ๊ฒฝ์ฐ i ๊ฐ 1์ผ ๋, attack์ ์ธ๋ฑ์ค๊ฐ 1,2,3,4์ธ ๊ฒฝ์ฐ์ 1์ฉ ๋ํด์ง๋ค. (1์ ๋ชจ๋ ์์ ์ฝ์์ด๊ธฐ ๋๋ฌธ์)
i๊ฐ 2์ธ ๊ฒฝ์ฐ์๋ attack์ ์ธ๋ฑ์ค๊ฐ 2,4์ธ ๊ฒฝ์ฐ์ 1์ฉ ๋ํด์ง๋ค. ์ด๋ ๊ฒ ํ๋ฉด i์ ๋ฐฐ์์๋ง 1์ฉ ๋ํด์ง๊ฒ ๋๋ค)
์ดํ attack ๋ฐฐ์ด์์ map ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์์๊ฐ์ด limit๋ณด๋ค ํฐ ๊ฒฝ์ฐ์๋ power๋ก ์๋๋ผ๋ฉด ์๊ธฐ ์์ ์ ๋ฐํํ๋ค.
reduceํจ์๋ฅผ ์ฌ์ฉํ์ฌ attack๋ฐฐ์ด์ ํฉ์ ๋ฐํํ๋ค.
'โจ๏ธ Language > swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift] ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ฌธ์์ด ๋๋๊ธฐ (0) | 2023.03.16 |
---|---|
[Swift] ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ช ์์ ์ ๋น (1) (0) | 2023.03.15 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ๊ณผ์ผ ์ฅ์ (0) | 2023.03.13 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ํธ๋ ํ์ดํธ ๋ํ (0) | 2023.03.12 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ํ๋ฒ๊ฑฐ ๋ง๋ค๊ธฐ (1) | 2023.03.12 |