๋ฐ์ํ
ํ๋ก๊ทธ๋๋จธ์ค LV.1 ๋ชจ์
๋ถ์กฑํ ๊ธ์ก ๊ณ์ฐํ๊ธฐ
๋ฌธ์ ์ค๋ช
์๋ก ์๊ธด ๋์ด๊ธฐ๊ตฌ๋ ์ธ๊ธฐ๊ฐ ๋งค์ฐ ๋ง์ ์ค์ด ๋์ด์ง ์์ต๋๋ค. ์ด ๋์ด๊ธฐ๊ตฌ์ ์๋ ์ด์ฉ๋ฃ๋ price์์ธ๋ฐ, ๋์ด๊ธฐ๊ตฌ๋ฅผ N ๋ฒ ์งธ ์ด์ฉํ๋ค๋ฉด ์๋ ์ด์ฉ๋ฃ์ N๋ฐฐ๋ฅผ ๋ฐ๊ธฐ๋ก ํ์์ต๋๋ค. ์ฆ, ์ฒ์ ์ด์ฉ๋ฃ๊ฐ 100์ด์๋ค๋ฉด 2๋ฒ์งธ์๋ 200, 3๋ฒ์งธ์๋ 300์ผ๋ก ์๊ธ์ด ์ธ์๋ฉ๋๋ค.
๋์ด๊ธฐ๊ตฌ๋ฅผ count๋ฒ ํ๊ฒ ๋๋ฉด ํ์ฌ ์์ ์ด ๊ฐ์ง๊ณ ์๋ ๊ธ์ก์์ ์ผ๋ง๊ฐ ๋ชจ์๋ผ๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์. ๋จ, ๊ธ์ก์ด ๋ถ์กฑํ์ง ์์ผ๋ฉด 0์ return ํ์ธ์.
์ ํ ์ฌํญ
- ๋์ด๊ธฐ๊ตฌ์ ์ด์ฉ๋ฃ price : 1 ≤ price ≤ 2,500, price๋ ์์ฐ์
- ์ฒ์ ๊ฐ์ง๊ณ ์๋ ๊ธ์ก money : 1 ≤ money ≤ 1,000,000,000, money๋ ์์ฐ์
- ๋์ด๊ธฐ๊ตฌ์ ์ด์ฉ ํ์ count : 1 ≤ count ≤ 2,500, count๋ ์์ฐ์
์ ์ถ๋ ฅ ์
price | money | count | result |
3 | 20 | 4 | 10 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ์ด์ฉ๊ธ์ก์ด 3์ธ ๋์ด๊ธฐ๊ตฌ๋ฅผ 4๋ฒ ํ๊ณ ์ถ์ ๊ณ ๊ฐ์ด ํ์ฌ ๊ฐ์ง ๊ธ์ก์ด 20์ด๋ผ๋ฉด, ์ด ํ์ํ ๋์ด๊ธฐ๊ตฌ์ ์ด์ฉ ๊ธ์ก์ 30 (= 3+6+9+12) ์ด ๋์ด 10๋งํผ ๋ถ์กฑํ๋ฏ๋ก 10์ return ํฉ๋๋ค.
์ ์ถ
import Foundation
func solution(_ price:Int, _ money:Int, _ count:Int) -> Int64{
var answer:Int64 = 0
for i in 1...count{
answer += Int64(i*price)
}
return (answer > money) ? answer-Int64(money) : 0
}
1๋ถํฐ count๊น์ง i๋ฅผ 1์ฉ ์ฆ๊ฐ์ํค๋ฉฐ, answer ๋ณ์์ i*price ์ฐ์ฐ์ ๋ํ๋ค.
answer ๊ฐ์ด money๋ณด๋ค ํฌ๋ค๋ฉด answer์ money๋ฅผ ๋บ ๊ฐ์ ๋ฐํํ๊ณ , ์๋๋ผ๋ฉด 0์ ๋ฐํํ๋ค.
๋ค๋ฅธ ํ์ด
import Foundation
func solution(_ price:Int, _ money:Int, _ count:Int) -> Int{
return max(price * ((count + 1) * count / 2) - money , 0)
}
์ด๊ธ์ก์ ๊ณ์ฐํ๋ ์์ (1*price) + (2*price) + ... +(n*price) ์ด๋ฏ๋ก price*(1+2+...+n)์ด๋ค.
๋ฑ์ฐจ์์ด ํฉ ๊ณต์์ ๋ฐ๋ผ ์ด๊ธ์ก์ price*((count+1)*count/2)๊ฐ ๋๋ค.
์ด๊ธ์ก์์ money๋ฅผ ๋บ ๊ฒฐ๊ณผ์ 0์ค์ ํฐ ๊ฐ์ ๋ฐํํ๋ค.
๋ฐ์ํ
'โจ๏ธ Language > swift' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์ต์์ง์ฌ๊ฐํ (1) | 2023.03.06 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์๋ ์ซ์ ๋ํ๊ธฐ (0) | 2023.03.06 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์ซ์ ๋ฌธ์์ด๊ณผ ์๋จ์ด (0) | 2023.03.05 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ์ฝ์์ ๊ฐ์์ ๋ง์ (0) | 2023.03.05 |
[ํ๋ก๊ทธ๋๋จธ์ค LV.1] ๋ก๋์ ์ต๊ณ ์์์ ์ต์ ์์ (0) | 2023.03.04 |