1. ๋ฌธ์ ์ค๋ช
[๋ฌธ์ ๋งํฌ](https://school.programmers.co.kr/learn/courses/30/lessons/12977?language=java)
์ฃผ์ด์ง ์ซ์ ์ค 3๊ฐ์ ์๋ฅผ ๋ํ์ ๋ ์์๊ฐ ๋๋ ๊ฒฝ์ฐ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ค๊ณ ํฉ๋๋ค. ์ซ์๋ค์ด ๋ค์ด์๋ ๋ฐฐ์ด nums๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, nums์ ์๋ ์ซ์๋ค ์ค ์๋ก ๋ค๋ฅธ 3๊ฐ๋ฅผ ๊ณจ๋ผ ๋ํ์ ๋ ์์๊ฐ ๋๋ ๊ฒฝ์ฐ์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- nums์ ๋ค์ด์๋ ์ซ์์ ๊ฐ์๋ 3๊ฐ ์ด์ 50๊ฐ ์ดํ์ ๋๋ค.
- nums์ ๊ฐ ์์๋ 1 ์ด์ 1,000 ์ดํ์ ์์ฐ์์ด๋ฉฐ, ์ค๋ณต๋ ์ซ์๊ฐ ๋ค์ด์์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
numsresult
[1,2,3,4] | 1 |
[1,2,7,6,4] | 4 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1 [1,2,4]๋ฅผ ์ด์ฉํด์ 7์ ๋ง๋ค ์ ์์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2 [1,2,4]๋ฅผ ์ด์ฉํด์ 7์ ๋ง๋ค ์ ์์ต๋๋ค. [1,4,6]์ ์ด์ฉํด์ 11์ ๋ง๋ค ์ ์์ต๋๋ค. [2,4,7]์ ์ด์ฉํด์ 13์ ๋ง๋ค ์ ์์ต๋๋ค. [4,6,7]์ ์ด์ฉํด์ 17์ ๋ง๋ค ์ ์์ต๋๋ค.
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ ํ ์คํธ ์ฐ์ต, https://school.programmers.co.kr/learn/challenges
2. ํ์ด ์ค๋ช
keyword
: ์กฐํฉ, ์์ ํ๋ณ
- ์กฐํฉ์ผ๋ก n๊ฐ์ ์ ์ค 3๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ๋ ํ๋ ์ํํ๋ค.
- ๊ฐ ๊ฒฝ์ฐ์ ์๋ง๋ค, ๊ธฐ์ ์กฐ๊ฑด์์ 3๊ฐ๋ฅผ ๋ ํ์ ๋, ์์์ธ์ง ํ๋ณ ํ๋ค.
3. ์ ์ถ ์ฝ๋
class Solution {
static int [] arr;
static boolean [] isVisited;
static int cnt = 0;
public int solution(int[] nums) {
arr = new int [nums.length];
isVisited = new boolean[nums.length];
for(int i = 0; i < arr.length; i++){
arr[i] = nums[i];
}
combination(0, 0);
return cnt;
}
public void combination(int depth, int start) {
if(depth == 3){
int v = 0;
// ์ ํ๋ ์๋ค์ ํฉํด์ ํ๋ณด ๊ฐ์ ๋ง๋ ๋ค.
for(int i = 0; i < isVisited.length; i ++){
if(isVisited[i]){
v += arr[i];
}
}
// ๋ง์ฝ ํ๋ณด๊ฐ์ด ์ ์ฒด์ ์ ๋ฐ์ ์ ์ค ํ๋๋ผ๋ ๋๋์ด ๋จ์ด์ง๋ฉด ์์๊ฐ ์๋๋ค.
for(int i = 0; i <= v/2; i ++){
if(i == 0 || i == 1) continue;
if(v%i == 0) {
return;
}
}
// ๊ทธ๋ ์ง ์๋ค๋ฉด ์์์์ผ๋ก ์์ ๊ฐ์๋ฅผ ํ๋ ์นด์ดํธ ํ๋ค.
cnt++;
return;
}
for(int i = start; i < arr.length; i++){
if(!isVisited[i]){
isVisited[i] = true;
combination(depth+1, i+1);
isVisited[i] = false;
}
}
}
}
4. ์ข์์๋ฅผ ๋ง์ด ๋ฐ์ ํ์ด
import java.util.Arrays;
class Solution {
public int solution(int[] nums) {
int ans = 0;
for(int i = 0; i < nums.length - 2; i ++){
for(int j = i + 1; j < nums.length - 1; j ++){
for(int k = j + 1; k < nums.length; k ++ ){
if(isPrime(nums[i] + nums[j] + nums[k])){
ans += 1;
}
}
}
}
return ans;
}
public Boolean isPrime(int num){
int cnt = 0;
for(int i = 1; i <= (int)Math.sqrt(num); i ++){
if(num % i == 0) cnt += 1;
}
return cnt == 1;
}
}
- 3์ค For ๋ฌธ์ผ๋ก ์กฐํฉ ๊ตฌํ i๊ฐ ์ ํํ ์ ๋ค์๋ถํฐ j๊ฐ ๊ณ ๋ฅด๋๋ก ํ๊ณ , j๊ฐ ๊ณ ๋ฅธ ๊ฒ ๋ค์๋ถํฐ k๊ฐ ๊ณ ๋ฅด๋๋ก ํด์, N๊ฐ ์ค 3๊ฐ๋ฅผ ์์ ์์ด ๊ณ ๋ฅด๋ ์กฐํฉ์ ๊ฐ๋จํ ๊ตฌํ โ n์ด 50๊ฐ ์ดํ์ฌ์, ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ฐ์ง ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ฐ์ธ ๊ฒ์ด๋ผ ์๊ฐํ๋ค. ์คํ๋ ค ๊ฐ๋ ์ฑ์ ์ข์ ๋ฏ
- ์์ ํ๋ณ ๋ ํด์ง ๊ฐ์ ๋ํ ์์ ํ๋ณ๋ก ๊ทธ ์์ ์ ๊ณฑ๊ทผ ๋ณด๋ค ์์ ์๋ค๋ก ํด๋น num์ด๋ ๋ํด์ง ์๊ฐ ๋๋์ด ์ง๋๊ฐ๋ฅผ ๊ณ์ฐํ๊ณ ์๋ค. ๋๋ ์ ๊ณฑ๊ทผ์ผ๋ก ๋๋์ง๊ฐ ๊ฐ๋ฌผ๊ฐ๋ฌผํด์ num/2๋ณด๋ค ์์ ์๋ค๋ก ๊ตฌํ๋ค. ์๋ผํ ์คํ ๋ค์ค์ ์ฒด ๋ค์ ๊ณต๋ถํด์ผ๊ฒ ๋ค.