잡다한 배똥월드

import java.util.*;
class Solution {
    public String solution(int[] numbers) {
        int check = 0;
        
        //문자열로 변경하면서 check에 모든 합 구하기
        String[] nString = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            nString[i] = Integer.toString(numbers[i]);
            check += numbers[i];
        }
        
        //합이 0이면 그냥 0 바로 리턴
        if (check == 0) return "0";
        
        //정렬
        //예를 들어서 n1 = 1, n2 = 123 일 때 n1+n2인 1123과 n2+n1인 1231을 비교해서
        //큰 숫자로 만들어지는 걸로 내림차순 정렬하기
        Arrays.sort(nString, new Comparator<String>(){
            @Override
            public int compare(String n1, String n2) {
                int s1 = Integer.parseInt(n1 + n2);
                int s2 = Integer.parseInt(n2 + n1);
                
                return s2 - s1;
            }
        });
        
        //구분자 ""로 합쳐서 리턴
        return String.join("", nString);
    }
}

import java.util.*;

class Solution {
    public int solution(int[][] jobs) {
        int answer = 0;
        
        //요청시간 순으로 정렬해놓은 큐
        PriorityQueue<Job> waiting = new PriorityQueue<>(new Comparator<Job>(){
            @Override
            public int compare(Job j1, Job j2) {
                return j1.start - j2.start;
            }
        });
        
        //작업시간 순으로 정렬할 큐
        PriorityQueue<Job> working = new PriorityQueue<>(new Comparator<Job>(){
            @Override
            public int compare(Job j1, Job j2) {
                return j1.work - j2.work;
            }
        });
        
        //waiting에 넣기
        for (int i = 0; i < jobs.length; i++) {
            waiting.offer(new Job(jobs[i][0], jobs[i][1]));
        }
        
        int count = 0; //몇 개 처리됬는지 파악할 변수
        int time = 0; //작업이 끝나는 시간을 담을 변수
        
        while (count < jobs.length) {
        	//waiting이 비어있지 않고, 작업이 끝나는 시간 이전에 요청이 들어온 것이 있다면
            //꺼내서 working에 넣기
        	while (!waiting.isEmpty() && time >= waiting.peek().start) {
                working.offer(waiting.poll());
            }
            
            //만약에 working이 비어있지 않으면
            if (!working.isEmpty()) {
            	//작업시간이 가장 짧은 즉, working 가장 처음에 있는 것을 꺼내서 계산하기
                //time은 작업이 끝나자마자 새로운 작업이 시작되기 때문에 해당 새로운 작업의 작업 시간 추가
                //answer은 총 시간이기 때문에 작업이 완전히 끝나는 시간부터 요청이 들어온 시간을 뺀 값을 추가하기
                //count는 작업 하나가 끝났기 때문에 1 더하기
                Job job = working.poll();
                time += job.work;
                answer += (time - job.start);
                count++;
            } else {
            //working이 비어있으면 time + 1
                time++;
            }
        }
        
        //총 시간에서 jobs의 갯수로 나눠서 리턴
        return answer / jobs.length;
    }
}

class Job {
    int start, work;
    public Job(int start, int work) {
        this.start = start;
        this.work = work;
    }
}

import java.util.*;
class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        
        //프린트 대기열을 표현하기 위해 큐 선언
        Queue<Integer> list = new LinkedList<>();
        
        //큐에 0부터 priorities 길이 - 1만큼 숫자를 넣음
        for (int i = 0; i < priorities.length; i++) {
            list.add(i);
        }
        
        //큐가 비워질 때까지 반복
        while (!list.isEmpty()) {
        
        	//제일 먼저 들어온 숫자 꺼내기
            int p = list.poll();
            
            //꺼낸 숫자의 우선순위 선언
            int num = priorities[p];
            
            //우선순위가 높은게 있는지 없는지 체크할 용도
            boolean value = false;
            
            //priorities를 하나씩 보면서 우선순위가 더 큰게 있는지 확인하기
            for (int i = 0; i < priorities.length; i++) {
                if (i == p) continue;
                if (priorities[i] > num) {
                    value = true;
                    break;
                }
            }
            
            //만약 우선순위가 높은게 없다면
            if (!value) {
                answer++; //answer은 몇 번째 순서로 꺼내진건지를 파악하는 것 그래서 1 추가
                priorities[p] = 0; //우선순위를 끝냈으니까 0으로 리셋
                if (location == p) break; //만약 location과 숫자가 동일하다면 while 종료
            } else {
                list.add(p); //우선순위가 높은게 있다면 그냥 다시 맨 뒤로 넣기
            }
        }
        
        return answer;
    }
}

import java.util.*;
class Solution {
    
    public boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);  //문자열을 정렬하면 사전순으로 정렬이 됨

		//i+1 위치의 문자가 i 위치의 문자로 시작하면 false 리턴
        for (int i = 0; i < phone_book.length - 1; i++) {
            if (phone_book[i+1].indexOf(phone_book[i]) == 0) return false;
        }
        
        //for문이 종료되면 그냥 true 리턴
        return true;
    }
}

엄청 간단한 문제였는데 해시 문제길래 해시를 써야하나 하고 계속 복잡하게 생각했었는데,

효율성 테스트 4번만 시간 초과가 계속 나와서 짜증났다가 순간 저게 생각이 나서 하니까 바로 통과했다...

import java.util.*;
class Solution {
    char[][] table;
    HashMap<Character, MatchCard> list;
    public String solution(int m, int n, String[] board) {
        String answer = "";
        table = new char[m][n];
        list = new HashMap<>();
        
        for (int i = 0; i < board.length; i++) {
            table[i] = board[i].toCharArray();
        }
        
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (table[i][j] == '.' || table[i][j] == '*') continue;
                if (list.get(table[i][j]) != null) continue;
                
                for (int a = 0; a < m; a++) {
                    for (int b = 0; b < n; b++) {
                        if (i == a && j == b) continue;
                        
                        if (table[i][j] == table[a][b]){
                            list.put(table[i][j], new MatchCard(i, j, a, b));
                        }
                    }
                }
            }
        }

        ArrayList<Character> arr = new ArrayList<>();        
        while (list.size() > 0) {
            arr = new ArrayList<>();
            
            for (int i = 0; i < m; i++) {
            }
            for (char key : list.keySet()) {
                MatchCard card = list.get(key);
            
                boolean value = rootCheck(card.x1, card.y1, card.x2, card.y2);
                if (value) {
                    arr.add(key);
                }
                
            }
            
            if (arr.size() == 0) return "IMPOSSIBLE"; 
            
            Collections.sort(arr);
            char key = arr.get(0);
            MatchCard c = list.get(key);
            table[c.x1][c.y1] = '.';
            table[c.x2][c.y2] = '.';
            list.remove(key);
            answer += key;
        }
            
        return answer;
    }
    
    public boolean rootCheck(int x1, int y1, int x2, int y2) {
        if (x1 == x2) {
            if (holCheck(y1, y2, x1)) {return true;} else {return false;}
        }
        if (y1 == y2) {
            if (verCheck(x1, x2, y1)) {return true;} else {return false;}
        }
        
        if (verCheck(x1, x2, y1)) {
            boolean value = false;
            if (x1 < x2) {
                value = holCheck(y1, y2, x2) && cornerCheck(x2, y1);
            } else {
                value = holCheck(y1, y2, x1) && cornerCheck(x1, y1);
            }
            
            if (value) return true;
        }
        
        if (verCheck(x1, x2, y2)) {
            boolean value = false;
            if (x1 < x2) {
                value = holCheck(y1, y2, x1) && cornerCheck(x1, y2);
            } else {
                value = holCheck(y1, y2, x2) && cornerCheck(x2, y2);
            }
            
            if (value) return true;
        }
        
        return false;
    }
    
    public boolean cornerCheck(int x, int y) {
        if (table[x][y] == '.') return true;
        
        return false;
    }
    
    public boolean verCheck(int x1, int x2, int col) {
        if (x1 == x2) return true;
        
        if (x1 < x2) {
            for (int i = x1 + 1; i < x2; i++) {
                if (table[i][col] != '.') return false;
            }
            
        } else {
            for (int i = x1 - 1; i > x2; i--) {
                if (table[i][col] != '.') return false;
            }
        }
        
        return true;
    }
    
    public boolean holCheck(int y1, int y2, int row) {
        if (y1 == y2) return true;
        
        if (y1 < y2) {
            for (int i = y1 + 1; i < y2; i++) {
                if (table[row][i] != '.') return false;
            }
        } else {
            for (int i = y1 - 1; i > y2; i--) {
                if (table[row][i] != '.') return false;
            }
        }
        return true;
    }
}

class MatchCard {
    int x1, x2, y1, y2;
    
    public MatchCard(int x1, int y1, int x2, int y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }
}

import java.util.*;
class Solution {
    public int[] solution(String s) {
        ArrayList<Integer> answer = new ArrayList<>();
        
        //제일 앞의 {{와 맨 뒤의 }}를 제외하고 },{로 구분
        String[] list = s.substring(2, s.length()-2).split("\\},\\{");
        
        //몇 개의 숫자로 구성되어 있는지 해당 길이로 오름차순 정렬
        Arrays.sort(list, new Comparator<String>(){
            @Override
            public int compare(String s1, String s2) {
                String[] a1 = s1.split(",");
                String[] a2 = s2.split(",");
                
                return a1.length - a2.length;
            }
        });
       
      	//하나씩 돌려가면서 만약에  answer에 이미 담긴 숫자면 넘어가고 아니면 추가
        for (int i = 0; i < list.length; i++) {
            String[] temp = list[i].split(",");
            
            for (int j = 0; j < temp.length; j++) {
                int num = Integer.parseInt(temp[j]);
                if (answer.indexOf(num) == -1) answer.add(num);
            }
        }
        
        //int[]로 변환 후 리턴
        return answer.stream().mapToInt(Integer::intValue).toArray();
    }
}

import java.util.*;
class Solution {
    public int[] solution(String[][] places) {
        int[] answer = new int[places.length];
        
        //places 길이만큼 반복
        for (int i = 0; i < places.length; i++) {
            ArrayList<People> arr = new ArrayList<>(); //P점들이 담길 배열
            char[][] map = new char[5][5]; //5 * 5 배열
            answer[i] = 1; //일단 성공했다고 치고 1 넣어두기
            
            for (int j = 0; j < 5; j++) { //맵 넣는 과정
                char[] row = places[i][j].toCharArray();
                map[j] = Arrays.copyOf(row, 5);
                
                for (int m = 0; m < 5; m++) {  //넣을 값 중에 P가 있으면 배열에 추가
                    if (row[m] == 'P') {
                        arr.add(new People(j, m));
                    }
                }
            }
            
            //P 포인트들끼리 비교하기
            loop:
            for (int m = 0; m < arr.size(); m++) {
                People p1 = arr.get(m);
                int x1 = p1.x;
                int y1 = p1.y;
                
                for (int n = 0; n < arr.size(); n++) {
                    if (m == n) continue;
                    
                    People p2 = arr.get(n);
                    int x2 = p2.x;
                    int y2 = p2.y;
                    
                    //만약 거리가 2면 func함수로 넘기기
                    int num = Math.abs(x2 - x1) + Math.abs(y2 - y1);
                    if (num == 2) {
                        boolean value = func(map, x1, y1, x2, y2);
                        if (!value) {
                            answer[i] = 0;
                            break loop;
                        }
                    } else if (num < 2) { //거리가 2보다 작으면 그냥 바로 false로 실패 리턴
                        answer[i] = 0;
                        break loop;
                    }
                }
            }
        }
        return answer;
    }
    
    public boolean func(char[][] map, int x1, int y1, int x2, int y2) {
    	//포인터가 대각선에 있는지
        if (x1 != x2 && y1 != y2) {
            if (map[x1][y2] == 'O' || map[x2][y1] == 'O') return false;
        } else {
            if (x1 == x2) { //아니면 x나 y가 동일한지를 비교
                if (map[x1][Math.min(y1, y2) + 1] == 'O') return false;
            } else if (y1 == y2) {
                if (map[Math.min(x1, x2) + 1][y1] == 'O') return false;
            }
        }
        
        return true;
    }
    
}

class People {
    int x, y;
    public People(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

import java.util.*;
class Solution {
    HashMap<String, Integer> aGroup, bGroup;
    public int solution(String str1, String str2) {
        aGroup = new HashMap<>();
        bGroup = new HashMap<>();
        
        char[] c1 = str1.toLowerCase().toCharArray();
        char[] c2 = str2.toLowerCase().toCharArray();
        String[] s1 = str1.toLowerCase().split("");
        String[] s2 = str2.toLowerCase().split("");
        
        for (int i = 0; i < c1.length-1; i++) {
            if (c1[i] < 97 || c1[i] > 122 || c1[i+1] < 97 || c1[i+1] > 122) continue;
            StringBuilder sb = new StringBuilder(s1[i]);
            sb.append(s1[i+1]);
            
            String s = sb.toString();
            aGroup.put(s, aGroup.getOrDefault(s, 0) + 1);
        }
        
        for (int i = 0; i < c2.length-1; i++) {
            if (c2[i] < 97 || c2[i] > 122 || c2[i+1] < 97 || c2[i+1] > 122) continue;
            StringBuilder sb = new StringBuilder(s2[i]);
            sb.append(s2[i+1]);
            
            String s = sb.toString();
            bGroup.put(s, bGroup.getOrDefault(s, 0) + 1);
        }
        
        int inter = 0;
        int outer = 0;
        for (String key : aGroup.keySet()) {
            int a = aGroup.get(key);
            outer += a;
            
            int b = bGroup.getOrDefault(key, 0);
            if (b == 0) continue;
            
            inter += Math.min(a, b);
        }
        
        for (String key : bGroup.keySet()) {
            int a = aGroup.getOrDefault(key, 0);
            int b = bGroup.get(key);
            
            if (b - a > 0) outer += (b - a);
        }
        
        double result = (inter == 0 && outer == 0) ? 65536 : (double) inter / outer * 65536;
        return (int) result;
    }
}