์ค๋์ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ณธ์์ + ์ฌํํ์ต์ ์ํด ํ๋ก๊ทธ๋๋จธ์ค์ ์ฝ๋ฉํ ์คํธ ๋ฌธ์ ํ์ด๋ฅผ ์งํํ๋ค.
๋ฌด๋ฆฌ ์์ด ํ์ด๋๊ฐ๋ ์ค ์ฝ๋ ์คํ ์ ์๋ฌ ๋ฉ์์ง ์์ด ์ ์์ผ๋ก ์ถ๋ ฅ๋๋ ์ ๋ต์ผ๋ก ์ ์ถํ๋ ์คํจ๋ก ์ ์ถ๋ถ๊ฐ๋ผ๋ ๋ฉ์์ง๋ฅผ ๋ฐ์๋ค.
์ด๋๊ฐ ์ด๋ป๊ฒ ์๋ชป๋ ๊ฑด์ง ํ์ธํด ๋ณด์.
๋ฌธ์ ๋งํฌ: https://school.programmers.co.kr/learn/courses/30/lessons/82612#%EF%BB%BF
๊ธฐ๋ณธ์
์ฅ๋ฃ๋ price์ด๋ ๋์ด๊ธฐ๊ตฌ๋ฅผ N๋ฒ์งธ ์ด์ฉํ๋ค๋ฉด ๋ค์ ํ์ฐจ๋ถํฐ๋ ์ด์ฉ๋ฃ์ N๋ฐฐ๋ฅผ ๋ด์ผ ํ๋ค.
๋์ด๊ธฐ๊ตฌ๋ฅผ count๋ฒ ํ๊ฒ ๋๋ฉด ํ์ฌ ์์ ์ด ๊ฐ์ง๊ณ ์๋ ๊ธ์ก์์ ์ผ๋ง๊ฐ ๋ชจ์๋ผ๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ๋ผ.
๋จ, ๊ธ์ก์ด ๋ถ์กฑํ์ง ์์ผ๋ฉด 0์ return ํจ
* price : 1 โค price โค 2,500
* money : 1 โค money โค 1,000,000,000
* count : 1 โค count โค 2,500
-price, money, count๋ ๋ชจ๋ ์์ฐ์
class Solution {
public long solution(int price, int money, int count) {
long answer = -1;
for(int i=1; i<=count; i++){
money -= price * i;
}
answer = (money < 0)? (long)money * (-1):0;
return answer;
}
}
์๋ฌ ๋ฉ์์ง๊ฐ ๋์๋ค๋ฉด ๊ทธ ๋ถ๋ถ์ ์ค์ ์ ์ผ๋ก ๋ณด๊ณ ๊ณ ๋ฏผํ๊ฒ ์ผ๋ ์ด๋ฒ ์ค๋ฅ๋ ์ด๋์๋ถํฐ ์๋ชป๋ ๊ฑด์ง, ์๋ ์ ๋ง ์๋ชป๋ ๊ฑด ๋ง๋ ๊ฑด์ง
ํ์ฐธ์ ๊ณ ๋ฏผํ๋ฉฐ ํ๋์ฉ ์ ๊ฒํด ๋ณด์๋ค.
์ผ๋จ ๊ทธ๋์์ ๊ฒฝํ์ ์ฒ์๋ถํฐ ์ค๋ฅ๊ฐ ์๋๋ผ๋ฉด ์ฝ๋์ ์งํ ๋ฐฉํฅ์ ์ ์ก์์ผ๋ ๊ตฌ์กฐ์ ์ธ ๋ฌธ์ ์๋ ๊ฑธ ๋ ์ฌ๋ ธ๋ค.
1. ์ฒซ ๋ฒ์งธ๋ก answer์ด longํ์ธ๋ฐ price * i -> intํ์ผ๋ก ๋ฐํ๋๋ ๊ฒ ์์ธ์ด๋ผ๊ณ ์๊ฐํ์ฌ (long)์ผ๋ก ์ง์ ํ๋ณํ์ ์๋ํ๋ค(์คํจ)
2. ๋ ๋ฒ์งธ๋ก answer = (money < 0)? (long) money * (-1):0; ์ญ์ (-1)๋๋ฌธ์ answer๊ณผ ํ์
์ด ๋ง์ง ์๋ ๊ฒ ๊ฐ์์ ์ฌ๊ธฐ๋ (long)์ผ๋ก ํ๋ณํ์ ์๋ํ๋ค. (์คํจ)
3. ์ธ ๋ฒ์งธ๋ก๋ ์ ๋ง ๋ชจ๋ฅด๊ฒ ์ด์ ๋์ ๋ณด์ด๋ ์ซ์ํ ํ์
์ ๋ณ์๋ฅผ ์ ๋ถ long ํ์
์ผ๋ก ๋ฐ๊ฟ๋ดค๋ค.(์ฑ๊ณต)
๋ต์ ๋ฌด์ฌํ ์ ์ถ๋์์ผ๋ ์คํ๋ ค ๋๋ ๋ ๊น์ ์๋ฌธ์ ๋น ์ก๋ค.
๊ทธ ์ด์ ๋ ๋ฌด์์ (long)์ผ๋ก ํ๋ณํ์ ํ๊ธฐ ์ ์ int์ ๋ฒ์๋ฅผ ํ๋ฒ ๋ ์ฐพ์๋ณด๊ณ ๋ price * i์ ์ต๋๊ฐ์ ๋ฐ๋ก ์คํํด ๋ณด์๊ธฐ ๋๋ฌธ์ด๋ค.
๊ฐ๊ฐ ์ต๋๊ฐ์ธ 2500์ผ๋ก ์ค์ ํ๊ณ ๋ชจ๋ ๋ ํด๋ดค์ ๋ -774,309,592๋ก 7์ต๋๊ฐ ๋์๊ณ , ๋ง์ฝ money๊ฐ ์ต์๊ฐ์ธ 1์ด๋ผ๊ณ ํด๋ int์ ๋ฒ์ ์ฝ -21์ต~21 ์ต๋ด์ ์กด์ฌํ๋ค๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์ด๋ค.
count๋ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉ๋์์ผ๋ ํ์คํ ๊ด๋ จ์ด ์๊ธฐ ๋๋ฌธ์ price์ money์์ ๋ฌธ์ ๋๋ ๋ณ์๊ฐ ํ๋์ธ์ง ๋ ๋ค์๋์ง ๊ฒ์๋ฅผ ํด๋ดค๋ค.
์คํ๊ฒฐ๊ณผ | int price | int money |
---|---|---|
์ฑ๊ณต | long | long |
์คํจ | long | int |
์ฑ๊ณต | int | long |
์ค์ ํ ์ฝ๋ money -= price * i;
์ฆ, price * i๊ฐ ๋ฌธ์ ์๋ ๊ฒ์ผ๋ก ์๊ฐ๋์ด ๊ฐ์ ์ถ๋ ฅ๊ฐ์ ๋ค์ ๋ณด์๋ค.
์์ ๋ฐ๋ณต๋ฌธ์ ์ถ๋ ฅ๋ฌธ์ ํจ๊ป ์ฐ์ด์ ๋ณด๋ ์ค๊ฐ์ ๊ฐ์ด ์ด์ํ๊ฒ ๋์จ ๊ฑธ ํ์ธํ ์ ์์๊ณ ๋ฑ์ฐจ์์ด์ ํฉ์ ์ด์ฉํ์ฌ ์ง์ ๊ณ์ฐํด ๋ณด์๋ค.
์ฒซํญ: 2500
๋ง์ง๋งํญ: 2500*2500
n = 2500
-> 2500(2500+2500*2500)/2 = 7,815,625,000 (์ฝ 78์ต)
์ด๋ฌ๋ int money์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒ ๋น์ฐํ๋ค.
๊ทธ๋ฆฌ๊ณ b๋ฅผ longํ์
์ผ๋ก ๋ณ๊ฒฝ ํ ํ๋ฒ ๋ ๊ณ์ฐํด ๋ดค๋ค. (๊ณ์ฐ๊ฐ ์ผ์น)
๐ longํ์ ๋ณ์๋ก ์ ์ฅ๋ฐ๊ณ ๋ด์ผ ํ ๊ธ์ก๊ณผ ๊ฐ์ง๊ณ ์๋ ๊ธ์ก์ ๋น๊ต๋ก ์งํํ๊ธฐ.
class Solution {
public long solution(int price, int money, int count) {
long answer = 0;
for(int i=1; i<=count; i++){
answer += price * i;
}
return (answer < money)? 0: answer-money;
}
}
price * i๊ฐ int์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ค๋ฉด ํด๊ฒฐํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ง๋ง ๋๋ ์ด ์ธ ๊ฐ์ง๊ฐ ๋ฐ๋ก ์๊ฐ๋ฌ๋ค.
1. ์ ์ด์ ๋งค๊ฐ๋ณ์๋ฅผ intํ์ด ์๋ longํ์
์ผ๋ก ๋ฐ๊ธฐ
ex) public long solution(int price, long money, int count)
2. intํ์ผ๋ก ๋์ด์จ ๋ณ์๋ฅผ long์ผ๋ก ๋ค์ ๋ณํ ํ ๊ณ์ฐํ๊ธฐ
ex) long longMoney = money;
3. โ
price * i๋ฅผ long ๋ณ์๋ก ๋ฐ๊ณ money๊ฐ๊ณผ์ ๋์๋น๊ต๋ก return ํ๊ธฐ - ์์ ์ฝ๋ ์ฐธ์กฐ
1๋ฒ์ ๊ฒฝ์ฐ ๋ฌธ์ ์ ์๋์ ๋ฒ์ด๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํ๊ณ
2๋ฒ์ ๊ฒฝ์ฐ ์ฌ์ฉํ ๋ณ์๊ฐ ํ๋ ๋ ๋์ด๋๊ธฐ ๋๋ฌธ์ ๋น์ฉ์ ์ธ ๊ด์ ์์ ์ ํํ์ง ์์๋ค.
์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ฒ์๊ฐ ์๋ค๋ฉด ๋ฐ๋์ ์ต์๊ฐ, ์ต๋๊ฐ์ผ ๋์ ์ ํจ์ฑ์ ๊ฒ์ฌํด ๋ณด์.
์ง๊ธ๊น์ง๋ intํ์ ํํ๊ฐ์ ๋ฒ์ด๋๋ ์ํฉ์ ๋ง๋ ์ ์ด ์์ด์ ํํ๊ฐ์ ๋ฒ์๋ผ๋ ๊ฒ์ ๋ํด ์์ผํ๊ฒ ์๊ฐํ์๋ค.
๋ค๋ฅธ ์ฝ๋์ค๋ฅ์๋ ๋ฌ๋ฆฌ ์ด๋ ํ ๋ฉ์์ง๋ ๋จ์ง ์๊ธฐ ๋๋ฌธ์ ์ง๊ธ์ฒ๋ผ ํ๋ ธ๋ค๊ณ ์๋ ค์ฃผ์ง ์์๋ค๋ฉด ์์ํ ๋ชฐ๋์ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๊ฒ ์ค์ ํ๋ก์ ํธ์๋ค๋ฉด ๋ค๋ฅธ ์ฝ๋๋ ๋ง์์ ์ด๋ ๋ถ๋ถ์ ์ค๋ฅ์ธ์ง ์ฐพ๊ธฐ๊ฐ ์ ๋ง ํ๋ค์์ ๊ฑฐ๊ณ ๊ทธ ์์ ์ค์๊ฐ ๊ฑท์ก์ ์ ์๋ ์ค๋ฅ๋ฅผ ๋ง๋ค๊ฒ ๋ ๊ฒ์ด๋ค.
์ด๋ฒ์ผ์ ๊ณ๊ธฐ๋ก ๋ฐ์์จ ๋งค๊ฐ๋ณ์์ ํ์ ๊ณผ ๊ณ์ฐ์ ์งํํด์ผ ํ๋ ๋ณ์์ ํ์ ์ด ๋ถ์ผ์นํ ๊ฒฝ์ฐ ์๋ก์ด ๋ณ์๋ก ๋ค์ ๋ฐ์์ ํํ๋ฅผ ๋ง์ถ๊ฑฐ๋ ์ง์ ๊ณ์ฐํ์ง ์๊ณ ์๋ก์ ๊ฐ์ ๋น๊ตํ๋ ๋ฐฉ์์ด ๋ ์์ ํ๋ค๋ ๊ฒ์ ๊นจ๋ฌ์๋ค.
์์ผ๋ก๋ ์กฐ๊ฑด์ด ์ฃผ์ด์ง๋ฉด ๊ฐ์ ํํ๋ฒ์๋ฅผ ๋จผ์ ํ์คํ๊ฒ ์ฒดํฌํด์ผ๊ฒ ๋ค.