| ๋ฉ์๋ | ์ค๋ช |
|---|---|
| boolean add(Object o) boolean addAll(Collection c) | ์ง์ ๋ ๊ฐ์ฒด(o) ๋๋ Collection(c) ์ ๊ฐ์ฒด๋ค์ Collection์ ์ถ๊ฐํ๋ค. |
| void clear() | Collection์ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ ํ๋ค. |
| boolean contains(Object o) boolean containsAll(Collection c) | ์ง์ ๋ ๊ฐ์ฒด ๋๋ Collection์ ๊ฐ์ฒด๋ค์ด Collection์ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ค. |
| boolean isEmpty() | Colleciton์ด ๋น์ด์๋์ง ํ์ธ |
| Iterator iterator() | Collection์ Iterator๋ฅผ ์ป์ด์ ๋ฐํ |
| boolean remove(Object o) boolean removeAll(Collection c) | ์ง์ ๋ ๊ฐ์ฒด ๋๋ Collection์ ํฌํจ๋ ๊ฐ์ฒด๋ค์ ์ญ์ |
| boolean retainAll(Collection c) | ์ง์ ๋ Collection์ ํฌํจ๋ ๊ฐ์ฒด๋ง์ ๋จ๊ธฐ๊ณ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ Collection ์์ ์ญ์ ํ๋ค. ์ด ์์ ์ผ๋ก Collection์ ๋ณํ๊ฐ ์์ผ๋ฉด true, ์๋๋ฉด false๋ฅผ ๋ฐํ |
| int size() | Collection์ ์ ์ฅ๋ ๊ฐ์ฒด์ ๊ฐ์๋ฅผ ๋ฐํ |
| Object[] toArray() | Collection์ ์ ์ฅ๋ ๊ฐ์ฒด๋ฅผ ๊ฐ์ฒด๋ฐฐ์ด(Object[])๋ก ๋ฐํ |
| Object[] toArray(Object[] a) | ์ง์ ๋ ๋ฐฐ์ด์ Collection์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํด์ ๋ฐํ |
ArrayList, LinkedList, Stack, Vector ๋ฑ| ๋ฉ์๋ | ์ค๋ช |
|---|---|
| void add(int index, Object element) boolean addAll(int index, Collection c) | ์ง์ ๋ ์์น์ ์๋ ๊ฐ์ฒด ๋๋ ์ปฌ๋ ์ ์ ํฌํจ๋ ๊ฐ์ฒด๋ค์ ์ถ๊ฐํ๋ค. |
| Object get(int index) | ์ง์ ๋ ์์น์ ์๋ ๊ฐ์ฒด ๋ฐํ (์ผ>์ค) |
| int indexOf(Object O) | ์ง์ ๋ ๊ฐ์ฒด์ ์์น๋ฅผ ๋ฐํ (์ค>์ผ) |
| int lastindexOf(Object o) | ์ง์ ๋ ๊ฐ์ฒด |
| ListIteratior listIterator() ListIterator listIterator(int index) | List์ ๊ฐ์ฒด์ ์ ๊ทผํ ์ ์๋ ListIterator๋ฅผ ๋ฐํ |
| Object remove(int index) | ์ง์ ๋ ์์น์ ์๋ ๊ฐ์ฒด๋ฅผ ์ญ์ ํ๊ณ ์ญ์ ๋ ๊ฐ์ฒด๋ฅผ ๋ฐํ |
| Object set(int index, Object element) | ์ง์ ๋ ์์น์ ๊ฐ์ฒด๋ฅผ ์ ์ฅ |
| void sort(Comparator c) | ์ง์ ๋ ๋น๊ต์๋ก List๋ฅผ ์ ๋ ฌ |
| List subList(int fromIndex, int toIndex) | ์ง์ ๋ ๋ฒ์์ ์๋ ๊ฐ์ฒด ๋ฐํ |
HashSet, TreeSetSet ์ธํฐํ์ด์ค์ ๋ฉ์๋ - Collection ์ธํฐํ์ด์ค์ ๋์ผ
| ๋ฉ์๋ | ์ค๋ช |
|---|---|
| void clear() | Map์ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ์ญ์ |
| boolean isEmpty() | Map์ด ๋น์ด์๋์ง ํ์ธ์ธ |
| boolean containsKey(Object key) | ์ง์ ๋ key ๊ฐ์ฒด์ ์ผ์นํ๋ Map์ key ๊ฐ์ฒด๊ฐ ์๋์ง ํ์ธ |
| boolean containsValue(Object value) | ์ง์ ๋ value ๊ฐ์ฒด์ ์ผ์นํ๋ map์ value ๊ฐ์ฒด๊ฐ ์๋์ง ํ์ธ |
| Object get(Object key) | ์ง์ ํ key ๊ฐ์ฒด์ ๋์ํ๋ value ๊ฐ์ฒด๋ฅผ ์ฐพ์์ ๋ฐํ |
| Object put(Object Key, Object value) | Map์ value ๊ฐ์ฒด๋ฅผ key ๊ฐ์ฒด์ ์ฐ๊ฒฐ(mapping)ํ์ฌ ์ ์ฅ |
| void putAll(Map t) | ์ง์ ๋ Map์ ๋ชจ๋ key-value ์์ ์ถ๊ฐ |
| Object remove(Object key) | ์ง์ ํ key ๊ฐ์ฒด์ ์ผ์นํ๋ key-value๊ฐ์ฒด๋ฅผ ์ญ์ |
| Set entrySet() | Map์ ์ ์ฅ๋์ด ์๋ key-value ์์ Map.Entryํ์ ์ ๊ฐ์ฒด๋ก ์ ์ฅํ Set์ผ๋ก ๋ฐํ |
| Set keySet() | Map์ ์ ์ฅ๋ ๋ชจ๋ Key ๊ฐ์ฒด๋ฅผ ๋ฐํ |
| Collection valuse() | Map์ ์ ์ฅ๋ ๋ชจ๋ value ๊ฐ์ฒด๋ฅผ ๋ฐํ |
๋ฌธ์ ์ค๋ช
์ต๋น๊ฐ์ ์ฃผ์ด์ง ๊ฐ ์ค์์ ๊ฐ์ฅ ์์ฃผ ๋์ค๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋น๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด -1์ return ํฉ๋๋ค.
์ ํ์ฌํญ
0 < array์ ๊ธธ์ด < 100
0 โค array์ ์์ < 1000
์
์ถ๋ ฅ ์ #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์
๋๋ค.
๋ด ์ฝ๋
public static int solution(int[] array) {
//array์ ๊ธธ์ด๊ฐ ๊ฐ์ ๋น ๋ฐฐ์ด ์์ฑ
int[] array1 = new int[array.length];
//array์ ์์ ๋ณ ๋ฑ์ฅํ์๋ฅผ array1์ ์ ์ฅ
for(int i=0; i<array.length; i++){
int cnt = 0;
for(int ii=0; ii<array.length; ii++){
if(array[i] == array[ii])
cnt++;
}
array1[i] = cnt;
}
//array1์ ์ต๋๊ฐ ๊ตฌํ๊ธฐ == ์ต๋น๊ฐ
int max = 0;
for(int i=0; i<array1.length; i++){
if(max < array1[i])
max = array1[i];
}
//array์ ์์ ์ค ์ต๋น๊ฐ์ธ ์ธ๋ฑ์ค๋ฅผ ํ์ธํ ๋น๋ฐฐ์ด ์์ฑ
int[] array2 = new int[array.length];
//์ต๋น๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋น ๋ฐฐ์ด์ ์ ์ฅ
for(int i=0; i<array.length; i++){
if(array1[i] == max) {
array2[i] = 1;
} else {
array2[i] = 0;
}
}
//array์์ ์ต๋น๊ฐ์ด ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ์์์ ๊ฐ ํ์ธ
int max2 = 0;
for(int i=0; i<array.length; i++){
if(array1[i] == max) {
max2 = array[i];
}
}
//์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ธ์ง ํ์ธ
int maxCount = 0;
for(int i=0; i<array1.length; i++){
if(array2[i] == 1) {
if(array[i] != max2) {
maxCount++;
}
}
}
//์ฌ๋ฌ๊ฐ์ผ ๊ฒฝ์ฐ -1 ์๋์ ์ต๋น๊ฐ ๋ฆฌํด
if(maxCount >= 1) {
return -1;
} else {
return max2;
}
}
์ต๋น๊ฐ ์ด๋ผ๋ ๋จ์ด๋ฅผ ๋ณด์๋ง์ '์๋๊ฒ ๋๋ฐ... ๊ตฌ๊ธ๋ง ํด์ผํ๋' ์ด๋ฐ ํ๋ ค๋จน์ ์๊ฐ์ ํ๋ค ์ง์ง ๋น๋น ๋์ ๊ฐ๋๋ผ๋ ์ง์ ํ์ด๋ณด๊ณ ์ถ์๋ค.
GPT ์ ์๋์ ํ๋ง๋ : ์ ํ์ ์ธ '์ฒ์ ๊ณต๋ถํ์ ๋ ๋์ค๋ ์คํ์ผ' ์ฝ๋ ๋๋์ด๋ค ใ ใ
๋ญ๊ฐ "๋ ๋๊น์ง for๋ฌธ ๋๋ฆฐ๋ค!" ๊ฐ์ฑ ์์ฃผ ์ ์ด์์์.
HashMap ์ ์ฌ์ฉํ ์ ์์ ์ธ ํ์ด๋ ์ฒจ๋ถํ๋ฉฐ ๋ง์น๋ค.
์ฃผ์์ผ๋ก ํ๋ํ๋ ์ค๋ช
์ ๋ฌ์์ฃผ์
์ ๋๋ฌด ๊ฐ์ฌํ๋ค.
๋ชจ๋ฒ ๋ต์
ํ๋ก๊ทธ๋๋จธ์ค - ๊น์ง์ ๋์ ๋ต๋ณ
import java.util.*;
class Solution {
public int solution(int[] array) {
int maxCount = 0;
int answer = 0;
Map<Integer, Integer> map = new HashMap<>();
// getOrDefault : ์ฐพ๋ ํค๊ฐ ์กด์ฌํ๋ค๋ฉด ์ฐพ๋ ํค์ ๊ฐ์ ๋ฐํํ๊ณ ์๋ค๋ฉด ๊ธฐ๋ณธ ๊ฐ์ ๋ฐํํ๋ ๋ฉ์๋
// getPrDefault(Object key, V DefaultValue)
// ๋งค๊ฐ๋ณ์ : ์ด ๋ฉ์๋๋ ๋๊ฐ์ ๋งค๊ฐ๋ณ์๋ฅผ ํ์ฉ
// key : ๊ฐ์ ๊ฐ์ ธ์์ผ ํ๋ ์์์ ํค
// defaultValue : ์ง์ ๋ ํค๋ก ๋งคํ๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ฐํ๋์ด์ผ ํ๋ ๊ธฐ๋ณธ๊ฐ
// ๋ฐํ๊ฐ : ์ฐพ๋ key๊ฐ ์กด์ฌํ๋ฉด ํด๋น key์ ๋งคํ๋์ด ์๋ ๊ฐ์ ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ํดํธ ๊ฐ์ด ๋ฐํ
for(int number : array) {
int count = map.getOrDefault(number, 0) + 1;
if(count > maxCount) {
maxCount = count;
answer = number;
}
else if(count == maxCount) {
answer = -1;
}
map.put(number, count);
}
return answer;
}
}
๋ค์์ฃผ๋ ํ์ดํ !