๋ค์ด๊ฐ๊ธฐ ์ ์
ํ๋ก๊ทธ๋๋จธ์ค ๊ธฐ์กด์ ์์ด๋๋ฅผ ํํดํ๊ณ ๋ค์ ์์ํ๋ ๋ง์์ผ๋ก ์๋ก ๋ง๋ค์๋ค.
๊ทธ๋์ ์๊ณ ๋ฆฌ์ฆ ๋ ๋ฒจ 1๋ถํฐ ์ฐจ๊ทผํ ํ์ด๋ณด๊ณ ๊ธฐ๋ก์ ๋จ๊ธฐ๋ ค๊ณ ํ๋ค!
๋ฌธ์
๋ฌธ์ ์ค๋ช
์ ์ ๋ฐฐ์ด numbers๊ฐ ์ฃผ์ด์ง๋๋ค. numbers์์ ์๋ก ๋ค๋ฅธ ์ธ๋ฑ์ค์ ์๋ ๋ ๊ฐ์ ์๋ฅผ ๋ฝ์ ๋ํด์ ๋ง๋ค ์ ์๋ ๋ชจ๋ ์๋ฅผ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- numbers์ ๊ธธ์ด๋ 2 ์ด์ 100 ์ดํ์
๋๋ค.
- numbers์ ๋ชจ๋ ์๋ 0 ์ด์ 100 ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
numbers | return |
[2,1,3,4,1] | [2,3,4,5,6,7] |
[5,0,2,7] | [2,5,7,9,12] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- 2 = 1 + 1 ์ ๋๋ค. (1์ด numbers์ ๋ ๊ฐ ์์ต๋๋ค.)
- 3 = 2 + 1 ์ ๋๋ค.
- 4 = 1 + 3 ์ ๋๋ค.
- 5 = 1 + 4 = 2 + 3 ์ ๋๋ค.
- 6 = 2 + 4 ์ ๋๋ค.
- 7 = 3 + 4 ์ ๋๋ค.
- ๋ฐ๋ผ์
[2,3,4,5,6,7]
์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- 2 = 0 + 2 ์ ๋๋ค.
- 5 = 5 + 0 ์ ๋๋ค.
- 7 = 0 + 7 = 5 + 2 ์ ๋๋ค.
- 9 = 2 + 7 ์ ๋๋ค.
- 12 = 5 + 7 ์ ๋๋ค.
- ๋ฐ๋ผ์
[2,5,7,9,12]
๋ฅผ return ํด์ผ ํฉ๋๋ค.
ํ์ด
์ค๋ช
- ํด๋น ๋ฌธ์ ๋ ์ ์ถ๋ ฅ ์์์ฒ๋ผ ๋ฐฐ์ด์ ์กด์ฌํ๋ ๋ชจ๋ ์์๋ฅผ ํ์ํ์ฌ ๋ํ ๊ฐ์ ์ถ๋ ฅ ํด์ผ ํ๋ค.
- ๋จ, ๋ํ ๊ฐ์ด ์ค๋ณต์ผ๋ก ์กด์ฌํ๋ ๊ฒฝ์ฐ ํ๋๋ง ๋ฐฐ์ด์ ์ ์ฅํด์ผ ํ๋ค.
1๋ฒ์ ์กฐ๊ฑด์ ์ด์ค ๋ฐ๋ณต๋ฌธ์ ํตํด ์ฝ๊ฒ ๊ตฌํํ ์ ์์๋ค.
ํ์ง๋ง ์ค๋ณต์ ์ ๊ฑฐํ๋ ๋ฐฉ๋ฒ์์ ๋ด๊ฐ ์ง์ ๊ตฌํํ๋ ๊ฒ ๋ณด๋ค ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์ฌ ํจ์จ์ ์ด๋ผ๊ณ ํ๋จํ๋ค. ๊ทธ๋์ Set
์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ค.
Set
์๋ฃ๊ตฌ์กฐ์ ๋ํ์ ์ธ ๊ตฌํ ํด๋์ค๋ก HashSet
๊ฐ ์กด์ฌํ๋ค.
๋จผ์ HashSet
์ Hash
ํํ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ์ ๋ ฌ์ ๋ํด ์์ ํ์ง ๋ชปํ๋ค.
์ฆ, ์ ์ฅ๋ ๋ฐ์ดํฐ์ ์์๊ฐ ๋ค์ฃฝ๋ฐ์ฃฝ์ด๋ผ๋ ๋ป์ด๋ค!
๋จ, ์ค๋ณต๋ ๋ฐ์ดํฐ๋ ์ ์ฅํ์ง ์๋ Set
์๋ฃ๊ตฌ์กฐ์ ํน์ฑ์ ๊ฐ์ง๊ณ ์๋ค.
Set ์๋ฃ๊ตฌ์กฐ ํบ์๋ณด๊ธฐ
์ด๋ฌํ ์ด์ ๋ก ๋๋ ์ด์ค ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ฐฐ์ด์ ์์๋ค์ ๊ฐ๊ฐ ๋ํ ํ, ํด๋น ๊ฐ์ HashSet
์ ์ ์ฅํ๊ณ , ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ Iterator
๋ก ๋ณํํ์ฌ Arrays.sort()
๋ฉ์๋๋ฅผ ์ด์ฉํด ๋ํ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์์ด๋์ด๋ก ์ฝ๋๋ฅผ ๊ตฌ์ฑํ๋ค.
์ฝ๋
package ์ฌ์ฑํ.์๊ณ ๋ฆฌ์ฆ_6์ฃผ์ฐจ;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class ๋๊ฐ๋ฝ์์๋ํ๊ธฐ_ํ๋ก๊ทธ๋๋จธ์ค {
public static void main(String[] args) {
int[] arr = { 5, 0, 2, 7 };
int[] answer = solution(arr);
for (int i = 0; i < answer.length; i++) {
System.out.print(answer[i] + " ");
}
}
public static int[] solution(int[] numbers) {
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < numbers.length - 1; i++) {
int x = numbers[i];
for (int k = i + 1; k < numbers.length; k++) {
int y = numbers[k];
set.add(x + y);
}
}
Iterator<Integer> iter = set.iterator();
int[] answer = new int[set.size()];
int cnt = 0;
while (iter.hasNext()) {
answer[cnt] = iter.next();
cnt++;
}
for (int i = 0; i < answer.length - 1; i++) {
int tmp = answer[i];
for(int k = i + 1; k < answer.length; k++) {
if(tmp > answer[k]) {
answer[i] = answer[k];
answer[k] = tmp;
tmp = answer[i];
}
}
}
return answer;
}
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค | ์ฒด์ก๋ณต, ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ (2) | 2020.12.12 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค | ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์, Stack (0) | 2020.12.11 |
Cos Pro 1๊ธ | ๋น์์ด ์ด๋ ๊ฐ๋ฅํ ์นธ ๊ฐ์ ์ฐพ๊ธฐ (0) | 2020.12.10 |
Cos Pro 1๊ธ | ๋ฌธ์์ด ํฉ์ฑํ๊ธฐ, ์์ ํ์ (0) | 2020.12.10 |
Cos Pro 1๊ธ | ๋๋ฅด์์์ฆ ์ (0) | 2020.12.10 |