잡다한 배똥월드

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 {
    boolean[] check; //방문 여부 체크용
    char[] list; //* + -가 들어있는 리스트
    long answer; //리턴용
    public long solution(String expression) {
        answer = 0;
        
       	//숫자들 모아놓을 배열
        ArrayList<Long> numbers = new ArrayList<>();
        //숫자 구분용
        String[] nTemp = expression.split("\\*|\\-|\\+");
        
        //숫자로 변환
        for (int i = 0; i < nTemp.length; i++) {
            numbers.add(Long.parseLong(nTemp[i]));
        }
        
        //연산기호 구분용
        char[] sTemp = expression.toCharArray();
       	
        //연산기호 담길 배열
        ArrayList<Character> sign = new ArrayList<>(); 
        
        //* + -면 추가
        for (int i = 0; i < sTemp.length; i++) {
            if (sTemp[i] == '*' || sTemp[i] == '+' || sTemp[i] == '-') {
                sign.add(sTemp[i]);
            }
        }
        
        check = new boolean[3];
        list = new char[]{'*', '+', '-'};
        
        //함수 호출
        func(numbers, sign);
        
        return answer;
    }
    
    public void func(ArrayList<Long> numbers, ArrayList<Character> sign) {
    	//다 계산 끝나면 숫자 하나만 남기 때문에 조건문이 이럼
        if (numbers.size() == 1 && sign.size() == 0) {
            //절대값으로 변환한 숫자와 answer와 비교해서 큰 쪽 담기
            answer = Math.max(answer, Math.abs(numbers.get(0)));
            return;
        } 
        
        //* + -을 for문으로 방문함
        for (int i = 0; i < list.length; i++) {
            if (check[i]) continue;
            
            check[i] = true;
            
            ArrayList<Long> numClone = (ArrayList<Long>) numbers.clone();
            ArrayList<Character> signClone = (ArrayList<Character>) sign.clone();
            
            while(signClone.indexOf(list[i]) != -1) {
                int p = signClone.indexOf(list[i]);
                
                long a = numClone.remove(p);
                long b = numClone.remove(p);
                signClone.remove(p);
                
                long c = (i == 0) ? a * b : (i == 1) ? a + b : a - b;
                numClone.add(p, c);
            }
            
            func(numClone, signClone);
            check[i] = false;
        }
    }
}

중요한 포인트는 split( )을 이용해서 *, +, - 를 구분해서 숫자만 골라낼 때 그냥 "*|+|-"가 아닌 "\\*|\\+|\\-"로 입력을 해야 함

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

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        int[] arrival = new int[N+1];  //스테이지별 도달한 플레이어 수
        int[] noClear = new int[N+1];  //스테이지별 클리어하지 못한 플레이어 수
        
        //도달한 플레이어 수 구하기
        //stages[j](멈춰있는 스테이지)가 i(스테이지 레벨)보다 크거나 같으면 +1
        for (int i = 1; i <= N; i++) { 
            for (int j = 0; j < stages.length; j++) {
                if (stages[j] >= i) arrival[i]++; 
            }
        }
        
        //도달은 했지만 클리어하지 못한 플레이어 수 구하기
        //stages[i]의 해당 스테이지 +1
        for (int i = 0; i < stages.length; i++) {
            if (stages[i] > N) continue;
            noClear[stages[i]]++;
        }
        
        //해시맵에 스테이지와 해당 스테이지의 실패율 저장
        HashMap<Integer, Double> map = new HashMap<>();
        for (int i = 1; i <= N; i++) {
            if (arrival[i] == 0)
                map.put(i, (double) 0);
            else 
                map.put(i, (double) noClear[i] / arrival[i]);
                
        }
        
       	//실패율(내림차순)로 정렬
        //실패율이 동일하면 스테이지 레벨이 작은 것이 앞으로 오게(오름차순) 정렬
        List<Map.Entry<Integer, Double>> arr = new ArrayList<Map.Entry<Integer, Double>>(map.entrySet());
        Collections.sort(arr, new Comparator<Map.Entry<Integer, Double>>(){
            @Override
            public int compare(Map.Entry<Integer, Double> o1, Map.Entry<Integer, Double> o2) {
                double v1 = o1.getValue();
                double v2 = o2.getValue();
                
                if (v1 < v2) {
                    return 1;
                } else if (v1 == v2) {
                    if (o1.getKey() > o2.getKey()) {
                        return 1;
                    }
                }
                
                return -1;
            }
        });
        
        for (int i = 0; i < arr.size(); i++) {
            answer[i] = arr.get(i).getKey();
        }
        
        return answer;
    }
}

이게 1단계..?

문제를 풀면서 주의해야할 점은 도달한 플레이어 수가 0인 스테이지는 실패율을 0으로 제대로 처리해야 한다

직접 값을 입력하지 않으면 0으로 나누는 것이 되기 때문에 오류가 뜨기 때문이다.

import java.util.*;
class Solution {
    public String solution(String p) {
        return func(p); //func함수 자체가 String을 리턴하기 때문에 바로 리턴
    }
    
    public String func(String word) {
        if (word.equals("")) return ""; //만약 빈 문자열이면 그대로 리턴함
        
        //문자열을 붙이는 작업이 많기 때문에 시간 절약을 위해 StringBuilder 객체 선언하여 활용
        StringBuilder result = new StringBuilder();
        
        int position = 0; //u와 v를 구분하기 위한 위치를 담을 변수
        int count = 0; //균형잡힌 문자열을 알아내기 위해서 사용하는 변수
        String[] s = word.split("");
        
        //올바른 문자열인지 아닌지를 구분하기 위한 변수
        //만약 시작이 "("이면 올바른 문자열이고, 그렇지 않으면 아닌 것
        boolean value = s[0].equals(")") ? false : true; 
        
        for (int i = 0; i < s.length; i++) {
            count += (s[i].equals("(")) ? 1 : -1; //만약 s[i]가 "("면 +1을 아니면 -1을 함
            if (count == 0) { 
            	//괄호의 모양에 따라 +1 또는 -1 하면서 0이 되는 순간이 있음
                //그 순간이 괄호 숫자가 딱 떨어지는 순간이기 때문에 여기서 잘라야 함
                position = i + 1;
                break;
            }
        }
        
        String u = word.substring(0, position);
        String v = word.substring(position, word.length());
        
        if (value) { //올바른 문자열일 때
            result.append(u);
            result.append(func(v));
        } else { //올바른 문자열이 아닐 때
            result.append("(");
            result.append(func(v)); //v는 다시 처음부터 반복해서 리턴해야 하기 때문에 함수 호출
            result.append(")");
            
            char[] uSplit = u.substring(1, u.length()-1).toCharArray(); //앞 뒤 제외하고 배열 만들기
            
            for (int i = 0; i < uSplit.length; i++) { //괄호 뒤집기
                uSplit[i] = uSplit[i] == '(' ? ')' : '(';
            }

            result.append(new String(uSplit));
        }
        
        return result.toString(); //리턴값이 String이기 때문에 toString() 필수
    }
}

문제에서 재귀적으로 수행하라길래 진짜 재귀함수로 풀었음.