뒤집은 소수

public class C18 {
	public static void solution(int num[]) {
		for(int i=0;i<num.length;i++) {
			if(isPrime(num[i])) {
				System.out.print(Integer.parseInt(new StringBuilder(String.valueOf(num[i])).reverse()+"")+" ");
			}
		}
	}
	
	public static boolean isPrime(int n) {
		boolean p = true;
		String str = new StringBuilder(String.valueOf(n)).reverse()+"";
		n = Integer.parseInt(str);
		if(n==1) p=false;
		for(int i=2;i<n;i++) {
			if(n%i==0) { 
				p=false;
				break;
			}
		}
		
		return p;
	}	
    
    public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int num[] = new int[n];
		for(int i=0;i<n;i++) {
			num[i] = sc.nextInt();
		}
		solution(num);
		sc.close();
	}
}

처음 문제 풀이

1. 값을 배열로 받아서 solution이라는 메서드에 넘긴다.

2. solution은 소수인지 아닌지 판단하기 위해 isPrime이라는 메서드에 정수를 넘긴다.

3. 정수를 문자로 바꾸고, 문자를 뒤집는다.

4. 뒤집은 문자를 정수로 변환하고 정수가 1이면 false를 리턴한다.

5. 반복문을 돌면서 i로 나눠지면 소수가 아니다. false 리턴

6. 나눠지지 않았으면 그냥 true를 리턴한다.

7. true인 값들을 다시 뒤집어 출력한다.

 

public ArrayList<Integer> solution(int n, int[]arr){
		ArrayList<Integer> answer = new ArrayList<Integer>();
		for(int i=0;i<n;i++) {
			int tmp = arr[i];
			int res = 0;
			while(tmp>0) {
				int t = tmp%10;
				res = res * 10 + t;
				tmp = tmp/10;
			} // 거꾸로 하는 로직
			if(isPrime(res)) answer.add(res);
		}
		
		return answer;
	}
	
	public boolean isPrime(int num) {
		if(num==1) return false;
		for(int i=2;i<num;i++) {
			if(num%i==0) return false;
		}
		return true;
	}

두번째 풀이

1. 정수와 배열을 매개변수로 받고 ArrayList 객체를 생성한다.

2. 반복문을 돌면서 tmp, res를 선언 tmp에는 배열[i]의 값을 넣어준다.

3. res는 뒤집으려는 수가 들어갈 것이다.

4. while문 tmp가 0보다 클 때 

뒤의 한 자리만 추출: 정수%10 

뒤집는 수(res) = res*10 + 뒤의 한자리

뒤의 한 자리 삭제하기 : 정수/10

반복하면서 res에는 뒤집어진 정수가 들어가게 된다.

 

5. isPrime에 정수를 넘기고 정수가 1이면 소수가 아니기에 false를 리턴한다.

6. 만약 num이 i로 나눠지면 false를 리턴한다. 

 

7. 이미 뒤집어진 res를 ArrayList에 add 시킨다.