โค๏ธ Problem
- ๋ฌธ์
์์ธ์๋ถํด๋ ์ด๋ค ์๋ฅผ ์์๋ค์ ๊ณฑ์ผ๋ก ํํํ๋ ๊ฒ์ ๋๋ค. ์๋ฅผ ๋ค์ด 12๋ฅผ ์์ธ์ ๋ถํดํ๋ฉด 2 * 2 * 3 ์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ 12์ ์์ธ์๋ 2์ 3์ ๋๋ค. ์์ฐ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ n์ ์์ธ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
- ์ ํ ์ฌํญ
- 2 ≤ n ≤ 10,000
- ์ ์ถ๋ ฅ ์ & ์ค๋ช
no | n | result |
1 | 12 | [2, 3] |
2 | 17 | [17] |
3 | 420 | [2, 3, 5, 7] |
- 12๋ฅผ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 ์ ๋๋ค. ๋ฐ๋ผ์ [2, 3]์ returnํฉ๋๋ค.
- 17์ ์์์ ๋๋ค. ๋ฐ๋ผ์ [17]์ return ํด์ผ ํฉ๋๋ค.
- 420์ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 * 5 * 7 ์ ๋๋ค. ๋ฐ๋ผ์ [2, 3, 5, 7]์ returnํฉ๋๋ค.
๐ Solution
ํ์ด 1
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
class Solution {
public int[] solution(int n) {
Set<Integer> st = new TreeSet<Integer>();
int primefactor = 2;
while (primefactor<=n) {
if(n%primefactor==0) {
st.add(Integer.valueOf(primefactor));
n /= primefactor;
} else {
primefactor++;
}
}
int[] arr = new int[st.size()];
Iterator iter = st.iterator();
for(int i =0; i<st.size(); i++) {
if(iter.hasNext()) {
arr[i] = (int) iter.next();
}
}
return arr;
}
}
์ฒ๋ฆฌ์๋์ ๋ํ ๋ณด์์ด ํ์ํด ๋ณด์ธ๋ค
ํ์ด 2
import java.util.ArrayList;
import java.util.List;
class Solution {
public int[] solution(int n) {
List<Integer> list = new ArrayList<>();
int primeFactor = 2;
while(n > 1){
if(n%primeFactor==0){
if(!list.contains(primeFactor))
list.add(primeFactor);
n /= primeFactor;
continue;
}
primeFactor++;
}
int[] answer = new int[list.size()];
for(int i=0; i<answer.length; i++) {
answer[i] = list.get(i);
// System.out.println(answer[i]);
}
return answer;
}
}
์ฒ๋ฆฌ์๋ ๋ณด์ ์๋ฃ
๐ Comment
ํ์ด 1์ ์ฝ๋ ์ฒ๋ฆฌ ์๋๊ฐ ๋๋ ธ๋ ์ด์ ๋ ๋ฐ์ดํฐ์ ์ค๋ณต์ ํผํ๋ ค TreeSet์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ด๋ค.
TreeSet์ ์ฌ์ฉํ์ฌ ์ค๋ณต๋ฐฉ์ง + ์์์ ์ง ๋ ํจ๊ณผ๋ฅผ ๋ ธ๋ ค๋ดค์ง๋ง ๋์ค์ TreeSet์์ Array๋ก ๊ฐ์ ๋ด๋ณด๋ด๋ ๊ณผ์ ์์ ์ฒ๋ฆฌ ์๋๊ฐ ํ์ ํ๊ฒ ๋๋ ค์ง ๊ฒ์ผ๋ก ์ถ์ ๋๋ค.
TreeSet์ ํน์ง์๋ง ๊ฝํ ๋๋จธ์ง ํ์ฉ์ฑ์ ์๊ฐํ์ง ์์๋ ๊ฒ ๊ฐ๋ค. Set์ ๊ฐ์ ์ฝ์ ํ ๋ ์ ํด์ง ์์๊ฐ ์๊ธฐ ๋๋ฌธ์ Array๋ ArrayList์ฒ๋ผ ์ธ๋ฑ์ค๋ก ๊ฐ์ ์ถ์ถํ๋ ๋ฐฉ์์ด ํตํ์ง ์๋๋ค๋ ๊ฒ์ ๋ชฐ๋๋ค.
๋ฐ๋ผ์ ํ์ด 2์์๋ Set์ ์ฌ์ฉํ์ง ์์๋ค. ArrayList๋ฅผ ์ฌ์ฉํ๋ ์ค๋ณต๊ฒ์ฌ๋ฅผ ์ํด ArrayList์ ์ด๋ฏธ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ์๋ง ํด๋น ๊ฐ์ ์ฝ์ ํ๋๋ก ํ์๋ค. ์ดํ์๋ ArrayList์ ๊ฐ์ Array๋ก ์ ๋ฌํ๋ฉด ๋.
๐ค Concept
Set
- Collection ์๋ฃ๊ตฌ์กฐ ์ค ํ๋์ธ ์ธํฐํ์ด์ค
( == Collection interface๋ฅผ ์์ํ๋ ์๋ฃ ๊ตฌ์กฐ) - ์์์ ์๊ด ์์ด "๊ฐ"์ ์กด์ฌ์ ๋ฌด๋ฅผ ํ์ธํ๊ธฐ ์ํ ์ฉ๋๋ก ์ฃผ๋ก ์ฌ์ฉ
Set์ ํน์ง
- ๊ฐ ์ค๋ณต ๋ถ๊ฐ๋ฅ
- ๊ฐ ์ฝ์ ์ ์์๋ฅผ ๋ณด์ฅํ์ง ์์
- ์ ๋ ฌ ๋ถ๊ฐ๋ฅ (์์ธ: TreeSet)
- ๋๊ธฐํ ๋ถ๊ฐ๋ฅ (not thread-safe)
- ์์ํ ๊ฐ์ ์ ์ฅ์ด ๋ถ๊ฐ๋ฅ
- ๊ฐ ์ถ๋ ฅ ์ ๋ฐ๋ณต๋ฌธ ๋๋ Iterator๋ก ์ถ๋ ฅ (<-> ArrayList๋ get ์ฌ์ฉ)Set์ ์ข ๋ฅ
public static void main(String[] args) {
HashSet<Integer> set = new HashSet<>();
for (int i = 0; i < 10; i++) {
set.add(i);
}
//Iterator ์ฌ์ฉํ์ฌ ๊ฐ ๊บผ๋ด๊ธฐ
Iterator<Integer> iter = set.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
//๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ฐ ๊บผ๋ด๊ธฐ
for(int i : set) {
System.out.println(i);
}
}
- HashSet
- HashMap๊ณผ Set ์ธํฐํ์ด์ค๋ฅผ ์์
- ๊ฐ์ฅ ๋น ๋ฅธ ์์ ์ ๊ทผ ์๋ (๊ฐ์ฅ ์ฑ๋ฅ์ด ์ข์)
- ์ ๋ ฌ ๋ถ๊ฐ๋ฅ
- ์์๋ฅผ ๋ณด์ฅํ์ง ์์
- TreeSet
- Tree์ Set ์ธํฐํ์ด์ค๋ฅผ ์์
- HashSet๋ณด๋ค ์ฒ๋ฆฌ ์๋๋ ๋๋ฆผ
- ์ ๋ ฌ ๊ฐ๋ฅ (๊ฐ ์ฝ์ ๊ณผ ๋์์ ์ ๋ ฌ)
- ์ ๋ ฌ ๋ฐฉ๋ฒ์ ์ง์ ํ ์ ์์
- ์ต๋๊ฐ ๋ฐ ์ต์๊ฐ ๋ฉ์๋, ํต๊ณ ๋ฉ์๋ ์กด์ฌ
- LinkedHashSet
- ๊ฐ ์ฝ์ ์์๋ฅผ ๋ณด์ฅ
- ์ฐ๊ฒฐ๋ ๋ชฉ๋ก ํํ๋ก ๊ตฌํ๋จ -> ๋๋ฆฌ๋ค
- ์ฑ๋ฅ์์ ์ด์ ๋ก ์ ์ฌ์ฉํ์ง ์๋๋ค
์ฐธ๊ณ ํ ๋ธ๋ก๊ทธ
https://bangu4.tistory.com/203 [Java] Set ์ธํฐํ์ด์ค์ ํด๋์ค - ์ด์ ๋ฆฌ
https://bangu4.tistory.com/194 [Java] Java Collection ๊ตฌ์กฐ ์ ๋ฆฌ
'Programmers lv-0' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ฐ๊น์ด ์ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.28 |
---|---|
์ค๋ณต๋ ๋ฌธ์ ์ ๊ฑฐ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.27 |
์ปจํธ๋กค ์ ํธ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.27 |
์จ์ด์๋ ์ซ์์ ๋ง์ (1) - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.27 |
๊ตฌ์ฌ์ ๋๋๋ ๊ฒฝ์ฐ์ ์ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.27 |
์ง๋ฃ์์ ์ ํ๊ธฐ - Java [ํ๋ก๊ทธ๋๋จธ์ค ์ ๋ฌธ] (0) | 2022.11.27 |
๋๊ธ