잡다한 배똥월드

class Solution {
    public String solution(int[] numbers, String hand) {
        StringBuilder answer = new StringBuilder();
        String[] keypad = {"l", "m", "r", "l", "m", "r", "l", "m", "r", "l", "m", "r"};
        
        int left = 9;
        int right = 11;
        
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == 0) {
                numbers[i] = 10;
            } else {
                numbers[i]--;
            }
        }
                           
        for (int i = 0; i < numbers.length; i++) {
            int num = numbers[i];
            if (keypad[num].equals("l")) {
                left = num;
                answer.append("L");
            } else if (keypad[num].equals("r")) {
                right = num;
                answer.append("R");
            } else {
                int temp = func(num, left, right);
                if (temp == 1) {
                    left = num;
                    answer.append("L");
                } else if (temp == -1) {
                    right = num;
                    answer.append("R");
                } else {
                    if (hand.equals("left")) {
                        left = num;
                        answer.append("L");
                    } else {
                        right = num;
                        answer.append("R");
                    }
                }
            }
        }
        
        return answer.toString();
    }
    
    public int func(int number, int left, int right) {
        int num = number;
        
        int l1 = (left) / 3;
        int m1 = (num) / 3;
        int r1 = (right) / 3;
        
        int l2 = (left) % 3;
        int m2 = (num) % 3;
        int r2 = (right) % 3;
        
        double lFar = Math.abs(l1 - m1) + Math.abs(l2 - m2);
        double rFar = Math.abs(r1 - m1) + Math.abs(r2 - m2);
        
        if (lFar < rFar) {
            return 1;
        } else if (lFar > rFar) {
            return -1;
        } else {
            return 0;
        }
    }
}

도움을 받은 부분은 키패드의 거리 구할 때 유클리드 거리로 구했는데, 맨하탄 거리로 구해야 한다는 것을 알게 되었다..

좌표를 만들기 위해서 키패드 숫자에서 1씩 빼고, *은 9, 0은 10, #은 11로 만들어서 아래와 같은 표로 표현할 수 있다.

그래서 각각의 위치에 좌표를 구한다면 아래의 표와 같이 표현할 수 있는데,

x 좌표는 해당 위치의 숫자를 3으로 나눈 몫이고, y 좌표는 해당 위치의 숫자를 3으로 나눈 나머지이다.

그래서 좌표 (x1, y1), (x2, y2)의 맨하탄 거리를 구한다면 |x1 - x2| + |y1 - y2|이다.

처음엔 유클리드 거리로 해서 (x1-x2)^2 + (y1-y2)^2 로 했는데,

이렇게 하니까 테스트 13부터는 계속 오답이라고 떴다.

import java.util.*;

class Solution {
    public String solution(int[] numbers, String hand) {
        boolean value = true;
        int l = 10;
        int r = 12;
        
        if (hand.equals("right")){
            value = false;
        }
        
        ArrayList<String> data = new ArrayList<>();
        
        for (int i = 0; i < numbers.length; i++){
            int a = numbers[i];
            
            if (a == 0) a = 11;
            
            boolean value2 = true;
            
            if (a == 1 || a == 4 || a == 7){
                value2 = true;
            } else if (a == 3 || a == 6 || a == 9){
                value2 = false;
            } else {
                int ll = 0;
                int rr = 0;
                int l2 = l;
                int r2 = r;
                
                while (l2 != a){
                    if (l2 - a == -1 || l2 - a == 1){
                        ll++;
                        break;
                    }
                    
                    if (l2 > a){
                        l2 -= 3;
                        ll++;
                    } else {
                        l2 += 3;
                        ll++;
                    }
                }
                
                while (r2 != a){
                    if (r2 - a == -1 || r2 - a == 1){
                        rr++;
                        break;
                    }
                    
                    if (r2 > a){
                        r2 -= 3;
                        rr++;
                    } else {
                        r2 += 3;
                        rr++;
                    } 
                }
                
                if (ll > rr) {
                    value2 = false;
                } else if (ll < rr){
                    value2 = true;
                } else {
                    value2 = value;
                }
            }
            
            if (value2){
                data.add("L");
                l = a;
            } else {
                data.add("R");
                r = a;
            }
            
        }
        
        return String.join("", data);
    }
}

class Solution {
    public int solution(String s) {
        String[] word = {"zero", "one", "two", "three", "four", "five",
                        "six", "seven", "eight", "nine"};
        int answer = 0;
        String q = s;
        
        while (q.length() > 0) {
            String t = q.substring(0, 1);
            char temp = t.charAt(0);
            
            if (temp >= '0' && temp <= '9') {
                answer = answer * 10 + Integer.parseInt(t);
                q = q.substring(1, q.length());
                continue;
            }
            
            for (int j = 0; j < word.length; j++) {
                if (q.indexOf(word[j]) == 0) {
                    answer = answer * 10 + j;
                    q = q.substring(word[j].length(), q.length());
                    break;
                }
            }
            
        }
        return answer;
    }
}

음.. 일단 글자가 숫자인지를 먼저 파악하기 위해서 제일 앞 글자를 char로 바꿔서 숫자인지 파악한다.

answer에 숫자를 더하는 것은 한 번 할 때마다 자리수가 바뀌기 때문에 10을 곱한 후에 더해주는 식으로 진행하며

만약에 숫자가 아닐 경우에는 이제 String 배열에 만들어 놓은 숫자 영단어를 하나씩 비교해 가면서

해당하는 영단어가 제일 앞에서 시작되는지 안되는지를 파악하여 만들었다.

뭔가 설명이 이상하지만... 설명할 수 있는 방법이 없눼...

import java.util.*;

class Solution {
    public String[] solution(String[] record) {
        ArrayList<String> answer = new ArrayList<>();
        
        String[][] list = new String[record.length][2];
        HashMap<String, String> name = new HashMap<>();
        
        for (int i = 0; i < record.length; i++) {
            String[] re = record[i].split(" ");
            
            list[i][0] = re[0];
            list[i][1] = re[1];
            
            if (re[0].equals("Enter") || re[0].equals("Change")) {
                name.put(re[1], re[2]);
            } 
        }
        
        for (int i = 0; i < list.length; i++) {
            if (list[i][0].equals("Enter")) {
                answer.add(name.get(list[i][1]) + "님이 들어왔습니다.");
            } else if (list[i][0].equals("Leave")){
                answer.add(name.get(list[i][1]) + "님이 나갔습니다.");
            }
        }
        
        return answer.toArray(new String[answer.size()]);
    }
}

유저 ID는 그대로인데 이름은 변경할 수 있다.

그래서 for문으로 record를 순회할건데, 이 때 record[i]의 내용이 Enter이나 Change이면 이름을 변경될 수 있다.

그래서 유저ID에 맞게 이름을 넣기 위해서 해시맵을 사용하였고,

Enter이나 Change면 이름이 같든 다르든 그냥 변경하도록 했다.

그리고 나서 할 것이 들어왔다 나갔다 하는 문구를 적을 차례인데,

Enter면 들어왔다고, Leave면 나갔다고 문구를 적고 Change는 그냥 넘어가는 식으로 작성하였다.

import java.util.*;

class Solution {
    public String[] solution(String[] record) {
        
        HashMap<String, String> name = new HashMap<>();
        ArrayList<String> data = new ArrayList<>();
        
        for (int i = 0; i < record.length; i++){
            String[] temp = record[i].split(" ");
            
            if (temp[0].equals("Leave")){
                data.add(record[i]);
                continue;
            }
            
            if (temp[0].equals("Enter")){
                data.add(record[i]);
                name.put(temp[1], temp[2]);
                continue;
            }
            
            if (temp[0].equals("Change")){
                name.put(temp[1], temp[2]);
            }
        }
        
        String[] answer = new String[data.size()];
        
        for (int i = 0; i < data.size(); i++){
            String[] temp = data.get(i).split(" ");
            
            String st = name.get(temp[1]);
            
            StringBuilder sb = new StringBuilder(st);
            
            if (temp[0].equals("Enter")){
                sb.append("님이 들어왔습니다.");
            } else if (temp[0].equals("Leave")){
                sb.append("님이 나갔습니다.");
            }
            
            answer[i] = sb.toString();
        }
        
        return answer;
    }
}

import java.util.*;

class Solution {
    int answer = 0;
    public int solution(String s) {
        answer = s.length();
        for (int i = 1; i < s.length(); i++) {
            func(s, i);
        }
        
        return answer;
    }
    
    public void func(String s, int cut) {
        int position = 0;
        ArrayList<String> arr = new ArrayList<>();        
        
        // if (s.length() % cut != 0) return;
        
        while (position < s.length()) {
            int temp = (position+cut <= s.length()) ? position+cut : s.length();
            arr.add(s.substring(position, temp));
            position += cut;
        }
        
        String word = arr.get(0);
        StringBuilder sb = new StringBuilder();
        int number = 1;
        
        for (int i = 1; i < arr.size(); i++) {
            String temp = arr.get(i);
            
            if (temp.equals(word)) {
                number++;
            } else {
                if (number != 1) sb.append(number);
                
                sb.append(word);
                
                number = 1;
                word = temp;
            }
        }
        
        if (number != 1) sb.append(number);
        sb.append(word);
        
        // System.out.println(sb.toString() + ", " + sb.length());
        answer = Math.min(answer, sb.length());
        
    }
}

글자 자르는 것은 1글자부터 주어진 글자 s의 길이까지 1글자씩 늘려가면서 자르도록 for문으로 func함수를 호출.

그래서 substring()으로 글자를 잘라서 ArrayList에 넣고

앞에서부터 글자가 같은지 아닌지를 구분하고 같으면

만약에 글자가 같으면 같은 글자 개수 세는 것 (변수명 : number)에 +1,

다르면 StringBuilder에 number이랑 글자 추가 후 초기화.

그리고 for문이 끝나면 StringBuilder 길이랑 answer 길이 비교해서 작은 것 리턴으로 끝..

뭔가 예전엔 엄청 복잡하게 한 것 같은데.. 이번엔 비교적 쉽게 푼 것 같다.

class Solution {
    public int solution(String s) {
        int answer = Integer.MAX_VALUE;
        
        for (int i = 1; i <= s.length() / 2; i++){
            int num = 1;
            
            int a = 0;
            if (s.length() % i != 0) a = 1;
            
            String[] data = new String[(s.length() / i) + a];
            
            for (int j = 0; j < data.length; j++){
                int start = j * i;
                int end = (j + 1) * i;
                
                if (end > s.length()) end = s.length();
                data[j] = s.substring(start, end);
            }
        
            int size = 0;
            for (int j = 0; j < data.length - 1; j++){
                String first = data[j];
                String second = data[j + 1];
                
                if (first.equals(second)){
                    num++;
                } else {
                    if (num == 1){
                        size += first.length();
                    } else {
                        size += first.length() + Integer.toString(num).length();
                    }
                    
                    num = 1;
                }
            }
            
            if (num == 1){
                size += data[data.length - 1].length();
            } else {
                size += data[data.length - 1].length() + Integer.toString(num).length();
            }            
            answer = Math.min(answer, size);
        }
        
        if (s.length() == 1){
            answer = 1;
        }
        
        return answer;
    }
}

import java.util.*;

class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {
        int[] answer = new int[2];
        int result = 0;
        int zero = 0;
        for (int i = 0; i < lottos.length; i++) {
            if (lottos[i] != 0) {
                for (int j = 0; j < win_nums.length; j++) {
                    if (lottos[i] == win_nums[j]) {
                        result++;
                        break;
                    }
                }
            } else {
                zero++;
            }
        }        
        
        answer[0] = (result + zero == 0) ? 6 : 6 - (result + zero) + 1;
        answer[1] = (result == 0) ? 6 : 6 - result + 1;

        return answer;
    }
}

두번째 푸는 문제인데, 처음 풀었을 때의 코드가 더 깔끔한 것 같다..

일단 lottos에 0이 몇 개인지, win_nums와 같은 숫자가 몇 개인지 파악했고,

그걸 기준으로 순위를 계산했습니다.

이 문제를 풀면서 알게 된 점은 

int[] 즉, int 배열은 indexOf나 contains를 지원하지 않는다는 점이었다..!!!

그래서 for문으로 숫자가 있는지 없는지를 파악했는데, 그냥 ArrayList로 변환 후에 풀껄 그랬나.. 생각도 했다..

class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {

        int bingo = 0;
        int lose = 0;

        for (int i = 0; i < lottos.length; i++) {
            if (lottos[i] != 0) {
                for (int j = 0; j < win_nums.length; j++) {
                    if (lottos[i] == win_nums[j]) {
                        bingo++;
                        break;
                    }
                }
            } else {
                lose++;
            }
        }

        int[] data = new int[]{6, 6, 5, 4, 3, 2, 1};

        return new int[]{data[bingo + lose], data[bingo]};
    }
}

.

.

.

import java.util.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        int[] answer = new int[id_list.length];
        
        //유저 - 유저가 신고한 사람
        HashMap<String, ArrayList<String>> arr1 = new HashMap<>();

        //유저 - 유저를 신고한 사람
        HashMap<String, ArrayList<String>> arr2 = new HashMap<>();
        HashMap<String, Integer> arr3 = new HashMap<>();
        
        for (int i = 0; i < report.length; i++) {
            String[] temp = report[i].split(" ");
            
            ArrayList<String> list1 = arr1.getOrDefault(temp[0], new ArrayList<>());
            ArrayList<String> list2 = arr2.getOrDefault(temp[1], new ArrayList<>());
            
            if (list1.indexOf(temp[1]) == -1) {
                list1.add(temp[1]);
            }
            
            if (list2.indexOf(temp[0]) == -1) {
                list2.add(temp[0]);
            }
            
            arr1.put(temp[0], list1);
            arr2.put(temp[1], list2);
        }
        
        for (int i = 0; i < id_list.length; i++) {
            ArrayList<String> temp = arr2.getOrDefault(id_list[i], new ArrayList<>());
            arr3.put(id_list[i], temp.size());
        }
        
        for (int i = 0; i < id_list.length; i++) {
            ArrayList<String> temp = arr1.getOrDefault(id_list[i], new ArrayList<>());
            
            for (int j = 0; j < temp.size(); j++) {
                if (arr3.getOrDefault(temp.get(j), 0) >= k) {
                    answer[i]++;
                }
            }
        }
        
        return answer;
    }
}

해시맵 arr1은 유저가 신고한 유저 리스트

해시맵 arr2는 해당 유저를 신고한 유저 리스트

해시맵 arr3은 해당 유저가 신고당한 수 (배열로 대체 가능할 것 같음)

그래서 report 대로 for문을 돌려서 arr1과 arr2를 채워나갑니다.

만약에 중복이라면 추가하지 않고, 중복이 아니라면 추가하는 식으로...

그리고 나서 arr3을 채우는데 이건 id_list로 for문을 돌린다.

id_list에서 하나씩 꺼내서 arr1의 해당 유저가 신고한 리스트를 가져오고

리스트의 유저들이 몇 번 신고를 당했는지 파악하기 위해 arr3에서 값 가져와서

만약에 k값보다 크거나 같으면 answer++, 아니면 그냥 넘어가는 식으로 작성 후 answer 리턴

N×N 크기의 격자판이 있다. 각각의 격자는 비어 있거나(‘.’), 막혀 있다(‘#’). 이때, 막혀 있는 칸들이 하나의 정사각형을 이루는지를 판단하는 프로그램을 작성하라.

[입력]
첫 번째 줄에 테스트 케이스의 수 T가 주어진다.
각 테스트 케이스의 첫 번째 줄에는 격자판의 크기 N (1≤N≤20 이 주어진다. 다음 N개의 줄은 격자판의 배치를 나타내며, 각 줄에는 ‘.’ 또는 ‘#’로만 이루어진 길이가 N인 문자열이 주어진다. 모든 격자판에는 최소 1개 이상의 ‘#’ 칸이 있음이 보장된다.

[출력]
각 테스트 케이스마다 격자판의 막혀 있는 칸들이 하나의 정사각형을 이루면 ‘yes’를, 그렇지 않다면 ‘no’를 출력한다.

작성 코드

import java.util.*;
import java.io.*;

class Solution {
	public static void main(String args[]) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
		int T = Integer.parseInt(br.readLine());
        
		for(int test_case = 1; test_case <= T; test_case++) {
			int n = Integer.parseInt(br.readLine());
            
            String[][] map = new String[n][n];
            int firstR = -1;
            int firstC = -1;
            int count = 0;
            String answer = "yes";
            
            for (int i = 0; i < n; i++) {
            	String s = br.readLine();
                String[] arr = s.split("");
                
                map[i] = Arrays.copyOf(arr, arr.length);
                count += s.replace(".", "").length();
                
                if (firstR == -1 && firstC == -1 && s.indexOf("#") != -1) {
                	firstR = i;
                    firstC = s.indexOf("#");
                }
            }
            
            int size = 0;
            
            for (int i = 1; i <= n; i++) {
            	if (i * i == count) {
                    size = i;
                    break;
                }
            }
            
            if (size == 0 || firstR + size > n || firstC + size > n) {
                System.out.printf("#%d %s%n", test_case, "no");
                continue;
            }
            
            loop:
            for (int i = firstR; i < firstR + size; i++) {
                for (int j = firstC; j < firstC + size; j++) {
                    if (!map[i][j].equals("#")) {
                        answer = "no";
                        break loop;
                    }
                }
            }
            
            System.out.printf("#%d %s%n", test_case, answer);
		}
	}
}

어차피 #들이 다 붙어있어야 하기 때문에 처음 시작하는 행, 열 좌표를 구했고,

아래의 경우를 예를 들면 가로 세로 길이를 구할 땐 2로 나올 것이다.

근데 첫 시작 지점이 (0, 2)이기 때문에 범위 오류가 나기 때문에

만약에 첫 시작 지점에서 가로 세로로 갈 수 없으면 그냥 no 리턴.

모양에 대해서는 여러 경우의 수가 있기 때문에

다양한 모양을 생각해서 코드를 짜야만 했다.

풀고 난 지금에서야 코드를 보면 간단하다고 생각이 들지만

경우의 수를 생각하는 게 조금 어려웠다....

거즘 4번만에 통과한...

import java.io.*;
import java.util.*;

public class Main {
	
	static int answer;
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		int n = Integer.parseInt(br.readLine());
		
		for (int i = 0; i < n; i++) {
			int num = Integer.parseInt(br.readLine());
			answer = 0;
			
			func(num, 0);
			
			bw.write(answer + "\n");
		}
		
		bw.flush();
		bw.close();
		
	}
	
	public static void func(int num, int now) {
		if (num == now) {
			answer++;
			
			return;
		}
		
		if (num < now) return;
		
		int[] list = {1, 2, 3};
		
		for (int i = 0; i < list.length; i++) {
			func(num, now + list[i]);
		}
	}
}

1, 2, 3이 들어있는 배열 만들고, for문으로 돌리면서 함수를 호출하는데,

만약에 num보다 숫자가 커지면 그냥 리턴하고, 같으면 answer + 1, 작으면 다시 for문 돌리는 식으로 짬.