https://programmers.co.kr/learn/courses/30/lessons/12938
์ฝ๋
import java.util.*;
class Solution {
public int[] solution(int n, int s) {
if(n > s)
return new int[]{-1};
int[] answer = new int[n];
for(int i=0; i<answer.length; i++)
answer[i] = s/n;
for(int i=0; i<s%n; i++)
answer[i] ++;
Arrays.sort(answer);
return answer;
}
}
ํ์ด
๋ฌธ์ ์ ์์ ๋ค์ ๋ณด๊ณ ์ง๊ด์ ์ผ๋ก ์ ๊ทผํ๋ค.
๊ณฑ์ด ์ต๋์ธ ์์๋ฅผ ๋ฆฌํดํด์ผํ๋๋ฐ, ์์ ๋ค์ ๋ณด๋ฉด ์ง์ง์ ๊ฐ๋ค์ด ๊ฐ์ฅ ํฐ ์๋ค๋ก ์ด๋ฃจ์ด์ ธ์๋ค.
๊ทธ๋์ ์ฃผ์ด์ง s์ ํฉ์ n๊ฐ๋ก ๋ํ๋ผ๋, ์ผ๋จ s๊ฐ n์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ ์๋ก ๋๋๊ณ , ๋๋จธ์ง ๋งํผ ๊ฐ์ ๋ํ๋ค.
๋ฐ๋ผ์ ํ์ด๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
♠ ๋ง์ฝ n>s ์ธ๊ฒฝ์ฐ - ์งํฉ์ ํฉ๋ณด๋ค ์์ฐ์์ ๊ฐ์๊ฐ ๋ง์๊ฒฝ์ฐ
โถ ์์ ๊ฒฝ์ฐ n๊ฐ์ ์์ฐ์๋ฅผ ์ด์ฉํด s์ ํฉ์ ๋ง๋ค ์ ์์ผ๋ฏ๋ก -1์ ๋ฆฌํดํ๋ค.
♠ ๊ทธ ์ธ์๊ฒฝ์ฐ ๋ฆฌํดํ ๋ฐฐ์ด answer์ ๋ชจ๋ ๊ฐ์ s/n ์ ์ ์ฅํ๋ค.
♠ ๊ทธ ํ s%n ๋งํผ answer ๋ฐฐ์ด์ ๋ชจ๋ ๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํจ๋ค.
์ ํ์ด๊ฐ ๋ฌด์จ์๋ฆฌ๋๋ฉด, ๋ค์ํ ์์๋ฅผ ํตํด ๋ณด๋ฉด ์ดํดํ๊ธฐ๊ฐ ์ฝ๋ค.
n = 3 , s = 13 ์ธ๊ฒฝ์ฐ ์ธ ๊ฐ์ ์์ฐ์๋ฅผ ์ด์ฉํด ํฉ์ 13์ด ๋๊ณ , ๊ณฑ์ด ์ต๋์ธ ์์ 3๊ฐ๋ฅผ ๋ฆฌํดํด์ผ ํ๋๋ฐ,
๋จผ์ ๋ฆฌํดํด์ผ ํ๋ 3๊ฐ์ ๊ฐ์ 4, 4, 5 ์ด๋ค.
- s/n ===> 13/3 = 4 ์ด๋ค. ๋ฐ๋ผ์ answer ๋ฐฐ์ด์ ๋ชจ๋ ์์์ 4๋ฅผ ์ ์ฅํ๋ค.
- answer = [4, 4, 4]
- s%n ===> 13%3 = 1 ์ด๋ค. ๋ฐ๋ผ์ answer ๋ฐฐ์ด์ ํ๊ฐ์ ๊ฐ๋ง 1์ ์ฆ๊ฐ์ํจ๋ค.
- ๊ทธ๋ผ answer = [4, 4, 5] ๊ฐ ๋๋ค. ๋ฐ๋ผ์ ์ต๋๊ฐ์ด๋ค.
n = 4, s = 15 ์ธ๊ฒฝ์ฐ๋ ๋ณด์.
- s/n ===> 3์ด๋ค. ๋ฐ๋ผ์ answer ๋ฐฐ์ด์ ๋ชจ๋ ์์์ 3์ ์ ์ฅํ๋ค.
- answer = [3, 3, 3, 3]
- s%n ===> 3์ด๋ค. ๋ฐ๋ผ์ answer ๋ฐฐ์ด์ ์ธ ๊ฐ์ ๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํจ๋ค.
- ๊ทธ๋ผ answer = [4, 3, 3, 3]์ด ๋๋ค. ๋ฐ๋ผ์ ์ต๋๊ฐ์ด๋ค.
๋ง์ง๋ง์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๋ฆฌํดํ๋ฏ๋ก ๋ฐฐ์ด์ ์ ๋ ฌํด์ฃผ๋ฉด ๋๋ค.
(๋ฐฐ์ด์ ์ ๋ ฌํ์ง ์๊ณ , ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ถํฐ +1์ฉ ์ฆ๊ฐ์ํค๋ ๋ฐฉ๋ฒ๋ ์๋ค.)
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)์ฌ๋ฐ๋ฅธ ๊ดํธ (0) | 2020.03.17 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level2)์ ํ์ ์๊ฐ ์ด๋ (0) | 2020.03.17 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level3)ํ๋ ธ์ด์ ํ (0) | 2020.03.17 |
ํ๋ก๊ทธ๋๋จธ์ค[Java] - (Level3)๋ฐฉ๋ฌธ ๊ธธ์ด (0) | 2020.03.17 |
[Codeforces] 1005A: Tanya and Stairways (0) | 2020.03.17 |
๋๊ธ