잡다한 배똥월드

class Solution {
    String word = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; //알파벳 위치 찾기 위해서
    int answer = Integer.MAX_VALUE; //가장 큰 값으로 설정
    String[] names; //name 나눌 용도
    boolean[] check; //다녀왔는지 확인 용도
    public int solution(String name) {
        names = name.split("");
        check = new boolean[names.length];
        int all = 0; 
        
        //names 확인하면서 A는 굳이 들를 필요 없으니까 미리 check에 true 표시하고,
        //바꿔야할 알파벳들 개수 구하기
        for (int i = 0; i < names.length; i++) {
            if (names[i].equals("A")) check[i] = true;
            if (!names[i].equals("A")) all++;
        }
        
        //함수 호출
        func(all, 0, 0);
        
        return answer;
    }
    
    public void func(int num, int p, int count) {
        if (num == 0) { //다 바꿨으면 answer 값 바꾸기
            answer = Math.min(count, answer);
            return;
        }
        
        int r = right(p); //오른쪽으로 이동했을 경우 바꿀 위치
        int l = left(p); //왼쪽으로 이동했을 경우 바꿀 위치
        
        //오른쪽으로 이동하는 경우의 함수호출
        check[r] = true;
        int rCount = (p <= r) ? r - p : names.length - p + r; //r의 위치까지 이동 수
        int rIndex = word.indexOf(names[r]); //위로 알파벳을 바꿨을 때
        int anotherR = 26 - rIndex; //아래로 알파벳을 바꿨을 때
        func(num-1, r, count + rCount + Math.min(rIndex, anotherR));
        check[r] = false;
        
        //왼쪽으로 이동하는 경우의 함수호출
        check[l] = true;
        int lCount = (p >= l) ? p - l : p + names.length - l; //l의 위치까지 이동 수
        int lIndex = word.indexOf(names[l]); //위로 알파벳을 바꿨을 때
        int anotherL = 26 - lIndex; //아래로 알파벳을 바꿨을 때
        func(num-1, l, count + lCount + Math.min(lIndex, anotherL));
        check[l] = false;
    }
    
    public int right(int p) {
        for (int i = p; i < names.length; i++) {
            if (check[i]) continue;
            return i;
        }
        
        for (int i = 0; i < p; i++) {
            if (check[i]) continue;
            return i;
        }
        return p;
    }
    
    public int left(int p) {
        for (int i = p; i >= 0; i--) {
            if (check[i]) continue;
            return i;
        }
        
        for (int i = names.length - 1; i >= 0; i--) {
            if (check[i]) continue;
            return i;
        }
        return p;
    }
}

import java.util.*;
class Solution {
    ArrayList<Integer> nList; //추가한 숫자인지 확인용
    boolean[] check; //다녀간 숫자인지 확인용
    int answer; //리턴값 모을 용도
    public int solution(String numbers) {
        nList = new ArrayList<>();
        answer = 0;
        String[] temp = numbers.split("");
        int[] nums = new int[temp.length];
        check = new boolean[temp.length];
        
        //split으로 나눈 numbers를 int로 변경
        for (int i = 0; i < temp.length; i++) {
            nums[i] = Integer.parseInt(temp[i]);
        }
        
        func(nums, 0);
        
        return answer;
    }
    
    public void func(int[] nums, int num) {
        //무조건 체크하기
        if (checkNum(num)) {
            answer++;
            nList.add(num);
        }
        
       	//숫자 만들기
        for (int i = 0; i < nums.length; i++) {
            if (check[i]) continue;
            
            check[i] = true;
            int temp = num * 10 + nums[i];
            func(nums, temp);
            check[i] = false;
        }
    }
    
    //소수인지 체크하는 함수
    public boolean checkNum(int num) {
        if (num == 0 || num == 1) return false;
        if (nList.indexOf(num) != -1) return false;
        
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) return false;
        }
        
        return true;
    }
}

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();
    }
}