2023. 3. 7. 10:00ใ์ฝ๋ฉํ ์คํธ ์ฐ์ต/ํ๋ก๊ทธ๋๋จธ์ค_2023
๋ฌธ์ ์ค๋ช
๊ฒฝํ๋ ๊ณผ์์์์ ๊ทค์ ์ํํ์ต๋๋ค. ๊ฒฝํ๋ ์ํํ ๊ทค ์ค 'k'๊ฐ๋ฅผ ๊ณจ๋ผ ์์ ํ๋์ ๋ด์ ํ๋งคํ๋ ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ ์ํํ ๊ทค์ ํฌ๊ธฐ๊ฐ ์ผ์ ํ์ง ์์ ๋ณด๊ธฐ์ ์ข์ง ์๋ค๊ณ ์๊ฐํ ๊ฒฝํ๋ ๊ทค์ ํฌ๊ธฐ๋ณ๋ก ๋ถ๋ฅํ์ ๋ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ์ ์๋ฅผ ์ต์ํํ๊ณ ์ถ์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ฒฝํ๊ฐ ์ํํ ๊ทค 8๊ฐ์ ํฌ๊ธฐ๊ฐ [1, 3, 2, 5, 4, 5, 2, 3] ์ด๋ผ๊ณ ํฉ์๋ค. ๊ฒฝํ๊ฐ ๊ทค 6๊ฐ๋ฅผ ํ๋งคํ๊ณ ์ถ๋ค๋ฉด, ํฌ๊ธฐ๊ฐ 1, 4์ธ ๊ทค์ ์ ์ธํ ์ฌ์ฏ ๊ฐ์ ๊ทค์ ์์์ ๋ด์ผ๋ฉด, ๊ทค์ ํฌ๊ธฐ์ ์ข ๋ฅ๊ฐ 2, 3, 5๋ก ์ด 3๊ฐ์ง๊ฐ ๋๋ฉฐ ์ด๋๊ฐ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ๊ฐ ์ต์์ผ ๋์ ๋๋ค.
๊ฒฝํ๊ฐ ํ ์์์ ๋ด์ผ๋ ค๋ ๊ทค์ ๊ฐ์ k์ ๊ทค์ ํฌ๊ธฐ๋ฅผ ๋ด์ ๋ฐฐ์ด tangerine์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๊ฒฝํ๊ฐ ๊ทค k๊ฐ๋ฅผ ๊ณ ๋ฅผ ๋ ํฌ๊ธฐ๊ฐ ์๋ก ๋ค๋ฅธ ์ข ๋ฅ์ ์์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 1 ≤ k ≤ tangerine์ ๊ธธ์ด ≤ 100,000
- 1 ≤ tangerine์ ์์ ≤ 10,000,000
์ ์ถ๋ ฅ ์
6 | [1, 3, 2, 5, 4, 5, 2, 3] | 3 |
4 | [1, 3, 2, 5, 4, 5, 2, 3] | 2 |
2 | [1, 1, 1, 1, 2, 2, 2, 3] | 1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ณธ๋ฌธ์์ ์ค๋ช ํ ์์์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๊ฒฝํ๋ ํฌ๊ธฐ๊ฐ 2์ธ ๊ทค 2๊ฐ์ 3์ธ ๊ทค 2๊ฐ ๋๋ 2์ธ ๊ทค 2๊ฐ์ 5์ธ ๊ทค 2๊ฐ ๋๋ 3์ธ ๊ทค 2๊ฐ์ 5์ธ ๊ทค 2๊ฐ๋ก ๊ทค์ ํ๋งคํ ์ ์์ต๋๋ค. ์ด๋์ ํฌ๊ธฐ ์ข ๋ฅ๋ 2๊ฐ์ง๋ก ์ด ๊ฐ์ด ์ต์๊ฐ ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- ๊ฒฝํ๋ ํฌ๊ธฐ๊ฐ 1์ธ ๊ทค 2๊ฐ๋ฅผ ํ๋งคํ๊ฑฐ๋ 2์ธ ๊ทค 2๊ฐ๋ฅผ ํ๋งคํ ์ ์์ต๋๋ค. ์ด๋์ ํฌ๊ธฐ ์ข ๋ฅ๋ 1๊ฐ์ง๋ก, ์ด ๊ฐ์ด ์ต์๊ฐ ๋ฉ๋๋ค.
๋์ ํ์ด
public int solution(int k, int[] tangerine) {
int answer = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i : tangerine)
{
map.put(i, map.getOrDefault(i, 0) + 1);
}
List<Integer> collect = map.values().stream().sorted()
.collect(Collectors.toList());
for (int i = collect.size()-1; i >= 0; i--)
{
if (k > 0) {
k -= collect.get(i);
answer++;
}
}
return answer;
}
์ด ๋ฌธ์ ๋ฅผ ํ ๋ ์๊ฐ๋ ๋ฐฉ๋ฒ์ Map์ ์ฌ์ฉํ๋ ๊ฒ์ด์๋ค..! ๋ด๊ฐ Map ์ฌ์ฉ์ ๋น ์ก๋.. ๊ณ์ ๋ฐฉ๋ฒ์ด Map ๋ฐ์ ๊ธฐ์ต์ด ์๋จ ..ใ ใ
์๋ฌดํผ Map์ผ๋ก ๊ทค์ ์ฌ์ด์ฆ๋ฅผ key ๊ฐ์ผ๋ก ๋๊ณ , ๊ทค ์ฌ์ด์ฆ๋ณ ๊ฐ์๋ฅผ value๋ก ๋๋ ๊ฑธ ์๊ฐํ๋ค.
๊ทธ๋ฆฌ๊ณ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ํ๋ฉด์ ์๊ฒ ๋ (?) getOrDefault ๋ฅผ ์ฌ์ฉํด์ key๊ฐ์ธ ๊ทค ์ฌ์ด์ฆ๋ฅผ ๋ฐ๊ฒฌํ๋ฉด +1 ์ฉ ํด์ฃผ๊ณ ์๋๋ฉด ๊ธฐ๋ณธ๊ฐ 0 ์ ๋ฃ๋๋ก ํด์คฌ๋ค.
์ต๋ํ ๊ฐ์ ํฌ๊ธฐ๋ก ๊ทค์ ๊ณจ๋ผ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ค์์ ์ด์ value ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ์ ๋ ฌ์ ํด์คฌ๊ณ , ํ ์์์ ๋ด์์ผ ํ๋ ๊ทค์ ๊ฐ์ k๊ฐ๊ฐ 0๋ณด๋ค ํด ๊ฒฝ์ฐ๊น์ง ๊ทค์ ๋ฃ์ ์ ์๊ธฐ ๋๋ฌธ์ k > 0 ์ผ๋ก ํด์ ๊ทค์ ๋นผ์ฃผ๊ณ , ๋ค์ answer ์ 1์ฉ ์ฆ๊ฐํด์ฃผ๋ฉด ๋๋ค!
๋ค๋ฅธ ์ฌ๋ ํ์ด
public int otherSolution(int k, int[] tangerine)
{
int answer = 0;
Map<Integer, Integer> map = new HashMap<>();
for (int i : tangerine)
{
map.put(i, map.getOrDefault(i, 0) + 1);
}
List<Integer> list = new ArrayList<>(map.keySet());
list.sort(((o1, o2) -> map.get(o2) - map.get(o1)));
for (Integer key : list)
{
if (k > 0) {
k -= map.get(key);
answer++;
}
}
return answer;
}
๋ฐฉ๋ฒ์ ๋๋ ๋น์ทํ๋ฐ ์ ๋ ฌํด์ ๊ฐ์ ์ด๋ป๊ฒ ๋ฝ์์ค๋ ์ง ์ด ๋ฐฉ๋ฒ์ด ๋ค๋ฅผ ๋ฟ!!!
List์ map์ key๊ฐ์ ๋ฃ์ด์ฃผ๊ณ , ๋ค์ list๋ฅผ ์ ๋ ฌํ ๋ map์์ ํด๋น ํค ๊ฐ์ ๊ตฌํด ์ด ๊ฐ ๊ธฐ๋ฐ์ผ๋ก ์ ๋ ฌํด์คฌ๋ค๋ ์ ์ด๋ค!!
์ด๋ฐ ๋ฐฉ๋ฒ๋ ์์๋ฌ์ผ์ง~_~
'์ฝ๋ฉํ ์คํธ ์ฐ์ต > ํ๋ก๊ทธ๋๋จธ์ค_2023' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] Lv2. ๋ฉ๋ฆฌ๋ฐ๊ธฐ (0) | 2023.03.08 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1. ๋ฌธ์์ด ๋ด ๋ง์๋๋ก ์ ๋ ฌํ๊ธฐ (0) | 2023.03.07 |
[ํ๋ก๊ทธ๋๋จธ์ค] Lv1. ๋ช ์์ ์ ๋น (1) (0) | 2023.02.23 |
[ํ๋ก๊ทธ๋๋จธ์ค] Lv2. ์กฐ๊ฑด์ ๋ง๋ ๋์์ ์ ์ ๋ฆฌ์คํธ ์ถ๋ ฅํ๊ธฐ (0) | 2023.02.23 |
[ํ๋ก๊ทธ๋๋จธ์ค] Lv3. ๋์ฌ ๊ธฐ๋ก์ด ์กด์ฌํ๋ ์๋์ฐจ ๋ฆฌ์คํธ ๊ตฌํ๊ธฐ (0) | 2023.02.22 |