BLOG :||

import java.util.*;
class Solution {
    public int[] solution(int brown, int yellow) {
        int[] answer = new int[2];

        int x;
        int y;
        for(int i = 1; i<=yellow;++i) {
            if(yellow % i == 0) {
                x = i;
                y = yellow / i;
                if(x == y) {
                    return new int[]{x+2,x+2};
                }
                if((x+y)*2+4 == brown) {
                    if(x < y) {
                        int tmp = y;
                        y = x;
                        x = tmp;
                    }
                    return new int[]{x+2,y+2};
                }
            }
        }
        return answer;
    }
}

yellow와 brown의 개수에 대한 공식을 알면 문제를 어렵지 않게 풀 수 있다.

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        int[] answer = {};
        int[] first = {1,2,3,4,5};
        int[] second = {1,3,4,5};
        int[] third = {3,1,2,4,5};
        int[] uAnswer = new int[3];
        //1,2,3,4,5,1,2,3,4,5,1,2,3,4,5
        //1는 (answer % 5 == 0) ? 5 : answer % 5;
        //(answer % 2 == 1) ? 2 : (answer / 2) % 4;
        //1,3,4,5,1,3,4,5
        //2,1,2,3,2,4,2,5,2,1,2,3,2,4,2,5
        //33,11,22,44,55
        //
        for(int i = 0; i<answers.length;++i) {
            
            int f = first[i%5];
            int s = (i%2 == 0) ? 2 : second[(i/2)%4];
            int t = third[(i/2)%5];
            if(f == answers[i])
                uAnswer[0]++;
            if(s == answers[i])
                uAnswer[1]++;
            if(t == answers[i])
                uAnswer[2]++;
        }
        int max = -1;
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i<uAnswer.length;++i) {
            if(uAnswer[i] > max)
                max = uAnswer[i];
        }
        for(int i = 0; i<uAnswer.length;++i) {
            if(uAnswer[i] == max)
                list.add(i+1);
        }
        answer = new int[list.size()];
        for(int i = 0; i<list.size();++i)
            answer[i] = list.get(i);
        return answer;
    }
}

찍는 방법의 규칙성만 찾아내면 되는 문제

import java.util.*;
public class main {
    public static void main(String[] args) {

        Solution s = new Solution();

        System.out.println(Arrays.toString(s.Chap4Example01(5, new String[]{"R","R","R","U","D","D"})));
        //Guide 생략
        System.out.println(s.Chap4Example02Guide(5));
        //규칙성 찾지 말고 그냥 완전탐색을 쓰라고 한다. 10만건 이하의 건이기 때문에 시간이 더 늘어날 일이 없으므로..
        //애초에 hour + minute + second 에서 "24"의 contains을 확인할 때, 024011과 같은 경우처럼 hour과 minute가 붙어있어야 확인이 되는 경우도 있으므로...
        System.out.println(s.Chap4Example03("a1"));
        System.out.println(s.Chap4Example03Guide("a1"));
        //조건을 확인하고 count를 하는 과정은 조건문이 너무 많이 사용되니 일단 값을 계산하고 한번에 조건을 확인한다.
        System.out.println(s.Chap4Example04(4,4,new int[]{1,1,0},new int[][]{{1,1,1,1},{1,0,0,1},{1,1,0,1},{1,1,1,1}}));
        //Guide 생략

    }
}
class Solution {
    public int[] Chap4Example01(int n, String[] moves){
        int[] pos = new int[2];
        //y, x로 가정 좌상이 0,0

        for(String s : moves) {
            switch (s) {
                case "R":
                    if(pos[1]+1 < n)
                        pos[1]++;
                    break;
                case "L":
                    if(pos[1]-1>-1)
                        pos[1]--;
                    break;
                case "U":
                    if(pos[0]-1> -1)
                        pos[0]--;
                    break;
                case "D":
                    if(pos[0]+1 < n)
                        pos[0]++;
                    break;
            }
        }
        pos[0]++;
        pos[1]++;
        return pos;
    }
    public int Chap4Example02(int n) {
        int answer = 0;
        //n이 포함되는 모든 시간 체크
        //nn:nn:nn
        //n~~~~~~~규칙성은 없을까..?
        //


        return answer;
    }
    public int Chap4Example02Guide(int n) {
        //000000~235959까지 경우의 수가 10만개가 되지 않으므로 완전탐색 하는게 낫다고 한다..
        int answer = 0;
        for(int i = 0; i<n+1;++i) {
            for(int j = 0; j<60;++j) {
                for(int k = 0; k<60;++k) {
                    String s = Integer.toString(i)+Integer.toString(j)+Integer.toString(k);
                    if(s.contains("3")) {
                        answer++;
                    }
                }
            }
        }
        return answer;
    }
    public int Chap4Example03(String pos) {
        int answer = 0;

        String[] xyPos = pos.split("");
        //'a' = 97 then 'a'-96 = 1
        int x = (int)xyPos[0].charAt(0)-(int)'a'+1;
        int y = Integer.parseInt(xyPos[1]);
        if(x > 2) {
            if(y > 1) {
                answer++;
            }
            if(y < 8) {
                answer++;
            }
        }
        if(x < 6) {
            if(y > 1) {
                answer++;
            }
            if(y < 8) {
                answer++;
            }
        }
        if(y > 2) {
            if(x > 1) {
                answer++;
            }
            if(x < 8) {
                answer++;
            }
        }
        if(y < 6) {
            if(x > 1) {
                answer++;
            }
            if(x < 8) {
                answer++;
            }
        }
        return answer;
    }
    public int Chap4Example03Guide(String pos) {
        int answer = 0;

        String[] xyPos = pos.split("");
        //'a' = 97 then 'a'-96 = 1
        int x = (int)xyPos[0].charAt(0)-(int)'a'+1;
        int y = Integer.parseInt(xyPos[1]);
        int[][] steps = new int[][]{{-2, -1}, {-1, -2}, {1, -2}, {2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}};

        for(int[] step : steps) {
            int nX = x+step[0];
            int nY = y+step[1];
            if(nX >= 1 && nX <= 8 && nY >= 1 && nY <= 8) {
                answer++;
            }
        }
        return answer;
    }
    public int Chap4Example04(int m, int n, int[] character, int[][] map) {
        int answer = 0;
        int[][] visited = new int[n][m];//m: x, n: y

        visited[character[0]][character[1]] = 1;//0: x, 1: y
        answer++;
        int notMoveCount = 0;
        int[][] move = new int[][]{{-1,0}, {0,-1}, {1,0}, {0,1}};
        while(true) {
            character[2] = (character[2]-1 < 0) ? 3 : character[2]-1;
            int tmpX = character[1]+move[character[2]][1];
            int tmpY = character[0]+move[character[2]][0];
            if(tmpX >= 0 && tmpY >= 0 && tmpX < m && tmpY < n && visited[tmpY][tmpX] == 0 && map[tmpY][tmpX] == 0) {
                character[1] = tmpX;
                character[0] = tmpY;
                answer++;
                visited[tmpY][tmpX] = 1;

            }
            else {
                notMoveCount++;
                if(notMoveCount == 4) {
                    notMoveCount = 0;
                    int nextMove = (character[2] + 2) % 4;
                    tmpX = character[1]+move[nextMove][1];
                    tmpY = character[0]+move[nextMove][0];

                    if(tmpX < 0 || tmpY < 0 || tmpX >= m && tmpY >= n || map[tmpY][tmpX] == 1)
                        break;

                    character[0] = tmpY;
                    character[1] = tmpX;
                }
            }
        }
        return answer;
    }
}

완전탐색 문제들이라고 봐야 하나