๋ฌธ์
์ต๋น๊ฐ์ ์ฃผ์ด์ง ๊ฐ ์ค์์ ๊ฐ์ฅ ์์ฃผ ๋์ค๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋น๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด -1์ return ํฉ๋๋ค.
์ ํ์ฌํญ
- 0 < array์ ๊ธธ์ด < 100
- 0 ≤ array์ ์์ < 1000
์ ์ถ๋ ฅ ์
array | result |
[1, 2, 3, 3, 3, 4] | 3 |
[1, 1, 2, 2] | -1 |
[1] | 1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- [1, 2, 3, 3, 3, 4]์์ 1์ 1๊ฐ 2๋ 1๊ฐ 3์ 3๊ฐ 4๋ 1๊ฐ๋ก ์ต๋น๊ฐ์ 3์ ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- [1, 1, 2, 2]์์ 1์ 2๊ฐ 2๋ 2๊ฐ๋ก ์ต๋น๊ฐ์ด 1, 2์ ๋๋ค. ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ด๋ฏ๋ก -1์ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- [1]์๋ 1๋ง ์์ผ๋ฏ๋ก ์ต๋น๊ฐ์ 1์ ๋๋ค.
ํ์ด
๐ก ์ ๊ทผ ๋ฐฉ๋ฒ
1. ๋ฐฐ์ด์์์ ์ต๋๊ฐ์ ๊ตฌํ๋ค. (max)
2. ์ต๋๊ฐ๋งํผ์ ๊ธธ์ด๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ ํ ๋นํ๋ค. (cnt[ ])
(* ์ต๋๊ฐ์ index์ ์ต๋๊ฐ์ด ๋ค์ด์ค๋๋ก +1์ ํด์ค๋ค)
3. for๋ฌธ์ผ๋ก ์ฃผ์ด์ง ๋ฐฐ์ด์ ๊ฐ ๊ฐ๊ณผ ์ผ์นํ๋ ๋ถ๋ถ์ ์ฆ๊ฐ์ํจ๋ค. (๋ฐ์ ํ์๋ฅผ ์นด์ดํธ ํจ)
4. ๋ฐฐ์ด(cnt[ ])์์ ๊ฐ์ฅ ํฐ ๊ฐ์ index๋ฅผ ๊ตฌํ๋ค.
5. ๊ตฌํ๋ ๊ณผ์ ์์ ๊ฐ์ฅ ํฐ ๊ฐ๊ณผ ๋์ผํ ๊ฐ์ด ์กด์ฌํ๋ค๋ฉด -1์ return ํ๋ค.
์ฒ์ ์๋ฌ ์ฝ๋
import java.util.Arrays;
class Solution {
public int solution(int[] array) {
int answer = 0;
int max = 0;
//๋ฐฐ์ด์์์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ
for(int i=0; i<array.length; i++){
if(max < array[i]){
max = array[i];
}
}
int cnt[] = new int[max+1];
for(int i=0; i<array.length; i++){
cnt[array[i]]++;
}
Arrays.sort(cnt);
// !๋ฌธ์ ๋ฐ์์ง์
if(cnt[cnt.length-1] == cnt[cnt.length-2]){
answer = -1;
} else{
answer = cnt[cnt.length-1];
}
return answer;
}
}
์ค๋ฅ๊ฐ ๋ฐ์ํ ์ฝ๋์ด๋ค.
cnt[ ]์ ๊ฐ์ฅ ๋ง์ด count๋ ์์๋๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํ์ฌ, ๋ง์ง๋ง ๊ฐ๊ณผ ์ง์ ๊ฐ์ด ๊ฐ๋ค๋ฉด ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ ์ด๋ฏ๋ก -1์ ์ถ๋ ฅํ๋๋ก ํ๋ค.
!๋ฌธ์ : ์ฃผ์ด์ง ํ ์คํธ์ผ์ด์ค 3๊ฐ๋ ํต๊ณผํ์ผ๋, ์ ์ถ ์ 16๊ฐ ์ค 6๊ฐ์ ํ ์คํธ๋ง ํต๊ณผํ์๋ค.
!์์ธ: ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ ์ผ ๋ -1์ ์ถ๋ ฅํ๋๋ก ํ ์ฝ๋์์
๋ฐฐ์ด์ ๊ฐ์ด 1๊ฐ๋ง ๋ค์ด์์ ๊ฒฝ์ฐ .length-2๋ฅผ ํ์ ๋ ํด๋นํ๋ index๊ฐ ์กด์ฌํ์ง ์๊ฒ ๋์ด
์ค๋ฅ๊ฐ ๋ฐ์ํ ์ ๋ฐ์ ์์๋ค.
์ต์ข ์ฝ๋
class Solution {
public int solution(int[] array) {
int answer = 0;
int max = 0;
int max_cnt = 0;
//๋ฐฐ์ด์์์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ
for(int i=0; i<array.length; i++){
if(max < array[i]){
max = array[i];
}
}
int cnt[] = new int[max+1];
for(int i=0; i<array.length; i++){
cnt[array[i]]++;
}
for(int i=0; i<cnt.length; i++){
if(max_cnt < cnt[i]) {
max_cnt = cnt[i];
answer = i;
} else if(max_cnt == cnt[i]) {
answer = -1;
}
}
return answer;
}
}
์ค๋ฆ์ฐจ์ ์ ๋ ฌ ๋์ cnt[ ]์์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ๋๋ค. ๊ฐ์ ์ฐพ๋ ๋์ค ๋์ผํ ๊ฐ์ด ์กด์ฌํ๋ค๋ฉด -1์ return ํ๋๋ก ์์ ํ๋ค.
'๐ Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] ๋ชจ์ค๋ถํธ(1)(์๋ฐ) (0) | 2023.03.27 |
---|---|
[Programmers] ๋ฐ๋ณต๋ฌธ ์ถ๋ ฅํ๊ธฐ(์๋ฐ) (0) | 2023.03.25 |
[Programmers] ํผ์ ๋๋ ๋จน๊ธฐ(2)(์๋ฐ) (0) | 2023.03.21 |
[Programmers] ๋ถ์์ ๋ง์ (์๋ฐ) (0) | 2023.03.20 |
[Programmers] ๋ ์์ ๋๋์ (์๋ฐ) (2) | 2023.03.17 |