steady study

[Level 2] 올바른 괄호

kmkunk — Thu, 7 Apr 2022 18:46:50 +0900

import java.util.*;

class Solution {
    boolean solution(String s) {
        Stack<Character> stack = new Stack<>();
        
        for(int i=0; i<s.length(); i++) {
            char c = s.charAt(i);
            if(c=='(') {
                stack.push(c);
            } else {
                if(stack.isEmpty()) { return false; }
                else { stack.pop(); }
            }
        }
        
        return stack.isEmpty();
    }
}

[Level 2] [3차] 파일명 정렬

kmkunk — Thu, 7 Apr 2022 18:46:33 +0900

import java.util.*;

class Solution {
    public String[] solution(String[] files) {
        String[] answer = new String[files.length];
        String[][] file = new String[files.length][3];
        
        for(int i=0; i<files.length; i++) {
            int index = 0;
            int state = 0;
            for(int j=0; j<files[i].length(); j++) {
                char c = files[i].charAt(j);
                
                if(state==0 && c>='0' && c<='9') {
                    file[i][0] = files[i].substring(0, j);
                    index = j;
                    state = 1;
                }
                
                if(state==1 && !(c>='0'&&c<='9')) {
                    file[i][1] = files[i].substring(index, j);
                    file[i][2] = files[i].substring(j, files[i].length());
                    state = 2;
                }
            }
            
            if(state == 1) {
                file[i][1] = files[i].substring(index, files[i].length());
                file[i][2] = "";
            }
        }
        
        Arrays.sort(file, new Comparator<String[]>(){
            @Override
            public int compare(String[] s1, String[] s2) {
                String ss1 = s1[0].toUpperCase();
                String ss2 = s2[0].toUpperCase();
                
                if(ss1.equals(ss2)) { return Integer.parseInt(s1[1])-Integer.parseInt(s2[1]); }
                
                return ss1.compareTo(ss2);
            }
        });
        
        for(int i=0; i<answer.length; i++) { answer[i] = file[i][0]+file[i][1]+file[i][2]; }
        
        return answer;
    }
}

[Level 2] 가장 큰 정사각형 찾기

kmkunk — Thu, 7 Apr 2022 18:46:05 +0900

class Solution {
    public int solution(int [][]board) {
        int answer = 0;
        int[][] dp = new int[board.length][board[0].length];
        
        for(int i=0; i<dp.length; i++) {
            for(int j=0; j<dp[0].length; j++) { dp[i][j] = board[i][j]; }
        }
        
        for(int i=1; i<dp.length; i++) {
            for(int j=1; j<dp[0].length; j++) {
                if(dp[i][j]==0) { continue; }
                if(dp[i-1][j-1]>0 && dp[i][j-1]>0 && dp[i-1][j]>0) {
                    dp[i][j] = Math.min(Math.min(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1])+1;
                }
            }
        }
        
        for(int i=0; i<dp.length; i++ ) {
            for(int j=0; j<dp[0].length; j++) { answer = Math.max(answer, dp[i][j]); }
        }
        
        return answer*answer;
    }
}

[Level 2] 방문 길이

kmkunk — Thu, 7 Apr 2022 18:45:42 +0900

import java.util.*;

class Solution {
    public int solution(String dirs) {
        int x = 0; int y = 0;
        Set<String> set = new HashSet<>();
        
        for(int i=0; i<dirs.length(); i++) {
            char c = dirs.charAt(i);
            String start = String.valueOf(x)+String.valueOf(y);
            String end = "";
            
            if(c=='U' && y!=5) {
                y++;
                end = String.valueOf(x)+String.valueOf(y);
                set.add(start+end); set.add(end+start);
            } else if(c=='D' && y!=-5) {
                y--;
                end = String.valueOf(x)+String.valueOf(y);
                set.add(start+end); set.add(end+start);
            } else if(c=='L' && x!=-5) {
                x--;
                end = String.valueOf(x)+String.valueOf(y);
                set.add(start+end); set.add(end+start);
            } else if(c=='R' && x!=5) {
                x++;
                end = String.valueOf(x)+String.valueOf(y);
                set.add(start+end); set.add(end+start);
            }
        }
        
        return set.size()/2;
    }
}

[Level 2] 스킬트리

kmkunk — Thu, 7 Apr 2022 18:45:21 +0900

import java.util.*;

class Solution {
    public int solution(String skill, String[] skill_trees) {
        int answer = 0;
        List<Character> list = new ArrayList<>();
        
        for(int i=0; i<skill.length(); i++) { list.add(skill.charAt(i)); }
        
        for(String s : skill_trees) {
            int index = 0;
            boolean check = true;
            
            for(int i=0; i<s.length(); i++) {
                char c = s.charAt(i);
                if(list.contains(c)) {
                    if(list.get(index)==c) {
                        index++;
                        continue;
                    } else {
                        check = false;
                        break;
                    }
                }
            }
            
            answer += check ? 1 : 0;
        }
        
        return answer;
    }
}

[Level 2] n^2 배열 자르기

kmkunk — Thu, 7 Apr 2022 18:44:51 +0900

class Solution {
    public int[] solution(int n, long left, long right) {
        int len = (int)(right-left+1);
        int[] answer = new int[len];
        
        for(int i=0; i<answer.length; i++) {
            int x = (int)(left/n);
            int y = (int)(left%n);
            answer[i] = Math.max(x, y)+1;
            left++;
        }
        
        return answer;
    }
}

[Level 2] 점프와 순간 이동

kmkunk — Thu, 7 Apr 2022 18:44:15 +0900

import java.util.*;

public class Solution {
    public int solution(int n) {
        return dp(n);
    }
    
    public int dp(int n) {
        if(n==1) {
            return 1;
        }
        
        if(n%2==0) { return dp(n/2); }
        else { return dp(n-1)+1; }
    }
}

[Level 2] 이진 변환 반복하기

kmkunk — Thu, 7 Apr 2022 18:43:40 +0900

class Solution {
    public int count = 0;
    public int zero = 0;
    
    public int[] solution(String s) {
        int[] answer = new int[2];
        
        while(!s.equals("1")) {
            s = deleteZero(s);
            count++;
        }
        
        answer[0] = count;
        answer[1] = zero;
        
        return answer;
    }
    
    public String deleteZero(String s) {
        String temp = "";
        
        for(int i=0; i<s.length(); i++) {
            if(s.charAt(i)=='0') { zero++; }
            else { temp += "1"; }
        }
        
        return Integer.toBinaryString(temp.length());
    }
}

[Level 2] 게임 맵 최단거리

kmkunk — Thu, 7 Apr 2022 10:59:59 +0900

import java.util.*;

class Solution {
    public int n;
    public int m;
    public int[] dx = new int[]{1,-1,0,0};
    public int[] dy = new int[]{0,0,1,-1};
    public int[][] copy;
    
    public int solution(int[][] maps) {
        n = maps.length;
        m = maps[0].length;
        copy = new int[n][m];
        
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) { copy[i][j] = maps[i][j]; }
        }
        
        bfs(0,0);
        
        return copy[n-1][m-1]==1 ? -1 : copy[n-1][m-1];
    }
    
    public void bfs(int i, int j) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i,j});
        
        while(!queue.isEmpty()) {
            int[] a = queue.poll();
            int x = a[1];
            int y = a[0];
            for(int k=0; k<4; k++) {
                int nx = x+dx[k];
                int ny = y+dy[k];
                if(nx>=0 && ny>=0 && nx<m && ny<n && copy[ny][nx]==1) {
                    queue.add(new int[]{ny,nx});
                    copy[ny][nx] = copy[y][x]+1;
                }
            }
        }
    }
}

[Level 2] 카카오프렌즈 컬러링북

kmkunk — Thu, 7 Apr 2022 10:59:34 +0900

import java.util.*;

class Solution {
    public boolean[][] visited;
    public int[] dx = new int[]{0,0,1,-1};
    public int[] dy = new int[]{1,-1,0,0};
    
    public int[] solution(int m, int n, int[][] picture) {
        visited = new boolean[m][n];
        int[] answer = new int[2];
        
        for(int i=0; i<m; i++) {
            for(int j=0; j<n; j++) {
                if(!visited[i][j] && picture[i][j]>0) {
                    answer[1] = Math.max(bfs(i,j,m,n,picture),answer[1]);
                    answer[0]++;
                }
            }
        }
        
        return answer;
    }
    
    public int bfs(int i, int j, int m, int n, int[][] picture) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i,j});
        visited[i][j] = true;
        int count = 1;
        
        while(!queue.isEmpty()) {
            int[] a = queue.poll();
            int x = a[1];
            int y= a[0];
            for(int k=0; k<4; k++) {
                int nx = x+dx[k];
                int ny = y+dy[k];
                if(nx>=0 && ny>=0 && nx<n && ny<m && !visited[ny][nx] && picture[ny][nx]==picture[i][j]) {
                    queue.add(new int[]{ny,nx});
                    visited[ny][nx] = true;
                    count++;
                }
            }
        }
        
        return count;
    }
}

[Level 2] 모음 사전

kmkunk — Wed, 6 Apr 2022 12:56:10 +0900

class Solution {
    public int solution(String word) {
        int answer = word.length();
        String s = "AEIOU";
        int[] n = new int[]{781, 156, 31, 6, 1};
        
        for(int i=0; i<word.length(); i++) {
            answer += n[i]*s.indexOf(String.valueOf(word.charAt(i)));
        }
        
        return answer;
    }
}

[Level 2] 교점에 별 만들기

kmkunk — Wed, 6 Apr 2022 12:55:42 +0900

import java.util.*;

class Solution {
    public String[] solution(int[][] line) {
        List<Long> xl = new ArrayList<>(); List<Long> yl = new ArrayList<>();
        long xMax = Long.MIN_VALUE; long xMin = Long.MAX_VALUE;
        long yMax = Long.MIN_VALUE; long yMin = Long.MAX_VALUE;
        
        for(int i=0; i<line.length; i++) {
            for(int j=0; j<i; j++) {
                long a = line[i][0]; long b = line[i][1]; long e = line[i][2];
                long c = line[j][0]; long d = line[j][1]; long f = line[j][2];
                double x = (double)(b*f-e*d)/(a*d-b*c); double y = (double)(e*c-a*f)/(a*d-b*c);
                
                if(check(x,y)) { xl.add((long)x); yl.add((long)y); }
            }
        }
        
        for(int i=0; i<xl.size(); i++) {
            xMax = Math.max(xMax, xl.get(i)); xMin = Math.min(xMin, xl.get(i));
            yMax = Math.max(yMax, yl.get(i)); yMin = Math.min(yMin, yl.get(i));
        }
        
        String[] answer = new String[(int)(yMax-yMin+1)];
        
        for(int i=0; i<answer.length; i++) {
            answer[i] = "";
            for(long j=xMin; j<=xMax; j++) { answer[i] += "."; }
        }
        
        for(int i=0; i<xl.size(); i++) {
            int x = (int)(xl.get(i)-xMin); int y = (int)(yMax-yl.get(i));
            StringBuilder sb = new StringBuilder(answer[y]);
            
            sb.setCharAt(x, '*');
            answer[y] = sb.toString();
        }
        
        return answer;
    }
    
    public boolean check(double x, double y) {
        if(x==(long)x && y==(long)y) { return true; }
        else { return false; }
    }
}

[Level 2] 구명보트

kmkunk — Wed, 6 Apr 2022 12:54:43 +0900

import java.util.*;

class Solution {
    public int solution(int[] people, int limit) {
        int answer = 0;
        int start = 0;
        int end = people.length-1;
        
        Arrays.sort(people);
        
        while(start<=end) {
            start += people[start]+people[end]<=limit ? 1 : 0;
            end--;
            answer++;
        }
        
        return answer;
    }
}

[Level 2] 주식가격

kmkunk — Wed, 6 Apr 2022 12:54:06 +0900

import java.util.*;

class Solution {
    public int[] solution(int[] prices) {
        int[] answer = new int[prices.length];
        Stack<Integer> stack = new Stack<>();
        
        for(int i=0; i<prices.length; i++) {
            while(!stack.isEmpty() && prices[stack.peek()]>prices[i]) {
                int index = stack.peek();
                answer[index] = i-index;
                stack.pop();                
            }
            
            stack.push(i);
        }
        
        while(!stack.isEmpty()) {
            int index = stack.peek();
            answer[index] = prices.length-1-index;
            stack.pop();
        }
        
        return answer;
    }
}

[Level 2] 영어 끝말잇기

kmkunk — Wed, 6 Apr 2022 12:53:41 +0900

import java.util.*;

class Solution {
    public int[] solution(int n, String[] words) {
        int[] answer = new int[2];
        List<String> list = new ArrayList<>();
        list.add(words[0]);
        
        for(int i=1; i<words.length; i++) {
            String w1 = words[i-1];
            String w2 = words[i];
            
            if(w1.charAt(w1.length()-1)!=w2.charAt(0) || list.contains(w2)) {
                answer[0] = i%n+1;
                answer[1] = i/n+1;
                break;
            }
            
            list.add(w2);
        }
        
        return answer;
    }
}

[Level 2] 삼각 달팽이

kmkunk — Wed, 6 Apr 2022 12:53:19 +0900

class Solution {
    public int[] solution(int n) {
        int[] answer = new int[n*(n+1)/2];
        int[][] arr = new int[n][n];
        int x = -1;
        int y = 0;
        int len = n;
        int value = 1;
        int index = 0;
        
        while(true) {
            //down
            for(int i=0; i<len; i++) { arr[x+1+i][y] = value++; }
            x += len;
            len--;
            if(len==0) { break; }
            
            //right
            for(int i=0; i<len; i++) { arr[x][y+1+i] = value++; }
            y += len;
            len--;
            if(len==0) { break; }
            
            //diagonal
            for(int i=0; i<len; i++) { arr[x-1-i][y-1-i] = value++; }
            x -= len;
            y -= len;
            len--;
            if(len==0) { break; }
        }
        
        for(int i=0; i<n; i++) {
            for(int j=0; j<=i; j++) { answer[index++] = arr[i][j]; }
        }
        
        return answer;
    }
}

[Level 2] 2개 이하로 다른 비트

kmkunk — Wed, 6 Apr 2022 12:52:40 +0900

class Solution {
    public long[] solution(long[] numbers) {
        long[] answer = new long[numbers.length];
        
        for(int i=0; i<numbers.length; i++) {
            if(numbers[i]%2==0) { answer[i] = numbers[i]+1; }
            else {
                String[] arr = Long.toBinaryString(numbers[i]).split("");
                String s = "";
                int k = -1;
                
                for(int j=0; j<arr.length; j++) {
                    if(arr[j].equals("0")) { k = j; }
                }
                
                if(k==-1) {
                    s = "10";
                    for(int j=0; j<arr.length-1; j++) { s += "1"; }
                } else {
                    arr[k] = "1"; arr[k+1] = "0";
                    for(int j=0; j<arr.length; j++) { s += arr[j]; }
                }
                
                answer[i] = Long.valueOf(s, 2);
            }
        }
        
        return answer;
    }
}

[Level 2] 피로도

kmkunk — Wed, 6 Apr 2022 12:52:17 +0900

class Solution {
    public boolean[] visited;
    public int answer = 0;
    
    public int solution(int k, int[][] dungeons) {
        visited = new boolean[dungeons.length];
        
        recur(0, k, dungeons, 0);
        
        return answer;
    }
    
    public void recur(int index, int k, int[][] dungeons, int count) {
        if(index==dungeons.length) {
            answer = Math.max(answer, count);
            
            return;
        }
        
        for(int i=0; i<dungeons.length; i++) {
            if(!visited[i] || k>=dungeons[i][0]) {
                visited[i] = true;
                recur(index+1, k-dungeons[i][1], dungeons, count+1);
                recur(index+1, k, dungeons, count);
                visited[i] = false;
            }
        }
    }
}

[Level 2] 큰 수 만들기

kmkunk — Wed, 6 Apr 2022 12:51:17 +0900

class Solution {
    public String solution(String number, int k) {
        String answer = "";
        int len = number.length()-k;
        
        for(int i=0; i<number.length(); i++) {
            if(answer.length()==len) { break; }
            if(k==0) { return answer+number.substring(i, number.length()); }
            
            char c = number.charAt(i);
            boolean delete = true;
            
            for(int j=i+1; j<=i+k; j++) {
                if(c<number.charAt(j)) {
                    delete = false;
                    k--;
                    break;
                }
            }
            
            if(delete) { answer += String.valueOf(c); }
        }
        
        return answer;
    }
}

[Level 2] 카펫

kmkunk — Wed, 6 Apr 2022 11:27:22 +0900

class Solution {
    public int[] solution(int brown, int yellow) {
        int[] answer = new int[2];

        for(int i=3; i<=(brown-2)/2; i++) {
            if(i==(double)(brown+yellow)/((brown/2)-i+2)) {
                answer[0] = (brown+yellow)/i;
                answer[1] = i;
                break;
            }
        }
        
        return answer;
    }
}

[Level 2] H-Index

kmkunk — Wed, 6 Apr 2022 11:26:24 +0900

import java.util.*;

class Solution {
    public int solution(int[] citations) {
        int answer = 0;
        
        Arrays.sort(citations);
        
        for(int i=0; i<=citations.length; i++) {
            for(int j=0; j<citations.length; j++) {
                if(citations[j]>=i && citations.length-j>=i) {
                    answer = i;
                    break;
                }
            }
        }
        
        return answer;
    }
}

[Level 2] 다리를 지나는 트럭

kmkunk — Wed, 6 Apr 2022 11:25:57 +0900

import java.util.*;

class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int answer = 0;
        int sum = 0;
        Queue<Integer> queue = new LinkedList<>();
        
        for(int i=0; i<truck_weights.length; i++) {
            if(queue.isEmpty()) {
                sum += truck_weights[i];
                queue.add(truck_weights[i]);
                answer++;
                continue;
            }
            
            while(true) {
                if(queue.size()==bridge_length) { sum -= queue.poll(); }

                if(sum+truck_weights[i]>weight) {
                    queue.add(0);
                    answer++;
                } else {
                    sum += truck_weights[i];
                    queue.add(truck_weights[i]);
                    answer++;
                    break;
                }
            }
        }
        
        return answer+bridge_length;
    }
}

[Level 2] 위장

kmkunk — Wed, 6 Apr 2022 11:25:38 +0900

import java.util.*;

class Solution {
    public int solution(String[][] clothes) {
        int answer = 1;
        Map<String, Integer> map = new HashMap<>();
        
        for(int i=0; i<clothes.length; i++) { map.put(clothes[i][1], 1); }
        for(int i=0; i<clothes.length; i++) {
            int value = map.get(clothes[i][1])+1;
            map.put(clothes[i][1], value);
        }
        
        for(int i : map.values()) { answer *= i; }
        
        return answer-1;
    }
}

[Level 2] 괄호 회전하기

kmkunk — Wed, 6 Apr 2022 11:24:19 +0900

import java.util.*;

class Solution {
    public int solution(String s) {
        int answer = 0;
        int len = s.length();
        
        for(int i=0; i<len; i++) {
            Stack<Character> stack = new Stack<>();
            for(int j=0; j<len; j++) {
                char c = s.charAt(j);
                
                if(c=='[' || c=='(' || c=='{') { stack.push(c); }
                else {
                    if(stack.isEmpty()) {
                        stack.push(c);
                        break;
                    } else {
                        if((stack.peek()=='['&&c==']') || (stack.peek()=='('&&c==')') || (stack.peek()=='{'&&c=='}')) {
                            stack.pop();
                        }
                    }
                }
            }
            
            if(stack.isEmpty()) { answer++; }
            
            s = s.substring(1, len)+String.valueOf(s.charAt(0));
        }
        
        return answer;
    }
}

[Level 2] 예상 대진표

kmkunk — Wed, 6 Apr 2022 11:23:46 +0900

class Solution {
    public int solution(int n, int a, int b) {
        int answer = 1;
        int x = Math.min(a,b);
        int y = Math.max(a,b);

        for(int i=1; i<=20; i++) {
            if(y%2==0 && y-x==1) { break; }
            
            x = (x+1)/2;
            y = (y+1)/2;
            answer++;
        }
        
        return answer;
    }
}

[Silver 2] 15663번 N과 M (9)

kmkunk — Fri, 1 Apr 2022 14:43:46 +0900

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

public class Main {
    public static int n; public static int m;
    public static int[] ans;
    public static int[] numbers;
    public static boolean[] tf;
    public static LinkedHashSet<String> set;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr1 = br.readLine().split(" "); String[] arr2 = br.readLine().split(" ");
        n = Integer.parseInt(arr1[0]); m = Integer.parseInt(arr1[1]);
        numbers = new int[n]; ans = new int[m]; tf = new boolean[n];
        set = new LinkedHashSet<>();
        StringBuilder sb2 = new StringBuilder();
        
        for(int i=0; i<n; i++) { numbers[i] = Integer.parseInt(arr2[i]); }
        Arrays.sort(numbers);
        
        calc(0);
        for(String s : set) { sb2.append(s).append("\n"); }
        System.out.println(sb2);
    }
    
    public static void calc(int index) {
        if(index==m) {
            StringBuilder sb = new StringBuilder();
            for(int a : ans) {
                sb.append(String.valueOf(a)).append(" ");
            }
            
            set.add(sb.toString()); return;
        }
        
        for(int i=0; i<n; i++) {
            if(tf[i]) { continue; }
            
            tf[i] = true;
            ans[index] = numbers[i];
            calc(index+1);
            tf[i] = false;
        }
    }
}

[Silver 3] 15657번 N과 M (8)

kmkunk — Fri, 1 Apr 2022 14:41:40 +0900

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

public class Main {
    public static int n; public static int m;
    public static int[] numbers;
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr1 = br.readLine().split(" ");
        String[] arr2 = br.readLine().split(" ");
        n = Integer.parseInt(arr1[0]); m = Integer.parseInt(arr1[1]);
        numbers = new int[n]; ans = new int[m];
        sb = new StringBuilder();
        
        for(int i=0; i<n; i++) { numbers[i] = Integer.parseInt(arr2[i]); }
        Arrays.sort(numbers);
        
        calc(0, 0);
        System.out.println(sb);
    }
    
    public static void calc(int index, int start) {
        if(index==m) {
            for(int a : ans) { sb.append(String.valueOf(a)).append(" "); }
            
            sb.append("\n"); return;
        }
        
        for(int i=start; i<n; i++) {
            ans[index] = numbers[i];
            calc(index+1, i);
        }
    }
}

[Silver 3] 15656번 N과 M (7)

kmkunk — Fri, 1 Apr 2022 14:41:07 +0900

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

public class Main {
    public static int n; public static int m;
    public static int[] numbers;
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr1 = br.readLine().split(" ");
        String[] arr2 = br.readLine().split(" ");
        n = Integer.parseInt(arr1[0]); m = Integer.parseInt(arr1[1]);
        numbers = new int[n]; ans = new int[m];
        sb = new StringBuilder();
        
        for(int i=0; i<n; i++) { numbers[i] = Integer.parseInt(arr2[i]); }
        
        Arrays.sort(numbers);
        
        calc(0);
        System.out.println(sb);
    }
    
    public static void calc(int index) {
        if(index==m) {
            for(int a : ans) { sb.append(String.valueOf(a)).append(" "); }
            
            sb.append("\n"); return;
        }
        
        for(int i=0; i<n; i++) {
            ans[index] = numbers[i];
            calc(index+1);
        }
    }
}

[Silver 3] 15655번 N과 M (6)

kmkunk — Fri, 1 Apr 2022 14:40:36 +0900

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

public class Main {
    public static int[] numbers;
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr1 = br.readLine().split(" ");
        String[] arr2 = br.readLine().split(" ");
        int n = Integer.parseInt(arr1[0]); int m = Integer.parseInt(arr1[1]);
        numbers = new int[n]; ans = new int[m];
        sb = new StringBuilder();
        
        for(int i=0; i<n; i++) { numbers[i] = Integer.parseInt(arr2[i]); }
        
        Arrays.sort(numbers);
        calc(0, 0, n, m);
        
        System.out.println(sb);
    }
    
    public static void calc(int index, int selected, int n, int m) {
        if(selected==m) {
            for(int a : ans) { sb.append(String.valueOf(a)).append(" "); }
            
            sb.append("\n"); return;
        }
        
        if(index>=n) { return; }
        
        ans[selected] = numbers[index];
        calc(index+1, selected+1, n, m);
        calc(index+1, selected, n, m);
    }
}

[Silver 3] 15654번 N과 M (5)

kmkunk — Fri, 1 Apr 2022 14:40:12 +0900

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

public class Main {
    public static int[] numbers;
    public static int[] ans;
    public static boolean[] tf;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr1 = br.readLine().split(" ");
        String[] arr2 = br.readLine().split(" ");
        int n = Integer.parseInt(arr1[0]); int m = Integer.parseInt(arr1[1]);
        numbers = new int[n]; ans = new int[m]; tf = new boolean[n];
        sb = new StringBuilder();
        
        for(int i=0; i<n; i++) { numbers[i] = Integer.parseInt(arr2[i]); }
        Arrays.sort(numbers);
        
        calc(0, n, m);
        System.out.println(sb);        
    }
    
    public static void calc(int index, int n, int m) {
        if(index==m) {
            for(int a : ans) {
                sb.append(String.valueOf(a)).append(" ");
            }
            
            sb.append("\n");
            return;
        }
        
        for(int i=0; i<n; i++) {
            if(tf[i]) { continue; }
            
            tf[i] = true;
            ans[index] = numbers[i];
            calc(index+1, n, m);
            tf[i] = false;
        }
    }
}

[Silver 3] 15652번 N과 M (4)

kmkunk — Fri, 1 Apr 2022 14:39:20 +0900

import java.io.*;

public class Main {
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr = br.readLine().split(" ");
        int n = Integer.parseInt(arr[0]); int m = Integer.parseInt(arr[1]);
        sb = new StringBuilder();
        ans = new int[m];
        
        calc(0, 0, n, m);
        System.out.println(sb);
    }
    
    public static void calc(int index, int start, int n, int m) {
        if(index==m) {
            for(int a : ans) {
                sb.append(String.valueOf(a)).append(" ");
            }
            
            sb.append("\n");
            return;
        }

        for(int i=start; i<n; i++) {
            ans[index] = i+1;
            calc(index+1, i, n, m);
        }
    }
}

[Silver 3] 15651번 N과 M (3)

kmkunk — Fri, 1 Apr 2022 14:38:37 +0900

import java.io.*;

public class Main {
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        sb = new StringBuilder();
        String[] arr = br.readLine().split(" ");
        int n = Integer.parseInt(arr[0]); int m = Integer.parseInt(arr[1]);
        ans = new int[m];
        
        calc(0, n, m);
        System.out.println(sb);
    }
    
    public static void calc(int index, int n, int m) {
        if(index==m) {
            for(int a : ans) {
                sb.append(String.valueOf(a)).append(" ");
            }
            
            sb.append("\n");
            return;
        }
        
        for(int i=0; i<n; i++) {
            ans[index] = i+1;
            calc(index+1, n, m);
        }
    }
}

[Silver 3] 15650번 N과 M (2)

kmkunk — Fri, 1 Apr 2022 14:38:04 +0900

import java.io.*;

public class Main {
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        sb = new StringBuilder();
        String[] arr = br.readLine().split(" ");
        int n = Integer.parseInt(arr[0]); int m = Integer.parseInt(arr[1]);
        ans = new int[m];
        
        calc(1, 0, n, m);
        
        System.out.println(sb);
    }
    
    public static void calc(int index, int selected, int n, int m) {
        if(selected==m) {
            for(int a : ans) {
                sb.append(a).append(" ");
            }
            
            sb.append("\n");
            return;
        }
        
        if(index>n) { return; }
        
        ans[selected] = index;
        calc(index+1, selected+1, n, m);
        calc(index+1, selected, n, m);
    }
}

[Silver 3] 15649번 N과 M (1)

kmkunk — Fri, 1 Apr 2022 14:37:15 +0900

import java.io.*;

public class Main {
    public static boolean[] tf;
    public static int[] ans;
    public static StringBuilder sb;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        sb = new StringBuilder();
        String[] arr = br.readLine().split(" ");
        int n = Integer.parseInt(arr[0]); int m = Integer.parseInt(arr[1]);
        tf = new boolean[n];
        ans = new int[m];
        
        calc(0, n, m);
        System.out.println(sb);
    }
    
    public static void calc(int index, int n, int m) {
        if(index==m) {
            for(int a : ans) { sb.append(String.valueOf(a)).append(" "); }
            sb.append("\n");
            return;
        }
        
        for(int i=0; i<n; i++) {
            if(tf[i]) { continue; }
            
            tf[i] = true;
            ans[index] = i+1;
            calc(index+1, n, m);
            tf[i] = false;
        }
    }
}

[Silver 3] 1748번 수 이어 쓰기 1

kmkunk — Fri, 1 Apr 2022 14:27:13 +0900

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int len = String.valueOf(n).length();
        String s = "";
        int ans = 0;

        for(int i=1; i<len; i++) {
            s += "9";
            ans += 9*Math.pow(10, i-1)*i;
        }
        
        int nine = len==1 ? 0 : Integer.parseInt(s);
        ans += (n-nine)*len;
        
        System.out.println(ans);
    }
}

[Silver 1] 6064번 카잉 달력

kmkunk — Fri, 1 Apr 2022 14:26:26 +0900

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        
        while(t-- > 0) {
            String[] arr = br.readLine().split(" ");
            int m = Integer.parseInt(arr[0]); int n = Integer.parseInt(arr[1]);
            int x = Integer.parseInt(arr[2]); int y = Integer.parseInt(arr[3]);
            int temp = 0;
            boolean noAnswer = true;
            
            for(int i=x; i<=m*n; i+=m) {
                temp = (i-1)%n+1;
                if(temp==y) {
                    System.out.println(i);
                    noAnswer = false;
                    break;
                }
            }
            
            if(noAnswer) { System.out.println(-1); }
        }
    }
}

[Gold 5] 14500번 테트로미노

kmkunk — Fri, 1 Apr 2022 14:25:38 +0900

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr = br.readLine().split(" ");
        int n = Integer.parseInt(arr[0]);
        int m = Integer.parseInt(arr[1]);
        int[][] paper = new int[n+1][m+1];
        int temp = 0;
        int ans = 0;
        
        for(int i=1; i<=n; i++) {
            String[] s = br.readLine().split(" ");
            for(int j=1; j<=m; j++) { paper[i][j] = Integer.parseInt(s[j-1]); }
        }
        
        //blue: 1*4
        for(int i=1; i<=n; i++) {
            for(int j=1; j<=m-3; j++) {
                temp = paper[i][j]+paper[i][j+1]+paper[i][j+2]+paper[i][j+3];
                ans = Math.max(ans, temp);
            }
        }
        
        //blue: 4*1
        for(int i=1; i<=n-3; i++) {
            for(int j=1; j<=m; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i+2][j]+paper[i+3][j];
                ans = Math.max(ans, temp);
            }
        }
        
        //yellow
        for(int i=1; i<=n-1; i++) {
            for(int j=1; j<=m-1; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i][j+1]+paper[i+1][j+1];
                ans = Math.max(ans, temp);
            }
        }
        
        //pink: 위&아래
        for(int i=1; i<=n-1; i++) {
            for(int j=1; j<=m-2; j++) {
                temp = paper[i][j+1]+paper[i+1][j]+paper[i+1][j+1]+paper[i+1][j+2];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i][j+1]+paper[i][j+2]+paper[i+1][j+1];
                ans = Math.max(ans, temp);
            }
        }
        
        //pink: 오른쪽&왼쪽
        for(int i=1; i<=n-2; i++) {
            for(int j=1; j<=m-1; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i+1][j+1]+paper[i+2][j];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j+1]+paper[i+1][j]+paper[i+1][j+1]+paper[i+2][j+1];
                ans = Math.max(ans, temp);
            }
        }
        
        //green : 1&2
        for(int i=1; i<=n-2; i++) {
            for(int j=1; j<=m-1; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i+1][j+1]+paper[i+2][j+1];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j+1]+paper[i+1][j]+paper[i+1][j+1]+paper[i+2][j];
                ans = Math.max(ans, temp);
            }
        }
        
        //green : 3&4
        for(int i=1; i<=n-1; i++) {
            for(int j=1; j<=m-2; j++) {
                temp = paper[i+1][j]+paper[i+1][j+1]+paper[i][j+1]+paper[i][j+2];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i][j+1]+paper[i+1][j+1]+paper[i+1][j+2];
                ans = Math.max(ans, temp);
            }
        }
        
        //orange: 1&2&3&4
        for(int i=1; i<=n-2; i++) {
            for(int j=1; j<=m-1; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i+2][j]+paper[i+2][j+1];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i+1][j]+paper[i+2][j]+paper[i][j+1];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j+1]+paper[i+1][j+1]+paper[i+2][j+1]+paper[i+2][j];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i][j+1]+paper[i+1][j+1]+paper[i+2][j+1];
                ans = Math.max(ans, temp);
            }
        }
        
        //orange: 5&6&7&8
        for(int i=1; i<=n-1; i++) {
            for(int j=1; j<=m-2; j++) {
                temp = paper[i][j]+paper[i+1][j]+paper[i][j+1]+paper[i][j+2];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i][j+1]+paper[i][j+2]+paper[i+1][j+2];
                ans = Math.max(ans, temp);
                
                temp = paper[i][j]+paper[i+1][j]+paper[i+1][j+1]+paper[i+1][j+2];
                ans = Math.max(ans, temp);
                
                temp = paper[i+1][j]+paper[i+1][j+1]+paper[i+1][j+2]+paper[i][j+2];
                ans = Math.max(ans, temp);
            }
        }
        
        System.out.println(ans);
    }
}

[Gold 5] 1107번 리모컨

kmkunk — Fri, 1 Apr 2022 14:25:01 +0900

import java.io.*;

public class Main {
    public static boolean[] broken = new boolean[10];
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int m = Integer.parseInt(br.readLine());
        int ans = Math.abs(100-n);
        if(m==0) {
            ans = Math.min(ans, String.valueOf(n).length());
            System.out.println(ans); return;
        }
        
        String[] arr = br.readLine().split(" ");
        for(int i=0; i<m; i++) { broken[Integer.parseInt(arr[i])] = true; }
        for(int i=0; i<=1_000_000; i++) {
            if(check(i)==0) { continue; }
            ans = Math.min(ans, Math.abs(i-n)+check(i));
        }
        
        System.out.println(ans);
    }
    
    public static int check(int i) {
        int check = 0;
        if(i==0) {
            if(broken[i]) { return 0; }
            else { return 1; }
        }
        
        while(i>0) {
            int temp = i%10;
            if(broken[temp]) { return 0; }
            
            check++;
            i /= 10;
        }
        
        return check;
    }
}

[Silver 5] 1476번 날짜 계산

kmkunk — Fri, 1 Apr 2022 14:23:11 +0900

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] arr = br.readLine().split(" ");
        int[] esm = new int[4];
        int e = 1; int s = 1; int m = 1;
        
        for(int i=1; i<=3; i++) { esm[i] = Integer.parseInt(arr[i-1]); }
        
        for(int i=1; i<=7980; i++) {
            if(e==esm[1] && s==esm[2] && m==esm[3]) {
                System.out.println(i);
                return;
            }
            
            e++; s++; m++;
            
            e = (e-1)%15+1;
            s = (s-1)%28+1;
            m = (m-1)%19+1;
        }
    }
}

[Silver 3] 3085번 사탕 게임

kmkunk — Fri, 1 Apr 2022 14:21:16 +0900

import java.io.*;

public class Main {
    public static String[][] board;
    public static int n;
    public static int max;
        
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        board = new String[n+1][n+1];
        max = 1;
        
        for(int i=1; i<=n; i++) {
            String[] arr = br.readLine().split("");
            for(int j=1; j<=n; j++) { board[i][j] = arr[j-1]; }
        }
        
        for(int i=1; i<=n; i++) {
            for(int j=1; j<=n; j++) {
                if((i==n&&j==n) || max==n) { System.out.println(max); return; }
                
                countC(i, j);
                countR(i, j);
                
                if(i==n) {
                    swapC(i ,j);
                    countC(i, j);
                    countR(i, j);
                    countR(i, j+1);
                    swapC(i ,j);
                    continue;
                } else if(j==n) {
                    swapR(i ,j);
                    countR(i, j);
                    countC(i, j);
                    countC(i+1, j);
                    swapR(i ,j);
                    continue;
                }
                
                swapC(i ,j);
                countC(i, j);
                countR(i, j);
                countR(i, j+1);
                swapC(i ,j);
                
                swapR(i ,j);
                countR(i, j);
                countC(i, j);
                countC(i+1, j);
                swapR(i ,j);
            }
        }
        
        System.out.println(max);
    }
    
    public static void countC(int i, int j) {
        int count = 1;
        for(int k=2; k<=n; k++) {
            if(board[i][k].equals(board[i][k-1])) {
                count++;
                max = Math.max(max, count);
            } else { count = 1; }
        }        
    }
    
    public static void countR(int i, int j) {
        int count = 1;
        for(int k=2; k<=n; k++) {
            if(board[k][j].equals(board[k-1][j])) {
                count++;
                max = Math.max(max, count);
            } else { count = 1; }
        }        
    }
    
    public static void swapC(int i, int j) {
        String temp = board[i][j];
        board[i][j] = board[i][j+1];
        board[i][j+1] = temp;
    }
    
    public static void swapR(int i, int j) {
        String temp = board[i][j];
        board[i][j] = board[i+1][j];
        board[i+1][j] = temp;
    }
}

[Level 2] 조이스틱

kmkunk — Thu, 31 Mar 2022 16:37:39 +0900

class Solution {
    public int solution(String name) {
        int answer = 0;
        int count = name.length()-1;
        
        for(int i=0; i<name.length(); i++) {
            char c = name.charAt(i);
            int index = i+1;
            
            answer += c<'N' ? (c-'0')-('A'-'0') : 26-(c-'0')+('A'-'0');
            
            while(index<name.length() && name.charAt(index)=='A') { index++; }
            
            count = Math.min(count, name.length()-index+i*2);
            count = Math.min(count, (name.length()-index)*2+i);
        }
        
        return answer+count;
    }
}

[Level 2] 소수 찾기

kmkunk — Thu, 31 Mar 2022 16:36:35 +0900

import java.util.*;

class Solution {
    public boolean[] visited;    
    public String[] arr;
    public int answer = 0;
    public Set<Integer> set = new HashSet<>();
    
    public int solution(String numbers) {
        arr = numbers.split("");
        visited = new boolean[arr.length];
        
        for(int i=1; i<=arr.length; i++) { recur(0, i, ""); }
        
        return answer;
    }
    
    public void recur(int index, int len, String s) {
        if(index==len) {
            int n = Integer.parseInt(s);
            if(isPrime(n) && !set.contains(n)) {
                set.add(n);
                answer++;
            }
            
            return;
        }
        
        for(int i=0; i<arr.length; i++) {
            if(visited[i]) { continue; }
            
            visited[i] = true;
            recur(index+1, len, s+arr[i]);
            visited[i] = false;
        }
    }
    
    public boolean isPrime(int n) {
        if(n==0 || n==1) { return false; }
        
        for(int i=2; i*i<=n; i++) {
            if(n%i==0) { return false; }
        }
        
        return true;
    }
}

[Level 2] 가장 큰 수

kmkunk — Thu, 31 Mar 2022 16:36:09 +0900

import java.util.*;

class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        String[] arr = new String[numbers.length];
        
        for(int i=0; i<arr.length; i++) { arr[i] = String.valueOf(numbers[i]); }
        
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s2+s1).compareTo(s1+s2);
            }
        });
        
        for(String s : arr) { answer += s; }
        
        return answer;
    }
}

[Level 2] 프린터

kmkunk — Thu, 31 Mar 2022 16:35:35 +0900

import java.util.*;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 1;
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        
        for(int p : priorities) { pq.add(p); }
        
        while(!pq.isEmpty()) {
            for(int i=0; i<priorities.length; i++) {
                if(pq.peek()==priorities[i]) {
                    if(i==location) { return answer; }
                    
                    pq.poll();
                    answer++;
                }
            }
        }
        
        return answer;
    }
}

[Level 2] 전화번호 목록

kmkunk — Thu, 31 Mar 2022 16:35:02 +0900

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);
        
        for(int i=0; i<phone_book.length-1; i++) {
            if(phone_book[i+1].startsWith(phone_book[i])) { return false; }
        }
        
        return true;
    }
}

[Level 2] 튜플

kmkunk — Thu, 31 Mar 2022 16:34:34 +0900

import java.util.*;

class Solution {
    public int[] solution(String s) {
        List<String> list = new ArrayList<>();
        
        if(!s.contains("},{")) {
            return new int[]{Integer.parseInt(s.replace("{{","").replace("}}",""))};
        }
        
        String[] arr = s.split("\\}\\,\\{");
        for(int i=0; i<arr.length; i++) {
            arr[i] = arr[i].replace("{{","").replace("}}","");
        }
        
        Arrays.sort(arr, new Comparator<String>(){
            @Override
            public int compare(String s1, String s2) {
                return s1.length()-s2.length();
            }
        });
        
        int[] answer = new int[arr.length];
        list.add(arr[0]); answer[0] = Integer.parseInt(arr[0]);
        
        for(int i=1; i<answer.length; i++) {
            String[] ss = arr[i].split(",");
            for(String sss : ss) {
                if(list.contains(sss)) { continue; }
                
                list.add(sss); answer[i] = Integer.parseInt(sss);
                break;
            }
        }
        
        return answer;
    }
}

[Level 2] [1차] 뉴스 클러스터링

kmkunk — Thu, 31 Mar 2022 16:34:00 +0900

import java.util.*;

class Solution {
    public int solution(String str1, String str2) {
        int count = 0;
        PriorityQueue<String> pq1 = new PriorityQueue<>();
        PriorityQueue<String> pq2 = new PriorityQueue<>();
        
        str1 = str1.toUpperCase(); str2 = str2.toUpperCase();
        
        for(int i=0; i<str1.length()-1; i++) {
            char c1 = str1.charAt(i); char c2 = str1.charAt(i+1);
            if(!(c1>='A'&&c1<='Z'&&c2>='A'&&c2<='Z')) { continue; }
            
            pq1.add(String.valueOf(c1)+String.valueOf(c2));
        }
        
        for(int i=0; i<str2.length()-1; i++) {
            char c1 = str2.charAt(i); char c2 = str2.charAt(i+1);
            if(!(c1>='A'&&c1<='Z'&&c2>='A'&&c2<='Z')) { continue; }
            
            pq2.add(String.valueOf(c1)+String.valueOf(c2));
        }
        
        String[] s1 = new String[pq1.size()];
        String[] s2 = new String[pq2.size()];
        
        if(s1.length==0 && s2.length==0) { return 65536; }
        
        for(int i=0; i<s1.length; i++) { s1[i] = pq1.poll(); }
        for(int i=0; i<s2.length; i++) { s2[i] = pq2.poll(); }
        
        for(int i=0; i<s1.length; i++) {
            for(int j=0; j<s2.length; j++) {
                if(s1[i].equals(s2[j])) {
                    count++;
                    s2[j] = "0";
                    break;
                }
            }
        }
        
        double rate = (double)count/(s1.length+s2.length-count);
        
        return (int)(rate*65536);
    }
}

[Level 2] 짝지어 제거하기

kmkunk — Thu, 31 Mar 2022 16:32:47 +0900

import java.util.*;

class Solution {
    public int solution(String s) {
        Stack<Character> stack = new Stack<>();
        
        for(int i=0; i<s.length(); i++) {
            if(!stack.isEmpty() && stack.peek()==s.charAt(i)) {
                stack.pop();
                continue;
            }
            
            stack.push(s.charAt(i));
        }
        
        return stack.isEmpty() ? 1 : 0;
    }
}

[Level 2] 행렬 테두리 회전하기

kmkunk — Thu, 31 Mar 2022 16:31:31 +0900

import java.util.*;

class Solution {
    public int[] solution(int rows, int columns, int[][] queries) {
        int[] answer = new int[queries.length];
        int[][] arr = new int[rows][columns];
        int value = 1;
        
        for(int i=0; i<rows; i++) {
            for(int j=0; j<columns; j++) { arr[i][j] = value++; }
        }
        
        for(int i=0; i<queries.length; i++) {
            int x1 = queries[i][0]-1; int y1 = queries[i][1]-1;
            int x2 = queries[i][2]-1; int y2 = queries[i][3]-1;

            answer[i] = min(arr, x1, y1, x2, y2);
            
            int x1y2 = arr[x1][y2];
            int x2y1 = arr[x2][y1];
            int x2y2 = arr[x2][y2];
            
            for(int j=y2; j>y1; j--) { arr[x1][j] = arr[x1][j-1]; }
            for(int j=x2; j>x1+1; j--) { arr[j][y2] = arr[j-1][y2]; }
            for(int j=y1; j<y2-1; j++) { arr[x2][j] = arr[x2][j+1]; }
            for(int j=x1; j<x2-1; j++) { arr[j][y1] = arr[j+1][y1]; }
            
            arr[x1+1][y2] = x1y2;
            arr[x2-1][y1] = x2y1;
            arr[x2][y2-1] = x2y2;
        }
        
        return answer;
    }
    
    public int min(int[][] arr, int x1, int y1, int x2, int y2) {
        int min = Integer.MAX_VALUE;
        
        for(int i=x1; i<=x2; i++) {
            min = Math.min(min, arr[i][y1]);
            min = Math.min(min, arr[i][y2]);
        }
        
        for(int i=y1; i<=y2; i++) {
            min = Math.min(min, arr[x1][i]);
            min = Math.min(min, arr[x2][i]);
        }
        
        return min;
    }
}

[Level 2] 타겟 넘버

kmkunk — Thu, 31 Mar 2022 16:30:29 +0900

class Solution {
    public int answer = 0;
    
    public int solution(int[] numbers, int target) {
        recur(0, numbers, 0, target);
        
        return answer;
    }
    
    public void recur(int index, int[] numbers, int sum, int target) {
        if(index==numbers.length) {
            if(sum==target) { answer++; }
            
            return;
        }
        
        recur(index+1, numbers, sum+numbers[index], target);
        recur(index+1, numbers, sum-numbers[index], target);
    }
}