> ๋ฌธ์ ๋ฅผ ๋ณด๋ ค๋ฉด ๋๋ณด๊ธฐ ํด๋ฆญ!
๋ฌธ์ ์ค๋ช
S์ฌ์์๋ ๊ฐ ๋ถ์์ ํ์ํ ๋ฌผํ์ ์ง์ํด ์ฃผ๊ธฐ ์ํด ๋ถ์๋ณ๋ก ๋ฌผํ์ ๊ตฌ๋งคํ๋๋ฐ ํ์ํ ๊ธ์ก์ ์กฐ์ฌํ์ต๋๋ค. ๊ทธ๋ฌ๋, ์ ์ฒด ์์ฐ์ด ์ ํด์ ธ ์๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์๋ ์์ต๋๋ค. ๊ทธ๋์ ์ต๋ํ ๋ง์ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์ ์๋๋ก ํ๋ ค๊ณ ํฉ๋๋ค.
๋ฌผํ์ ๊ตฌ๋งคํด ์ค ๋๋ ๊ฐ ๋ถ์๊ฐ ์ ์ฒญํ ๊ธ์ก๋งํผ์ ๋ชจ๋ ์ง์ํด ์ค์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1,000์์ ์ ์ฒญํ ๋ถ์์๋ ์ ํํ 1,000์์ ์ง์ํด์ผ ํ๋ฉฐ, 1,000์๋ณด๋ค ์ ์ ๊ธ์ก์ ์ง์ํด ์ค ์๋ ์์ต๋๋ค.
๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ด ๋ค์ด์๋ ๋ฐฐ์ด d์ ์์ฐ budget์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋ ๋ช ๊ฐ์ ๋ถ์์ ๋ฌผํ์ ์ง์ํ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- d๋ ๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ด ๋ค์ด์๋ ๋ฐฐ์ด์ด๋ฉฐ, ๊ธธ์ด(์ ์ฒด ๋ถ์์ ๊ฐ์)๋ 1 ์ด์ 100 ์ดํ์ ๋๋ค.
- d์ ๊ฐ ์์๋ ๋ถ์๋ณ๋ก ์ ์ฒญํ ๊ธ์ก์ ๋ํ๋ด๋ฉฐ, ๋ถ์๋ณ ์ ์ฒญ ๊ธ์ก์ 1 ์ด์ 100,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
- budget์ ์์ฐ์ ๋ํ๋ด๋ฉฐ, 1 ์ด์ 10,000,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
[1,3,2,5,4] | 9 | 3 |
[2,2,3,3] | 10 | 4 |
์
์ถ๋ ฅ ์ #1
๊ฐ ๋ถ์์์ [1์, 3์, 2์, 5์, 4์]๋งํผ์ ๊ธ์ก์ ์ ์ฒญํ์ต๋๋ค. ๋ง์ฝ์, 1์, 2์, 4์์ ์ ์ฒญํ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ฉด ์์ฐ 9์์์ 7์์ด ์๋น๋์ด 2์์ด ๋จ์ต๋๋ค. ํญ์ ์ ํํ ์ ์ฒญํ ๊ธ์ก๋งํผ ์ง์ํด ์ค์ผ ํ๋ฏ๋ก ๋จ์ 2์์ผ๋ก ๋๋จธ์ง ๋ถ์๋ฅผ ์ง์ํด ์ฃผ์ง ์์ต๋๋ค. ์ ๋ฐฉ๋ฒ ์ธ์ 3๊ฐ ๋ถ์๋ฅผ ์ง์ํด ์ค ๋ฐฉ๋ฒ๋ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- 1์, 2์, 3์์ ์ ์ฒญํ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ ค๋ฉด 6์์ด ํ์ํฉ๋๋ค.
- 1์, 2์, 5์์ ์ ์ฒญํ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ ค๋ฉด 8์์ด ํ์ํฉ๋๋ค.
- 1์, 3์, 4์์ ์ ์ฒญํ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ ค๋ฉด 8์์ด ํ์ํฉ๋๋ค.
- 1์, 3์, 5์์ ์ ์ฒญํ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ ค๋ฉด 9์์ด ํ์ํฉ๋๋ค.
3๊ฐ ๋ถ์๋ณด๋ค ๋ ๋ง์ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์๋ ์์ผ๋ฏ๋ก ์ต๋ 3๊ฐ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์ ์์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
๋ชจ๋ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด์ฃผ๋ฉด 10์์ด ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์ต๋ 4๊ฐ ๋ถ์์ ๋ฌผํ์ ๊ตฌ๋งคํด ์ค ์ ์์ต๋๋ค.
๐ฅ [๋ก์ง]
1. d ์ค๋ฆ์ฐจ์ ์ ๋ ฌ!
- ์ต๋ํ ๋ง์ ๋ถ์๋ฅผ ์ง์ํ๋ ค๋ฉด ์ ์ฒญ๊ธ์ก์ด ๋ฎ์ ๋ถ์ ์์๋๋ก ์ง์ํด์ผ ํ๊ธฐ ๋๋ฌธ.
Arrays.sort(d); // ๋ฐ๋์ ๊ธฐ์ตํ๊ธฐ!(int[] ๋ฐฐ์ด์๋ ์ฌ์ฉ๊ฐ๋ฅํจ)
2. ์ ๋ ฌ๋ d์ ๊ฐ์ ํ๋์ฉ ๋ํด๊ฐ๋ฉฐ ์ต๋ ์ง์ ๊ฐ๋ฅํ ๋ถ์์ ์ ์ ํ๊ธฐ
- ๋ค์์ ๋ํ ๊ธ์ก์ด ์์ฐ์ ๋์ด๊ฐ๋ ๊ฒฝ์ฐ ํ์ฌ๊น์ง ์ง์ ๊ฐ๋ฅํ ๋ถ์์ ์ ๋ฆฌํด
- ์๋ ๊ฒฝ์ฐ, ์์ฐ์ ํฉ์ ์ถ๊ฐํด์ฃผ๊ณ ์ง์๊ฐ๋ฅํ ๋ถ์์ ์ 1 ์ฆ๊ฐ
๐ฅ [์ต์ข ์ฝ๋]
import java.util.*;
class Solution {
public int solution(int[] d, int budget) {
Arrays.sort(d);
int answer = 0;
int sum = 0;
for(int num : d) {
if(sum + num > budget) {
return answer;
}
sum += num;
answer++;
}
return answer;
}
}
๐ฅ [์๊ฐ]
int[] ๋ฐฐ์ด์ ์ ๋ ฌํด์ฃผ๋ ค๋ฉด List๋ก ํ์ ๋ณํํด์ค์ผ ํ๋์ค ์๊ณ ์ด๋ฐ์ ์์ฒญ ์ฝ์งํ๋คใ ใ ๊ทธ๋ฅ Arrays.sortํ๋๋ฉด ๋ค ๋๋๋๋..
์ฝํ ์ค๋น๋ฅผ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ์ง ์ผ๋ง ๋์ง ์์ ์ฝ๋์ ๋ฏธํกํ ์ ์ด ๋ง์ ์ ์์ต๋๋ค.
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-budtree