[ํ๋ก๊ทธ๋๋จธ์ค] ํฐ์ผ๋ชฌ
https://programmers.co.kr/learn/courses/30/lessons/1845
๋ฌธ์ ์ค๋ช
๋น์ ์ ํฐ์ผ๋ชฌ์ ์ก๊ธฐ ์ํ ์ค๋ ์ฌํ ๋์, ํ ๋ฐ์ฌ๋์ ์ฐ๊ตฌ์ค์ ๋์ฐฉํ์ต๋๋ค. ํ ๋ฐ์ฌ๋์ ๋น์ ์๊ฒ ์์ ์ ์ฐ๊ตฌ์ค์ ์๋ ์ด N ๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค์์ N/2๋ง๋ฆฌ๋ฅผ ๊ฐ์ ธ๊ฐ๋ ์ข๋ค๊ณ ํ์ต๋๋ค.
ํ ๋ฐ์ฌ๋ ์ฐ๊ตฌ์ค์ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ์ ๋ฐ๋ผ ๋ฒํธ๋ฅผ ๋ถ์ฌ ๊ตฌ๋ถํฉ๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ์ข
๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด ์ฐ๊ตฌ์ค์ ์ด 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ด ์๊ณ , ๊ฐ ํฐ์ผ๋ชฌ์ ์ข
๋ฅ ๋ฒํธ๊ฐ [3๋ฒ, 1๋ฒ, 2๋ฒ, 3๋ฒ]์ด๋ผ๋ฉด ์ด๋ 3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ, 1๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ, 2๋ฒ ํฐ์ผ๋ชฌ ํ ๋ง๋ฆฌ๊ฐ ์์์ ๋ํ๋
๋๋ค. ์ด๋, 4๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ ์ค 2๋ง๋ฆฌ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ด 6๊ฐ์ง๊ฐ ์์ต๋๋ค.
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ ๋ฒ์งธ(1๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ฒซ ๋ฒ์งธ(3๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ์ธ ๋ฒ์งธ(2๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ๋ ๋ฒ์งธ(1๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
- ์ธ ๋ฒ์งธ(2๋ฒ), ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํ
์ด๋, ์ฒซ ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ๊ณผ ๋ค ๋ฒ์งธ(3๋ฒ) ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ํ ์ข ๋ฅ(3๋ฒ ํฐ์ผ๋ชฌ ๋ ๋ง๋ฆฌ)์ ํฐ์ผ๋ชฌ๋ง ๊ฐ์ง ์ ์์ง๋ง, ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค์ ๋ชจ๋ ๋ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ์์์์ ๊ฐ์ง ์ ์๋ ํฐ์ผ๋ชฌ ์ข ๋ฅ ์์ ์ต๋๊ฐ์ 2๊ฐ ๋ฉ๋๋ค.
๋น์ ์ ์ต๋ํ ๋ค์ํ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ๊ฐ์ง๊ธธ ์ํ๊ธฐ ๋๋ฌธ์, ์ต๋ํ ๋ง์ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ํฌํจํด์ N/2๋ง๋ฆฌ๋ฅผ ์ ํํ๋ ค ํฉ๋๋ค. N๋ง๋ฆฌ ํฐ์ผ๋ชฌ์ ์ข ๋ฅ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด nums๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, N/2๋ง๋ฆฌ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ ์ค, ๊ฐ์ฅ ๋ง์ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์, ๊ทธ๋์ ํฐ์ผ๋ชฌ ์ข ๋ฅ ๋ฒํธ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- nums๋ ํฐ์ผ๋ชฌ์ ์ข ๋ฅ ๋ฒํธ๊ฐ ๋ด๊ธด 1์ฐจ์ ๋ฐฐ์ด์ ๋๋ค.
- nums์ ๊ธธ์ด(N)๋ 1 ์ด์ 10,000 ์ดํ์ ์์ฐ์์ด๋ฉฐ, ํญ์ ์ง์๋ก ์ฃผ์ด์ง๋๋ค.
- ํฐ์ผ๋ชฌ์ ์ข ๋ฅ ๋ฒํธ๋ 1 ์ด์ 200,000 ์ดํ์ ์์ฐ์๋ก ๋ํ๋ ๋๋ค.
- ๊ฐ์ฅ ๋ง์ ์ข ๋ฅ์ ํฐ์ผ๋ชฌ์ ์ ํํ๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ์๋, ์ ํํ ์ ์๋ ํฐ์ผ๋ชฌ ์ข ๋ฅ ๊ฐ์์ ์ต๋๊ฐ ํ๋๋ง return ํ๋ฉด ๋ฉ๋๋ค.
Code
import java.util.HashMap;
class Solution {
public int solution(int[] nums) {
int answer = 0;
HashMap<Integer,Integer> ponketmon = new HashMap();
for(int num: nums){
ponketmon.put(num,ponketmon.getOrDefault(num,0)+1);
}
if(ponketmon.size() > nums.length/2){
answer = nums.length/2;
}
else {
answer = ponketmon.size();
}
return answer;
}
}
Code ์ค๋ช
์ด ๋ฌธ์ ๋ ์ฒ์ ๋ดค์๋๋ ์กฐํฉ์ ํ๋ํ๋ ๋ค ์ธ์ผ๋๋๊ฑฐ ๊ฐ์ง๋ง ์๊ฐํด๋ณด๋ฉด ์ค๋ณต๋๋ ๊ฒ๋ค์ ์ ๊ฑฐํ ๊ฐฏ์๊ฐ
nums.length/2๋ณด๋ค ํฌ๋ฉด nums.length/2๊ฐ answer์ด๊ณ , ๊ทธ๋ ์ง ์๋ค๋ฉด ์ค๋ณต๋๋ ๊ฒ๋ค์ ์ ๊ฑฐํ ๊ฐฏ์๊ฐ answer๊ฐ ๋๋ค.
์ค๋ณต์ ์ ๊ฑฐํ๊ธฐ ์ํด์ ์ ๋ฒ์ ์์ฃผํ์ง ๋ชปํ ์ ์์์ ์ฌ์ฉํ๋ HashMap์ ์ด์ฉํ๋ฉด ์ค๋ณต์ ์ ๊ฑฐํ ์ ์์๊ฒ ๊ฐ์์ ์ฌ์ฉํด ์ฃผ์๋ค.
๋ฐฐ์ด์
์ ๋ฒ์ ์ฌ์ฉํ๋ HashMap์ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ๋์ ๋ค๋ฅธ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๋ HashSet์ด๋ผ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์๊ฒ๋์๋ค.
HashMap์ key์ value๊ฐ ์์ง๋ง HashSet์ value๊ฐ ์๋ค๋ ์ฐจ์ด์ ์ด์๋ค. ์ฃผ๋ ์ฐจ์ด์ ์ HashMap์ด Map Interface Hierarchy์ ์ํ๊ณ HashSet์ด Collection Interface Hierarchy์ ์ํด์๋ ๋์ Collection ์ธํฐํ์ด์ค์ ๊ด๋ จ์ด ์๋ค๋ ๊ฒ์ด๋ค ๋ผ๋๊ฑด๋ฐ ๋ฌด์จ ์๋ฆฌ์ธ์ง ์ ๋ชจ๋ฅด๊ฒ ๋ค...
์๋ฌดํผ ์ด๋ฒ ๋ฌธ์ ๋ Key๊ฐ ํ์์์ผ๋ฏ๋ก HashSet์ ์ด์ฉํด์ ์ฝ๋๋ฅผ ๋ฐ๊ฟ๋ณด์๋ค. HashMap์ HashSet์ผ๋ก ๋ฐ๊พธ๊ธฐ๋ง ํ๋ฉด ๋๋ ๋๊ฐ์ ๊ตฌ์กฐ์ ์ฝ๋์ด๋ค
HashMap ์๊ฐ
HashSet ์๊ฐ
์๋ฏธ์๋ ์๊ฐ ์ฐจ์ด์ธ์ง๋ ๋ชจ๋ฅด๊ฒ ์ง๋ง HashSet์ด ๋ ๋น ๋ฅด๊ธด ํ๋ค.
HashSet์ ์ด์ฉํ Code
import java.util.HashSet;
class Solution {
public int solution(int[] nums) {
int answer = 0;
HashSet<Integer> ponketmon = new HashSet();
for(int num: nums){
ponketmon.add(num);
}
if(ponketmon.size() > nums.length/2){
answer = nums.length/2;
}
else {
answer = ponketmon.size();
}
return answer;
}
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ์ซ์ ๋ฌธ์์ด๊ณผ ์๋จ์ด (0) | 2021.07.18 |
---|---|
[Algoritm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ์ฒด์ก๋ณต (0) | 2021.07.13 |
[Algorithm/JAVA][ํ๋ก๊ทธ๋๋จธ์ค] ์์ฃผํ์ง ๋ชปํ ์ ์ (0) | 2021.07.11 |
[Algorithm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์ (0) | 2021.07.10 |
[Algorithm/Java][ํ๋ก๊ทธ๋๋จธ์ค] ๋ชจ์๊ณ ์ฌ (0) | 2021.07.08 |