1. 모의고사

해결방법
1. personList 메소드를 만든다
- 주어진 답 만큼 person1, person2, person3의 답을 만들고 정답과 비교 후 answer(Integer) 리턴
2. 리턴된 answer를 map에 넣어줌
3. Map을 value 기준으로 오름차순 정렬
4. 최대값을 구하고 만약 최대값 보다 크다면 계속 진행, 작다면 break
5. 출력

import java.util.*;
class Solution {
    static int size;
    
    public int[] solution(int[] answers) {

        
        size=answers.length;
        Map<Integer,Integer>map=new HashMap<>();
        
        int[]person1={1,2,3,4,5};
        int[]person2={2,1,2,3,2,4,2,5};
        int[]person3={3,3,1,1,2,2,4,4,5,5};
    
        // 1. personList -> 푼 문제 수에 대하여 answer 개수를 출력
        map.put(1,personList(person1,answers));
        map.put(2,personList(person2,answers));
        map.put(3,personList(person3,answers));
        // System.out.println(map.toString());
        // 출력 : {3=0, 2=0, 1=5}
        
        // 2. value 기준으로 오름차순 정렬
        ArrayList<Integer>keyList=new ArrayList<>(map.keySet());
        Collections.sort(keyList,(o1,o2)->map.get(o2).compareTo(map.get(o1)));
        // System.out.println(keyList);
        
        // 3. 만약 동일한다면 다음것도 포함
        ArrayList<Integer>answersList=new ArrayList<>();
        int maxValue=map.get(keyList.get(0));
        answersList.add(keyList.get(0));
        
        for (int i=1;i<keyList.size();i++) {
            if (maxValue==map.get(keyList.get(i))) {
                answersList.add(keyList.get(i));
            }else {
                break;
            }
        }
        
        // 4. 출력
        int[] answer = new int[answersList.size()];
        for (int i=0;i<answersList.size();i++) {
            answer[i]=answersList.get(i);
        }
        
        return answer;
    }
    
    // personList -> arraylist로 만들고, 정답과 비교하여 정답 개수를 return
    public int personList(int[]person,int []answers) {
        int div=size/person.length;
        ArrayList<Integer>arraylist=new ArrayList<>();
        for (int k=0;k<div;k++) {
            for (int j=0;j<person.length;j++) {
                arraylist.add(person[j]);  
            }
        }
        int mod=size%person.length;
        if (mod>0) {
            for (int p=0;p<mod;p++) {
                  arraylist.add(person[p]); 
                }
        }
        
        int answer=0;
        for (int i=0;i<answers.length;i++) {
            if (arraylist.get(i)==answers[i]) {
                answer++;
            }
        }
        
        return answer;
    }
    
}

2. 소수찾기

해결방법

• DFS를 이용하여 순열찾는 문제

1. isPrime메소드를 만든다 -> 소수인지 판별하는 메소드
2. 순열에 필요한 변수를 static로 만든다

   static int n; // n개 (전체 갯수) // 17 이면 -> "1","7" -> 2개
   static int numArray[]; // 문제를 담을 공간 (n개) "1","7"을 담을 배열
   static int check[]; // 썻던것을 다시 안쓰기 위해 사용
   static int answers[]; // 정답을 담을 공간
   static HashSet<Integer> hashset; // 중복제거를 위해 사용

3. dfs를 돌면서 level 이 뽑을 갯수(m)에 도달하면 출력하고 해당 수를 hashset에 저장
4. 저장된 hashset을 이용하여 isPrime메소드로 개수를 센다

import java.util.*;
class Solution {
    static int n; // n개 (전체 갯수) // 17 이면 -> "1","7" -> 2개
    static int numArray[]; // 문제를 담을 공간 (n개) "1","7"을 담을 배열
    
    static int check[]; // 썻던것을 다시 안쓰기 위해 사용
    static int answers[]; // 정답을 담을 공간
    static HashSet<Integer> hashset; // 중복제거를 위해 사용
    
    public void dfs(int l,int m) {
        if (l==m) {
            // 출력
            String num="";
            for (int i=0;i<m;i++) {
                num+=answers[i];
            }
            // System.out.println(num); //1,7,17,71 
            int number=Integer.parseInt(num);
            hashset.add(number);
            
        }
        else {
            for (int i=0;i<n;i++) {
                if (check[i]==0) {
                    check[i]=1;
                    answers[l]=numArray[i];
                    dfs(l+1,m);
                    check[i]=0;
                }
            }
        }
    }
    
    public int solution(String numbers) {
        int answer = 0;
        
        String []array=numbers.split("");
        hashset=new HashSet<>();
        n=array.length; // 전체 갯수
        answers=new int[n];
        numArray=new int[n];
        check=new int[n];
     
        for (int i=0;i<array.length;i++) {
            numArray[i]=Integer.parseInt(array[i]);
        }
        
        for (int m=1;m<=n;m++) { // m은 뽑은 개수 (1자리, 2자리 ... n자리까지)
            dfs(0,m);
        }
        
        // System.out.println(hashset.toString());
        for (int i:hashset) {
            if (isPrime(i)) answer++;
        }
        
        return answer;
    }
    
    // 소수인지 판별하는 메소드
    public boolean isPrime(int num) {
        boolean answer=true;
        
        if (num<2) return false;
        
        for (int i=2;i<num;i++) {
            if (num%i==0) {
                answer=false; 
            }
        }
        
        return answer;
    }

}

3. 카펫

• 문제해결
  - 전체 범위를 고려해서 문제를 풀 수 있는가?!
  - 2차 방정식 식을 세우기
  - brown 식 : xy-{(x-2)(y-2)}=brown (전체 사각형에서 - yellow 사각형 빼기)
  - yellow 식 : (x-2)(y-2)=yellow
  - 범위를 고려해서 x,y 찾기
  - 이때 추가

• 추가 고려사항은 -> x>=y이기 때문에 y부터 찾고 -> x를 검색

import java.util.*;
class Solution {
    public int[] solution(int brown, int yellow) {
        int xx=0;
        int yy=0;
        for (int y=1;y<=5000;y++) { // x>=y이기 때문에 y부터 시작 
            boolean check=false;
            for (int x=y;x<=5000;x++) {
                int temp_brown=2*(x+y-2);
                int temp_yellow=(x-2)*(y-2);
                if (temp_brown==brown && temp_yellow==yellow) {
                    xx=x;
                    yy=y;
                    check=true;
                    break;
                }
            }
            
            if (check) {
                break;
            }
        }
        int[] answer = {xx,yy};
        // System.out.println("xx"+xx);
        // System.out.println("yy"+yy);
        
        
        return answer;
    }
}