문제 설명

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다.

처음에 모든 심사대는 비어있습니다. 
한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다. 
가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다. 
하지만 더 빨리 끝나는 심사대가 있으면 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.

모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.

입국심사를 기다리는 사람 수 n, 각 심사관이 한 명을 심사하는데 걸리는 시간이 담긴 배열 times가 매개변수로 주어질 때, 모든 사람이 심사를 받는데 걸리는 시간의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

• 입국심사를 기다리는 사람은 1명 이상 1,000,000,000명 이하입니다.
• 각 심사관이 한 명을 심사하는데 걸리는 시간은 1분 이상 1,000,000,000분 이하입니다.
• 심사관은 1명 이상 100,000명 이하입니다.

풀이

1. 이분탐색. 변수 신경쓰기.

   결과

   import java.util.*;
   class Solution {
    static long answer = Long.MAX_VALUE;
    public long solution(int n, int[] times) {
        // 한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다.
        // 가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다.
        // 하지만!!
        // 더 빨리 끝나는 심사대가 있으면, 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.
   
        // 모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.
   
        // 파라메트릭 서치 - 매개변수 탐색
   
        Arrays.sort(times);
   
        long start = 0L;
        long end = (long) n * times[times.length-1];
        long mid = (start+end)/2;
   
        while(start <= end){
            mid = (start+end)/2L;
   
            long check = 0L;
            for(int time: times){
                check += mid / time;
                if(check >= n) break;
            }
   
            if(check >= n){
                answer = Math.min(answer, mid);
                end = mid - 1L;
            }else{
                start = mid + 1L;
            }
        }
   
        return answer;
    }
   }

문제 설명

주어진 항공권을 모두 이용하여 여행경로를 짜려고 합니다. 항상 "ICN" 공항에서 출발합니다.

항공권 정보가 담긴 2차원 배열 tickets가 매개변수로 주어질 때, 방문하는 공항 경로를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

• 모든 공항은 알파벳 대문자 3글자로 이루어집니다.
• 주어진 공항 수는 3개 이상 10,000개 이하입니다.
• tickets의 각 행 [a, b]는 a 공항에서 b 공항으로 가는 항공권이 있다는 의미입니다.
• 주어진 항공권은 모두 사용해야 합니다.
• 만일 가능한 경로가 2개 이상일 경우 알파벳 순서가 앞서는 경로를 return 합니다.
• 모든 도시를 방문할 수 없는 경우는 주어지지 않습니다.

풀이

1. dfs를 이용해서 순열로 풀기.

   결과

   import java.util.*;
   

class Solution { static int[][] route; static List list = new ArrayList<>();

static int N;
static List<String> result = new ArrayList<>();

static List<List<String>> perm = new ArrayList<>();
static String[] answer = {};

public String[] solution(String[][] tickets) {

    // 출발지 고정 : ICN(0)

    // 방향 그래프, 완전 탐색
    // bfs, dfs 둘다 상관없을 듯?

    // 공항 갯수 구하기
    list.add("ICN"); // ICN은 무조건 0번에서 시작.
    for(String[] ticket : tickets){
        if(!list.contains(ticket[0])) list.add(ticket[0]);
        if(!list.contains(ticket[1])) list.add(ticket[1]);
    }
    Collections.sort(list);      

    // 공항 경로 저장.
    N = list.size();
    route = new int[N][N];
    for(int i = 0; i < tickets.length; i++){
        String start = tickets[i][0];
        String end = tickets[i][1];

        int x = list.indexOf(start);
        int y = list.indexOf(end);

        route[x][y] += 1;
    }

    for(int i = 0; i < route.length; i++){
        int[] r = route[i];
    }

    int now = list.indexOf("ICN");
    result.add("ICN");
    dfs(0, now, tickets);

    answer = perm.get(0).toArray(new String[perm.get(0).size()]);

    return answer;
}

private void dfs(int depth, int now, String[][] tickets){
    if(depth == tickets.length){
        List<String> li = new ArrayList<>();
        for(String str: result){
            li.add(str);
        }
        perm.add(li);
        return;
    }
    for(int i = 0; i < N; i++){
        if(route[now][i] > 0){
            route[now][i] -= 1;
            result.add(list.get(i));
            dfs(depth+1, i, tickets);
            route[now][i] += 1;
            result.remove(result.size()-1);
        }
    }        
}

}

문제 설명

두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다.

1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.
2. words에 있는 단어로만 변환할 수 있습니다.

예를 들어 
begin이 "hit", target가 "cog", words가 
["hot","dot","dog","lot","log","cog"]라면 
"hit" -> "hot" -> "dot" -> "dog" -> "cog"와 같이 4단계를 거쳐 변환할 수 있습니다.

두 개의 단어 begin, target과 단어의 집합 words가 매개변수로 주어질 때, 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지 return 하도록 solution 함수를 작성해주세요.

제한사항

• 각 단어는 알파벳 소문자로만 이루어져 있습니다.
• 각 단어의 길이는 3 이상 10 이하이며 모든 단어의 길이는 같습니다.
• words에는 3개 이상 50개 이하의 단어가 있으며 중복되는 단어는 없습니다.
• begin과 target은 같지 않습니다.
• 변환할 수 없는 경우에는 0를 return 합니다.

풀이

1. bfs로 풀었으며, queue 이용, 최소값 구하는 문제

   결과

   import java.util.*;
   class Alpha{
    String word;
    int d;
   
    Alpha(String word, int d){
        this.word = word;
        this.d = d;
    }
   }
   class Solution {
    static int answer = 0;
    static boolean[] checked;
    public int solution(String begin, String target, String[] words) {
   
        // 한 번에 한 개의 알파벳만 바꿀 수 있습니다.
   
        // 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지
        // 최단 거리 같기도 하고? 일단 bfs로 풀어봄.
   
        // words에 있는 단어로만 변환할 수 있습니다.
        if(!Arrays.asList(words).contains(target)) return answer;
   
        checked = new boolean[words.length];
        for(int i = 0; i < words.length; i++){
            if(begin.equals(words[i])) checked[i] = true;
        }
   
        bfs(begin, target, words);
   
   

    return answer;
}

private void bfs(String begin, String target, String[] words){
    Queue<Alpha> que = new LinkedList<>();
    que.offer(new Alpha(begin, 0));

    while(!que.isEmpty()){
        Alpha ap = que.poll();

        if(ap.word.equals(target)){
            answer = ap.d;
            return;
        }

        for(int i = 0; i < words.length; i++){
            String wd = words[i];

            char[] wdrr = wd.toCharArray();
            char[] aprr = ap.word.toCharArray();
            int cnt = 0;
            for(int j = 0; j < wd.length(); j++){
                if(wdrr[j] == aprr[j]) cnt++;
            }

            if(cnt == wd.length()-1 && !checked[i]){
                checked[i] = true;
                que.offer(new Alpha(wd, ap.d+1));
            }
        }
    }  
}

} ```

문제 설명

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다.

예를 들어, 

컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 
컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 
컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다. 

따라서 컴퓨터 A, B, C는 모두 같은 네트워크 상에 있다고 할 수 있습니다.

컴퓨터의 개수 n, 연결에 대한 정보가 담긴 2차원 배열 computers가 매개변수로 주어질 때, 네트워크의 개수를 return 하도록 solution 함수를 작성하시오.

제한사항

• 컴퓨터의 개수 n은 1 이상 200 이하인 자연수입니다.
• 각 컴퓨터는 0부터 n-1인 정수로 표현합니다.
• i번 컴퓨터와 j번 컴퓨터가 연결되어 있으면 computers[i][j]를 1로 표현합니다.
• computer[i][i]는 항상 1입니다.

풀이

1. dfs로 풀이하였으며, 연결요소의 갯수를 구하는 문제

   결과

   import java.util.*;
   

class Solution { static int[][] network; static boolean[] checked; static int answer = 0;

public int solution(int n, int[][] computers) {
    // 컴퓨터 개수 n
    // 연결에 대한 정보 배열 computers
    // 네트워크의 개수(연결요소의 갯수) answer
    // 양방향 통신
    // i번과 j번 컴퓨터가 연결 되어 있으면 1, 아니면 0
    network = new int[n][n];

    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            if(computers[i][j] == 1 && i!=j) network[i][j] = 1;
        }
    }

    checked = new boolean[n]; 
    for(int i = 0; i < n; i++){
        if(!checked[i]){
            answer++;
            checked[i] = true;
            dfs(n,i);
        }
    }        
    return answer;
}

static void dfs(int n, int now){
    for(int j = 0; j < n; j++){
        if(network[now][j] == 1 && !checked[j]){
            checked[j] = true;
            dfs(n, j);
        }
    }
}

} ```

문제 설명

비내림차순(올림차순)으로 정렬된 수열이 주어질 때, 다음 조건을 만족하는 부분 수열을 찾으려고 합니다.

• 기존 수열에서 임의의 두 인덱스의 원소와 그 사이의 원소를 모두 포함하는 부분 수열이어야 합니다.
• 부분 수열의 합은 k입니다.
• 합이 k인 부분 수열이 여러 개인 경우 길이가 짧은 수열을 찾습니다.
• 길이가 짧은 수열이 여러 개인 경우 앞쪽(시작 인덱스가 작은)에 나오는 수열을 찾습니다.

수열을 나타내는 정수 배열 sequence와 부분 수열의 합을 나타내는 정수 k가 매개변수로 주어질 때, 위 조건을 만족하는 부분 수열의 시작 인덱스와 마지막 인덱스를 배열에 담아 return 하는 solution 함수를 완성해주세요. 이때 수열의 인덱스는 0부터 시작합니다.

제한사항

• 5 ≤ sequence의 길이 ≤ 1,000,000
  • 1 ≤ sequence의 원소 ≤ 1,000
  • sequence는 비내림차순으로 정렬되어 있습니다.
• 5 ≤ k ≤ 1,000,000,000
  • k는 항상 sequence의 부분 수열로 만들 수 있는 값입니다.

풀이

결과

import java.util.*;
class Indexes implements Comparable<Indexes>{
    int left;
    int right;
    int size;

    public Indexes(int left, int right){
        this.left = left;
        this.right = right;
        this.size = right-left;
    }

    @Override
    public int compareTo(Indexes o) {
        if(this.size == o.size){
            return this.left - o.left;
        }
        return this.size - o.size;
    }
}
class Solution {
    public int[] solution(int[] sequence, int k) {
        int[] answer = new int[2];
        List<Indexes> list = new ArrayList<>();

        int left = 0;
        int right = 0;
        int sum = sequence[0];
        int n = sequence.length;

        while(true){
            if(sum == k){
                list.add(new Indexes(left, right));
            }
            if(left == n && right == n) break;

            if(sum <= k && right < n){
                right++;
                if(right < n) sum += sequence[right];
            }else {
                if(left < n) sum -= sequence[left];
                left++;
            }      
        }

        Collections.sort(list, (x,y)->x.compareTo(y));

        answer[0] = list.get(0).left;
        answer[1] = list.get(0).right;


        return answer;
    }
}

문제 설명

영재는 택배상자를 트럭에 싣는 일을 합니다. 영재가 실어야 하는 택배상자는 크기가 모두 같으며 1번 상자부터 n번 상자까지 번호가 증가하는 순서대로 컨테이너 벨트에 일렬로 놓여 영재에게 전달됩니다.

컨테이너 벨트는 한 방향으로만 진행이 가능해서 벨트에 놓인 순서대로(1번 상자부터) 상자를 내릴 수 있습니다. 하지만 컨테이너 벨트에 놓인 순서대로 택배상자를 내려 바로 트럭에 싣게 되면 택배 기사님이 배달하는 순서와 택배상자가 실려 있는 순서가 맞지 않아 배달에 차질이 생깁니다. 따라서 택배 기사님이 미리 알려준 순서에 맞게 영재가 택배상자를 실어야 합니다.

만약 컨테이너 벨트의 맨 앞에 놓인 상자가 현재 트럭에 실어야 하는 순서가 아니라면 그 상자를 트럭에 실을 순서가 될 때까지 잠시 다른 곳에 보관해야 합니다. 하지만 고객의 물건을 함부로 땅에 둘 수 없어 보조 컨테이너 벨트를 추가로 설치하였습니다. 보조 컨테이너 벨트는 앞 뒤로 이동이 가능하지만 입구 외에 다른 면이 막혀 있어서 맨 앞의 상자만 뺄 수 있습니다(즉, 가장 마지막에 보조 컨테이너 벨트에 보관한 상자부터 꺼내게 됩니다). 보조 컨테이너 벨트를 이용해도 기사님이 원하는 순서대로 상자를 싣지 못 한다면, 더 이상 상자를 싣지 않습니다.

예를 들어, 
영재가 5개의 상자를 실어야 하며, 택배 기사님이 알려준 순서가 
기존의 컨테이너 벨트에 네 번째, 세 번째, 첫 번째, 두 번째, 다섯 번째 놓인 택배상자 순서인 경우, 

영재는 우선 첫 번째, 두 번째, 세 번째 상자를 보조 컨테이너 벨트에 보관합니다. 
그 후 네 번째 상자를 트럭에 싣고 보조 컨테이너 벨트에서 세 번째 상자 빼서 트럭에싣습니다. 
다음으로 첫 번째 상자를 실어야 하지만 보조 컨테이너 벨트에서는 두 번째 상자를, 
기존의 컨테이너 벨트에는 다섯 번째 상자를 꺼낼 수 있기 때문에 더이상의 상자는 실을 수 없습니다. 

따라서 트럭에는 2개의 상자만 실리게 됩니다.

택배 기사님이 원하는 상자 순서를 나타내는 정수 배열 order가 주어졌을 때, 영재가 몇 개의 상자를 실을 수 있는지 return 하는 solution 함수를 완성하세요.

제한사항

• 1 ≤ order의 길이 ≤ 1,000,000
• order는 1이상 order의 길이 이하의 모든 정수가 한번씩 등장합니다.
• order[i]는 기존의 컨테이너 벨트에 order[i]번째 상자를 i+1번째로 트럭에 실어야 함을 의미합니다.

풀이

결과

import java.util.*;
class Solution {
    public int solution(int[] order) {
        int answer = 0;
        Stack<Integer> subBalt = new Stack<>();

        int idx = 0;
        for(int i = 1; i <= order.length; i++){
            boolean flag = false;
            // 순서와 상자가 일치하는 경우
            if(order[idx] == i){
                answer++;
                idx++;
                flag = true;
            }
            // 보조 컨테이너 벨트가 비어있지 않고,
            // 마지막 상자가 순서에 일치하는 경우
            while(!subBalt.isEmpty() && subBalt.peek() == order[idx]){
                subBalt.pop();
                idx++;
                answer++;
                flag = true;
            }

            //보조 컨테이너 벨트에 적재
            if(!flag){
                subBalt.add(i);
            }
        }

        while(!subBalt.isEmpty() && subBalt.peek() == order[idx]){
            subBalt.pop();
            idx++;
            answer++;
        }
        return answer;
    }
}

💡Spring Framework에 대해 설명해주세요.

1. 각각의 객체 생성, 소멸과 같은 라이프 사이클을 관리하며 스프링으로부터 필요한 객체를 얻어올 수 있다.
2. 컨트롤의 제어권이 사용자가 아닌 프레임워크에 있어서 필요에 다라 스프링에서 사용자의 코드를 호출한다.
3. 각각의 계층이나 서비스들 간에 의존성이 존재할 경우 프레임워크가 서로 연결시켜준다.
4. 트랜잭션이나 로깅, 보안과 같이 여러 모듈에서 공통적으로 사용하는 기능의 경우 해당 기능을 분리하여 관리할 수 있다.

💡⭐Spring Filter와 Interceptor에 대해 설명하고, 사용 예시를 설명해주세요.

필터는 요청과 응답을 거른 뒤 정제하는 역할을 합니다.
필터 사용 사례 :
* 보안 및 인증/인가 관련 작업
* 모든 요청에 대한 로깅 또는 검사
* 이미지/데이터 압축 및 문자열 인코딩
* Spring과 분리되어야 하는 기능
인터셉터를 요청에 대한 작업 전/후로 가로채 요청과 응답을 참조하거나 가공하는 역할을 합니다.
인터셉터 사용 사례 :
* 세부적인 보안 및 인증/인가 공통 작업
* API 호출에 대한 로깅 또는 검사
* Controller로 넘겨주는 정보(데이터)의 가공

💡⭐Spring WebFlux에 대해 설명해주세요.

💡⭐관점지향 프로그래밍(AOP, Aspect Oriented Programming)는 무엇이고, 언제 사용할 수 있을까요?

💡⭐의존성 주입(DI, Dependency Injection)에 대해 설명해주세요.

💡@RequestBody, @RequestParam, @ModelAttribute의 차이를 설명해주세요.

💡Spring Boot와 Spring Framework의 차이점을 설명해주세요.

💡Spring MVC에 대해 설명해주세요.

Model: DAO, DTO, Service 등
View: html, jsp, tymeleaf, mustache 등 화면을 구성하기도 하고, Rest API로 서버가 구현된다면 json 응답으로 구성되기도 한다.
Controller: Model과 View는 서로 연결되어 있지 않기 때문에 Controller가 사이에서 통신 매체가 되어줍니다.

💡MVC는 어떠한 흐름으로 요청을 처리하는지 설명해주세요.

💡DispatcherServlet, HandlerMapping, HandlerAdapter, ViewResolver에 대해 설명해주세요.

💡제어의 역전(IoC, Inversion of Control)에 대해 아는대로 설명해주세요.

DI-Dependency Injection, IoC-Inversion of Control

💡IoC 컨테이너에 대해 설명해주세요.

* POJO(Plain Old Java Object)란? 
주로 특정 자바 모델이나 기능, 프레임워크를 따르지 않는 Java Object를 지칭한다.
Java Bean 객체가 대표적이다.
간단하게 getter / setter를 생각하면 될 것 같다.

💡스프링에서 빈(Bean)을 등록하는 방법에 대해 말해보세요.

💡스프링 빈의 라이프사이클은 어떻게 관리되는지 설명해주세요.

💡Lombok 라이브러리에 대해 알고 있나요? 알고 있다면 롬복이 만드는 메소드들이 생성되는 시점은 언제인가요?

Lombok 라이브러리를 추가할 때 CompileOnly, AnnotationProcessor를 추가하는 이유도 된다.

💡 서블릿(Servlet)에 대해 설명해주세요.

💡서블릿의 동작 방식에 대해 설명해주세요.

💡VO와 BO, DAO, DTO에 대해 설명해주세요.

DAO-Data Access Object, BO-Business Object, 
DTO-Data Transfer Object, DTO-Data Transfer Object,
VO-Value Object

💡 대용량 트래픽에서 장애가 발생하면 어떻게 대응할 것인가요?

💡Spring의 싱글톤 패턴에 대해 설명해주세요.

💡 Spring의 스코프 프로토 타입 빈에 대해 설명해주세요.

💡@Transactional의 동작 원리에 대해 설명해주세요.

💡@Transactional를 스프링 Bean의 메소드 A에 적용하였고, 해당 Bean의 메소드 B가 호출되었을 때, B 메소드 내부에서 A 메소드를 호출하면 어떤 요청 흐름이 발생하는지 설명해주세요.

A 메소드는 프록시로 감싸진 메소드가 아니므로 트랜잭션이 적용되지 않은 일반 코드가 수행됩니다.

💡A 라는 Service 객체의 메소드가 존재하고, 그 메소드 내부에서 로컬 트랜잭션 3개(다른 Service 객체의 트랜잭션 메소드를 호출했다는 의미)가 존재한다고 할 때, @Transactional을 A 메소드에 적용하면 어떤 요청 흐름이 발생하는지 설명해주세요.

💡@Transactional에 readOnly 속성을 사용하는 이유에 대해서 설명해주세요.

💡⭐JPA N + 1 문제와 발생하는 이유 그리고 해결하는 방법을 설명해주세요.

💡JPA와 같은 ORM을 사용하면서 쿼리가 복잡해지는 경우에는 어떻게 해결하는게 좋을까요?

💡Spring에서 CORS 에러를 해결하기 위한 방법을 설명해주세요.

💡JVM의 역할에 대해 설명해주세요.

💡Java의 컴파일 과정에 대해 설명해주세요.

💡Java에서 제공하는 원시 타입들에 무엇이 있고, 각각 몇 바이트를 차지하나요?

💡오버라이딩(Overriding)과 오버로딩(Overloading)에 대해 설명해주세요.

💡객체지향 프로그래밍(OOP)에 대해 설명해주세요.

💡try-with-resources에 대해 설명해주세요.

💡불변 객체가 무엇인지 설명하고 대표적인 Java의 예시를 설명해주세요.

💡불변 객체나 final을 굳이 사용해야 하는 이유가 있을까요?

💡추상 클래스와 인터페이스를 설명해주시고, 차이에 대해 설명해주세요.

💡싱글톤 패턴에 대해 설명해주세요.

💡싱글톤 패턴의 대표적인 예시를 간단하게 설명해주세요.

💡가비지 컬렉션(Garbage Collection)에 대해 설명해주세요.

💡가비지 컬렉션 과정에 대해 설명해주세요.

💡객체지향프로그래밍(OOP)에 대해 설명하세요

💡OOP의 4가지 특징에 대해 설명하세요

💡객체지향의 설계원칙(SOLID)에 대해 설명해주세요.

💡자바의 메모리 영역에 대해 설명해주세요.

💡각 메모리 영역이 할당되는 시점은 언제인가요?

💡클래스와 객체에 대해 설명해주세요.

💡생성자(Constructor)에 대해 설명해주세요.

💡 Wrapper Class란 무엇이며, Boxing과 UnBoxing은 무엇인지 설명해주세요.

💡Synchronized에 대해 아는 대로 말해주세요.

💡new String()과 리터럴("")의 차이에 대해 설명해주세요.

💡String, StringBuffer, StringBuilder의 차이를 설명해주세요.

💡String 객체가 불변인 이유에 대해 아는대로 설명해주세요.

💡 접근 제한자(Access Modifier)에 대해 설명해주세요.

public - 접근 제한이 없다. (같은 프로젝트 내 어디서든 사용 가능)
protected - 해당 패키지 내, 다른 패키지에서 상속받아 자손 클래스에서 접근 가능하다.
(default) - 해당 패키지 내에서만 접근 가능
private - 해당 클래스에서만 접근 가능

💡클래스 멤버 변수 초기화 순서에 대해 설명해주세요.

💡 static에 대해 설명해주세요.

💡static을 사용하는 이유에 대해 설명해주세요.

💡Inner Class(내부 클래스)의 장점에 대해 설명해주세요

💡⭐리플렉션(Reflection)이란 무엇인지 설명해주세요.

intelliJ의 자동완성 기능, 스프링의 어노테이션이 리플렉션을 이용한 기능

💡⭐Error와 Exception의 차이를 설명해주세요.

💡CheckedException과 UnCheckedException의 차이를 설명해주세요.

💡Optional API에 대해 설명해주세요.

💡⭐Collection Framework에 대해 설명해주세요.

💡⭐List, Set, Map, Stack, Queue의 특징에 대해 설명해주세요.

💡Array와 ArrayList의 차이점에 대해 설명하세요.

💡⭐HashMap와 Hashtable의 차이점에 대해 설명하세요.

다른 스레드가 block되고 unblock되는 대기 시간을 기다리기 때문

💡Java는 멀티 스레드(Multi Thread) 환경인데 멀티 스레드에 대해 설명하세요.

💡멀티 스레드를 사용하는 이유가 무엇인가요?

💡⭐Set과 Map의 타입이 Wrapper Class가 아닌 Object를 받을 때 중복 검사는 어떻게 할건지 설명해주세요.

💡Vector와 List의 차이를 설명해주세요.

💡⭐제네릭에 대해 설명해주시고, 왜 쓰는지 알려주세요.

💡final / finally / finalize 의 차이를 설명해주세요.

💡직렬화(Serialize)와 역직렬화에 대해 설명해주세요.

직렬화: JVM의 메모리에 상주(힙 or 스택)되어 있는 객체 데이터를 바이트 형태로 변환하는 기술

💡SerialVersionUID를 선언해야 하는 이유에 대해 설명해주세요.

참고 자료 1) 신입 개발자 기술면접 질문 정리 - 자바 참고 자료 2) 신입 백엔드 개발자 기술 면접 핵심 정리 - Java

👩‍🎓 Collection

1. List, Map, Set, Stack, Queue 인터페이스를 기준으로 여러 구현체가 존재.

2. 왜 collection을 사용?

• 다수의 데이터를 다루는데 표준화된 클래스들을 제공해주기 때문에 DataStructure를 직접 구현하지 않고 편하게 사용할 수 있기 때문이다.
• 배열과 다르게 객체를 보관하기 위한 공간을 미리 정하지 않아도 되므로, 상황에 따라 객체의 수를 동적으로 정할 수 있다.
• 프로그램의 공간적인 효율성을 높여준다.

3.List

• 직접 @Override를 통해 사용자가 정의하여 사용할 수도 있다.
• 대표적인 구현체
  • ArrayList(Vector개선), LinkedList

    4.Map

• key-value 구조로 이루어져 있다.
• key를 기준으로 중복된 값을 저장하지 않으여, 순서를 보장하지 않는다.
• 대표적인 구현체
  • HashMap, TreeMap(key값으로 정렬), LinkedHashMap(순서를 보장)

    5.Set

• value에 대해 중복된 값을 저장하지 않으며, 순서를 보장하지 않는다.
• 대표적인 구현체
  • HashSet, LinkedHashSet(순서를 보장)

    6.Stack

• 선형 자료구조.
• 나중에 들어온 원소가 가장 먼저 나온다.(LIFO)
• 먼저 들어간 원소가 나중에 나온다.(FILO)

  7.Queue

• 선형 자료 구조.
• 먼저 들어온 원소가 가장 먼저 나온다.(FIFO)
  • Priority Queue(트리구조)

👩‍🎓 Annotation

1. 본래 주석이란 뜻으로, 인터페이스를 기반으로 한 문법.

2. 주석처럼 코드에 달아 클래스에 특별한 의미를 부여하거나 기능을 주입할 수 있다.

3. 해석되는 시점을 정할 수 도 있다.

4. 종류

• Built-in annotation

  • 자바에 내장되어 있는 어노테이션.

  • 주로 컴파일러를 위한 것으로 컴파일러에게 유용한 정보 제공.

  • 대표적인 예

    @Override(현재메서드가 수퍼클래스의 메소드를 오버라이드한 메소드임을 명시)

        @Deprecated(더이상 사용하지 말아야 할 메소드 명시)
        @SupressWarning(프로그래머의 의도를 컴파일러에게 전달하여 경고를 제거)
        @FunctionalInterface(컴파일러에게 다음 인터페이스는 함수형 인터페이스 임을 알린다.)

• Meta annotation

  • 어노테이션에대한 정보를 나타내기위한 어노테이션

  • 어노테이션의 동작을 결정

  • 새로운 어노테이션 정의할 때 사용

  • 대표적인 예

    @Target(적용가능한 대상을 지정하는데 사용)
    @Retention(유지되는 기간을 정하는데 사용)
         RetentionPolicy (SOURCE, CLASS, RUNTIME)
    @Documented(jvavadoc으로 작성한 문서에 포함되도록 할 때 사용)
    @Inherited(자손클래스에도 상속되도록 함)
    @Native(네이티브 메서드에 의해 참조되는 상수 필드에 붙임)

• Custom annotation

  • 개발자가 직접 만들어내는 어노테이션

    public @Interface Annotation {}

    [reference] (https://asfirstalways.tistory.com/309)

👩‍🎓 Generic

1. 자바에서 안정성을 맡고 있다.

2. 다양한 타입의 객체들을 다루는 메서드나 컬렉션 클래스에서 사용하는 것으로 컴파일과정에서 타입체크를 해주는 기능이다.

3. 객체의 타입 안정성을 높이고 형변황의 번거로움을 줄여준다.

4. 코드도 간결해진다.

예를 들면, Collection 에 특정 객체만 추가될 수 있도록, 
또는 특정한 클래스의 특징을 갖고 있는 경우에만 추가될 수 있도록 하는 것

5. collection 내부에서 들어온 값이 내가 원하는 값인지 별도의 로직처리를 구현할 필요가 없어진다.

6. api 를 설계하는데 있어서 보다 명확한 의사전달이 가능해진다.

문제 설명

지원자가 지원서에 입력한 4가지의 정보와 획득한 코딩테스트 점수를 하나의 문자열로 구성한 값의 배열 info, 개발팀이 궁금해하는 문의조건이 문자열 형태로 담긴 배열 query가 매개변수로 주어질 때, 각 문의조건에 해당하는 사람들의 숫자를 순서대로 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

제한사항

• info 배열의 크기는 1 이상 50,000 이하입니다.
• info 배열 각 원소의 값은 지원자가 지원서에 입력한 4가지 값과 코딩테스트 점수를 합친 "개발언어 직군 경력 소울푸드 점수" 형식입니다.
  • 개발언어는 cpp, java, python 중 하나입니다.
  • 직군은 backend, frontend 중 하나입니다.
  • 경력은 junior, senior 중 하나입니다.
  • 소울푸드는 chicken, pizza 중 하나입니다.
  • 점수는 코딩테스트 점수를 의미하며, 1 이상 100,000 이하인 자연수입니다.
  • 각 단어는 공백문자(스페이스 바) 하나로 구분되어 있습니다.
• query 배열의 크기는 1 이상 100,000 이하입니다.
• query의 각 문자열은 "[조건] X" 형식입니다.
  • [조건]은 "개발언어 and 직군 and 경력 and 소울푸드" 형식의 문자열입니다.
  • 언어는 cpp, java, python, - 중 하나입니다.
  • 직군은 backend, frontend, - 중 하나입니다.
  • 경력은 junior, senior, - 중 하나입니다.
  • 소울푸드는 chicken, pizza, - 중 하나입니다.
  • '-' 표시는 해당 조건을 고려하지 않겠다는 의미입니다.
  • X는 코딩테스트 점수를 의미하며 조건을 만족하는 사람 중 X점 이상 받은 사람은 모두 몇 명인 지를 의미합니다.
  • 각 단어는 공백문자(스페이스 바) 하나로 구분되어 있습니다.
  • 예를 들면, "cpp and - and senior and pizza 500"은 "cpp로 코딩테스트를 봤으며, 경력은 senior 이면서 소울푸드로 pizza를 선택한 지원자 중 코딩테스트 점수를 500점 이상 받은 사람은 모두 몇 명인가?"를 의미합니다.

풀이

To-Do 리스트

1. 지원자 리스트와 채용 리스트를 생성.
2. 채용리스트에 지원자가 충족되면 1씩 더함.

결과

import java.util.*;

class Developer {
    String language;
    String subject;
    String career;
    String soulFood;
    int score;

    public Developer(String language, String subject, String career, String soulFood, int score){
        this.language = language;
        this.subject = subject;
        this.career = career;
        this.soulFood = soulFood;
        this.score = score;
    }

    @Override
    public String toString(){
        return "["+this.language+", "+this.subject+", "+this.career+", "+this.soulFood+", "+this.score+"]";
    }
}

class Solution {
    public int[] solution(String[] info, String[] query) {
        int[] answer = new int[query.length];
        int k = 0;

        List<Developer> list = new ArrayList<>();
        List<Developer> quelist = new ArrayList<>();

        for(String p: info){
            String[] srr = p.split(" ");
            Developer dp = new Developer(srr[0],srr[1],srr[2],srr[3],Integer.parseInt(srr[4]));
            list.add(dp);
        }

        for(String q : query){
            String[] srr = q.replaceAll("and ","").split(" ");
            Developer dp = new Developer(srr[0],srr[1],srr[2],srr[3],Integer.parseInt(srr[4]));
            quelist.add(dp);
        }

        for(Developer h: quelist){
            //System.out.println(h.toString());
            for(Developer v: list){
                if((h.language.equals(v.language) || h.language.equals("-"))
                  && (h.subject.equals(v.subject) || h.subject.equals("-"))
                  && (h.career.equals(v.career) || h.career.equals("-"))
                  && (h.soulFood.equals(v.soulFood) || h.soulFood.equals("-"))
                  && h.score <= v.score){
                    answer[k]++;
                    //System.out.println(">"+v.toString());
                }
            }
            k++;
        }

        return answer;
    }
}

알게 된 점

💥 효율성 테스트 0점. 💥 지원자를 기준으로 만들 수 있는 경우의 수를 map형태로 저장. 💥 map정렬시에 일일히 정렬하는 것보다 한번에 정리하면 시간단축이 가능. 💥 이분법으로 스코어보다 높은 사람의 수를 구함.

import java.util.*;

class Solution {
    static Map<String, List<Integer>> map = new HashMap<>();
    public void numberofcase(String[] srr, String str, int cnt){
        if(cnt == 4){
            if(!map.containsKey(str)){
                map.put(str, new ArrayList<>());
            }
            map.get(str).add(Integer.parseInt(srr[4]));
            return;
        }

        numberofcase(srr, str+"-", cnt+1);
        numberofcase(srr, str+srr[cnt], cnt+1);
    }

    public int[] solution(String[] info, String[] query) {
        int[] answer = new int[query.length];

        for(int i = 0; i < info.length; i++){
            String srr[] = info[i].split(" ");
            numberofcase(srr,"",0);
        }

        for(String key: map.keySet()){
            Collections.sort(map.get(key));
        }

        for(int i = 0; i < query.length; i++){
            String[] t = query[i].replaceAll(" and ","").split(" ");
            if(map.get(t[0]) != null){
                List<Integer> list = map.get(t[0]);
                int s = 0;
                int e = list.size()-1;
                while(s <= e){
                    int m = (s+e)/2;
                    if(list.get(m) < Integer.parseInt(t[1])){
                        s = m + 1;
                    }else {
                        e = m - 1;
                    }
                }
                answer[i] = list.size()-s;
            }
        }

        return answer;
    }
}

문제 설명

호텔을 운영 중인 코니는 최소한의 객실만을 사용하여 예약 손님들을 받으려고 합니다. 한 번 사용한 객실은 퇴실 시간을 기준으로 10분간 청소를 하고 다음 손님들이 사용할 수 있습니다.

예약 시각이 문자열 형태로 담긴 2차원 배열 book_time이 매개변수로 주어질 때, 코니에게 필요한 최소 객실의 수를 return 하는 solution 함수를 완성해주세요.

제한사항

• 1 ≤ book_time의 길이 ≤ 1,000
  • book_time[i]는 ["HH:MM", "HH:MM"]의 형태로 이루어진 배열입니다
    • [대실 시작 시각, 대실 종료 시각] 형태입니다.
    • 시각은 HH:MM 형태로 24시간 표기법을 따르며, "00:00" 부터 "23:59" 까지로 주어집니다.
      • 예약 시각이 자정을 넘어가는 경우는 없습니다.
      • 시작 시각은 항상 종료 시각보다 빠릅니다.

풀이

To-Do 리스트

1. 퇴실시간은 10분 더해서 저장.
2. 비교해서 작으면 역순으로 정렬 후, 리스트에서 제거.
3. 최소 퇴실시간 재지정.

   결과

   import java.util.*;
   

class Room{ String checkIn; String checkOut;

public Room(String checkIn, String checkOut){
    this.checkIn = checkIn;
    this.checkOut = checkOut;
}

}

class Solution { public int solution(String[][] book_time) { int answer = 1;

    Arrays.sort(book_time, (x,y)->x[0].compareTo(y[0]));

    List<Room> list = new ArrayList<>();

    String min = "";

    for(String[] rooms : book_time ){
        String[] end = rooms[1].split(":");
        int ehour = Integer.parseInt(end[0]);
        int emin = Integer.parseInt(end[1])+10;
        if(emin >= 60){
            ehour += 1;
            emin -= 60;
        }
        String co = String.format("%02d", ehour)+":"+String.format("%02d", emin);
        Room rm = new Room(rooms[0], co);

        if(!list.isEmpty()){
            //System.out.println(min+", "+rm.checkIn+"= "+min.compareTo(rm.checkIn));
            if(min.compareTo(rm.checkIn) <= 0 ){
                Collections.sort(list, (x,y)->x.checkOut.compareTo(y.checkOut));
                list.remove(0);
                if(!list.isEmpty()){
                    min = list.get(0).checkOut;
                }else {
                    min = "";
                }
            }else {
                answer++;
            }
            if(min.compareTo(rm.checkOut) > 0){
                min = rm.checkOut;
            }
        }else{
            min = rm.checkOut;
        }

        list.add(rm);
    }

    // for(Room r : list){
    //     System.out.printf("(%s, %s)\n",r.checkIn, r.checkOut);
    // }

    return answer;
}

}

문제 설명

좌표평면을 좋아하는 진수는 x축과 y축이 직교하는 2차원 좌표평면에 점을 찍으면서 놀고 있습니다. 진수는 두 양의 정수 k, d가 주어질 때 다음과 같이 점을 찍으려 합니다.

• 원점(0, 0)으로부터 x축 방향으로 a*k(a = 0, 1, 2, 3 ...), y축 방향으로 b*k(b = 0, 1, 2, 3 ...)만큼 떨어진 위치에 점을 찍습니다.
• 원점과 거리가 d를 넘는 위치에는 점을 찍지 않습니다.

예를 들어, 
k가 2, d가 4인 경우에는 (0, 0), (0, 2), (0, 4), (2, 0), (2, 2), (4, 0) 위치에
점을 찍어 총 6개의 점을 찍습니다.

정수 k와 원점과의 거리를 나타내는 정수 d가 주어졌을 때, 점이 총 몇 개 찍히는지 return 하는 solution 함수를 완성하세요.

제한사항

• 1 ≤ k ≤ 1,000,000
• 1 ≤ d ≤ 1,000,000

풀이

To-Do 리스트

결과

import java.util.*;

class Node {
    int x;
    int y;

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

class Solution {
    public long solution(int k, int d) {
        long answer = 0;
        //2차원 좌표평면 -> (+,+)
        //원점으로 부터 1~k까지, 1~k까지
        //단, 원점과의 거리가 d를 넘는 위치에는 점을 찍지 않는다.
        Node node = new Node(0,0);

        while(node.x <= d){
            //System.out.printf("(%d, %d)\n",node.x,node.y);
            double x2 = Math.ceil(Math.pow(node.x,2));
            double y2 = Math.ceil(Math.pow(node.y,2));

            double dis = Math.sqrt(x2 + y2);
            if(dis <= (double) d) {
                answer += 1;
                //System.out.printf("(%d, %d)\n",node.x,node.y);
            }
            node.y += k;
            if(node.y > d) {
                node.y = 0;
                node.x += k;
            }   
        }

        return answer;
    }
}

알게 된 점

💥 8,11,13,14 시간 초과.

import java.util.*;

class Solution {
    public long solution(int k, int d) {
        long answer = 0;
        //2차원 좌표평면 -> (+,+)
        //원점으로 부터 1~k까지, 1~k까지
        //단, 원점과의 거리가 d를 넘는 위치에는 점을 찍지 않는다.

        for(int i = 0; i <= d; i+=k){
            double x2 = Math.pow(i,2);
            double d2 = Math.pow(d,2);

            double dis = Math.sqrt(d2-x2);

            answer += (long)(dis/(long)k)+1;
        }

        return answer;
    }
}

문제 설명

어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.

예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.

문자열 형식으로 숫자 number와 제거할 수의 개수 k가 solution 함수의 매개변수로 주어집니다. number에서 k 개의 수를 제거했을 때 만들 수 있는 수 중 가장 큰 숫자를 문자열 형태로 return 하도록 solution 함수를 완성하세요.

제한사항

• number는 2자리 이상, 1,000,000자리 이하인 숫자입니다.
• k는 1 이상 number의 자릿수 미만인 자연수입니다.

풀이

To-Do 리스트

1. stack이 비어있는 경우, 수를 넣어준다.

2. stack의 마지막 값보다 넣으려는 수가 크고, 제거하려는 수 k 가 0보다 큰 경우에 아래를 반복한다. 2-1. 기존 stack값을 제거한다. 이때 제거하려는 수 k도 1을 감소한다. 2-2. 만약 그전에 stack이 비어버리거나 k가 0보다 작거나 같아지는 경우 반복을 멈춘다.

3. 넣으려는 수를 stack에 저장한다.

4. stack의 크기와 최종적으로 구할 수 있는 수의 길이가 같다면 반복을 멈춘다.

   결과

   import java.util.*;
   class Solution {
    public String solution(String number, int k) {
        String answer = "";
        Stack<Integer> stack = new Stack<>();
        char[] crr = number.toCharArray();
        for(int i = 0; i < crr.length; i++){
            char c = crr[i];
            int num = Integer.parseInt(String.valueOf(c));
            if(stack.isEmpty()){
                stack.add(num);
                continue;
            }
   
            while(stack.peek() < num && k > 0){
                stack.pop();
                k--;
                if(stack.isEmpty() || k <= 0) break;
            }
            stack.add(num);
            if(stack.size() == number.length()-k) break;
        }
   
        for(int i : stack){
            answer += i;
        }
        return answer;
    }
   }

문제 설명

철수는 롤케이크를 두 조각으로 잘라서 동생과 한 조각씩 나눠 먹으려고 합니다. 이 롤케이크에는 여러가지 토핑들이 일렬로 올려져 있습니다. 철수와 동생은 롤케이크를 공평하게 나눠먹으려 하는데, 그들은 롤케이크의 크기보다 롤케이크 위에 올려진 토핑들의 종류에 더 관심이 많습니다. 그래서 잘린 조각들의 크기와 올려진 토핑의 개수에 상관없이 각 조각에 동일한 가짓수의 토핑이 올라가면 공평하게 롤케이크가 나누어진 것으로 생각합니다.

롤케이크에 올려진 토핑들의 번호를 저장한 정수 배열 topping이 매개변수로 주어질 때, 롤케이크를 공평하게 자르는 방법의 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ topping의 길이 ≤ 1,000,000
  • 1 ≤ topping의 원소 ≤ 10,000

풀이

To-Do 리스트

1. p1에 토핑과 토핑의 수를 저장.
2. p2에 토핑을 나누면서 p1의 토핑의 수를 감소. 이때 토핑이 0개가 되면 제거.
3. p1의 갯수와 p2의 갯수가 같아지면 방법의 수를 1씩 증가.

   결과

   import java.util.*;
   

class Solution { public int solution(int[] topping) { int answer = 0; // 롤케이크를 두 조각으로 잘라서 동생과 나눠먹을 예정 // 롤케이크를 공평하게 나눠먹으려 함. // 롤케이크의 크기보다 롤케이크 위에 올려진 토핑들의 종류에 더 관심이 많음. // ** 잘린 조각들의 크기와 올려진 토핑의 개수에 상관없이 // 각 조각에 동일한 가짓수의 토핑이 올라가면 공평하게 롤케이크가 나누어진 것 Map<Integer,Integer> p1 = new HashMap<>(); Set p2 = new HashSet<>();

    for(int t : topping){
        p1.put(t, p1.getOrDefault(t,0)+1);
    }

    for(int i = 0; i < topping.length; i++){
        int t = topping[i];
        p2.add(t);
        p1.put(t, p1.get(t)-1);
        if(p1.get(t) == 0) p1.remove(t);

        if(p1.size() == p2.size()) answer++;
    }
    return answer;
}

}

문제 설명

자연수 x를 y로 변환하려고 합니다. 사용할 수 있는 연산은 다음과 같습니다.

• x에 n을 더합니다
• x에 2를 곱합니다.
• x에 3을 곱합니다.

자연수 x, y, n이 매개변수로 주어질 때, x를 y로 변환하기 위해 필요한 최소 연산 횟수를 return하도록 solution 함수를 완성해주세요. 이때 x를 y로 만들 수 없다면 -1을 return 해주세요.

제한사항

• 1 ≤ x ≤ y ≤ 1,000,000
• 1 ≤ n < y

풀이

To-Do 리스트

1. 처음 값을 넣고 구하려는 값보다 작거나 같은 수인 경우의 수의 값을 넣음.

2. 작거나 같은 수가 하나도 없는 경우 -1 리턴

3. 같은 수가 있다면 반복한 횟수 출력.

   결과

   import java.util.*;
   class Solution {
    public int solution(int x, int y, int n) {
        int answer = 0;
        // 경우의 수 : 3
        // x+n | x*2 | x*3
        // 최소 연산 횟수 구하기 (단, 만들수 없다면 -1)
        Set<Integer> list = new HashSet<>();
        Set<Integer> tmp = null;
        list.add(x);
   
        while(!list.isEmpty()){
            tmp = new HashSet<>();
            if(list.contains(y)) break;
   
            for(int i : list){
                if(i+n <= y) tmp.add(i+n);
                if(i*2 <= y) tmp.add(i*2);
                if(i*3 <= y) tmp.add(i*3);
            }
            list = tmp;
            answer++;
        }
        if(list.isEmpty()) answer = -1;
   
        return answer;
    }
   }

문제 설명

양의 정수 x에 대한 함수 f(x)를 다음과 같이 정의합니다. x보다 크고 x와 비트가 1~2개 다른 수들 중에서 제일 작은 수

예를 들어,

f(2) = 3 입니다. 2보다 큰 수들 중에서 비트가 다른 지점이 2개 이하이면서 제일 작은 수가 3이기 때문입니다.

f(7) = 11 입니다. 7보다 큰 수들 중에서 비트가 다른 지점이 2개 이하이면서 제일 작은 수가 11이기 때문입니다.

정수들이 담긴 배열 numbers가 매개변수로 주어집니다. numbers의 모든 수들에 대하여 각 수의 f 값을 배열에 차례대로 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ numbers의 길이 ≤ 100,000
• 0 ≤ numbers의 모든 수 ≤ 10¹⁵

풀이

To-Do 리스트

1. 기존 수에 1씩 더함.
2. 기존 수와 1를 더한 수를 xor연산, 그 수를 이진법으로 표현
3. 1의 갯수를 세서 2보다 커지면 break.
4. 반복완료 후 2보다 작거나 같은 수인 경우 break.
5. 해당 되지 않는 경우 1를 더함.
6. 반복하여 나온 값을 저장.

   결과

   import java.util.*;
   

class Solution { public long[] solution(long[] numbers) { long[] answer = new long[numbers.length]; // x보다 크고 x와 비트가 1~2개 다른 수들 중에서 제일 작은 수

    int k = 0;
    for(long num : numbers){
        long ins = num+1L;

        while(true){
            int cnt = 0;
            String str = Long.toBinaryString(num ^ ins);
            char[] crr = str.toCharArray();
            for(char c : crr){
                if(c == '1') cnt++;
                if(cnt > 2) break;
            }
            if(cnt <= 2) break;
            ins += 1L;
        }
        answer[k++] = ins;
    }
    return answer;
}

}

### 알게 된 점
> 💥 테스트 10, 11번 시간초과
> 💥 규칙을 찾아서 실행.

```java
import java.util.*;

class Solution {
    public long[] solution(long[] numbers) {
        long[] answer = new long[numbers.length];
        // x보다 크고 x와 비트가 1~2개 다른 수들 중에서 제일 작은 수

        int k = 0;
        for(long num : numbers){
            String str = Long.toBinaryString(num);
            char[] crr = str.toCharArray();

            int cnt = 0;           
            for(int i = crr.length-1; i >= 0; i--){
                char c = crr[i];
                if(c == '0') {
                    break;
                }
                cnt++;
            }
            answer[k++] = num+Math.round(Math.pow(2,cnt-1));

        }
        return answer;
    }
}

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.

예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

제한사항

• numbers의 길이는 1 이상 100,000 이하입니다.
• numbers의 원소는 0 이상 1,000 이하입니다.
• 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

풀이

To-Do 리스트

1. 숫자를 사전 순으로 정렬.

2. Comparator를 이용하여 현재 숫자와 이후 숫자를 비교.

3. 단, 0만 나오는 경우 는 수를 연결하지 않음.

   결과

   import java.util.*;
   class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        List<String> list = new ArrayList<>();
        for(int num : numbers){
            list.add(String.valueOf(num));
        }
        Collections.sort(list, new Comparator<String>(){
            public int compare(String s1, String s2) {
                return (s2+s1).compareTo(s1+s2);
            }
        });
   
        for(String s: list){
            if(answer.equals("0") && s.equals("0")) continue;
            answer += s;
        }
        return answer;
    }
   }

문제 설명

정수로 이루어진 배열 numbers가 있습니다. 배열 의 각 원소들에 대해 자신보다 뒤에 있는 숫자 중에서 자신보다 크면서 가장 가까이 있는 수를 뒷 큰수라고 합니다.

정수 배열 numbers가 매개변수로 주어질 때, 모든 원소에 대한 뒷 큰수들을 차례로 담은 배열을 return 하도록 solution 함수를 완성해주세요. 단, 뒷 큰수가 존재하지 않는 원소는 -1을 담습니다.

제한사항

• 4 ≤ numbers의 길이 ≤ 1,000,000
  • 1 ≤ numbers[i] ≤ 1,000,000

풀이

결과

import java.util.*;

class Solution {
    public int[] solution(int[] numbers) {
        int[] answer = new int[numbers.length];
        int k = 0;
        // 자신보다 1. 뒤에 있는 숫자 중에서 
        // 2. 자신보다 크면서 3. 가장 가까이 있는 수를 뒷 큰수
        // 모든 원소에 대한 뒷 큰수들을 차례로 담은 배열을 return 하도록 solution 함수를 완성
        // 단, 뒷 큰수가 존재하지 않는 원소는 -1
        Arrays.fill(answer, -1);

        for(int i = 0; i < numbers.length-1; i++ ){
            int num = numbers[i];
            int min = Integer.MAX_VALUE;
            for(int j = i+1; j < numbers.length; j++ ){
               int nNum = numbers[j];
               if(num < nNum) {
                   min = nNum;
                   break;
               }
            }
            answer[k++] = min==Integer.MAX_VALUE? -1 : min;
        }
        return answer;
    }
}

알게 된 점

💥 테스트 20 ~ 23 : 시간초과.

import java.util.*;

class Solution {
    public int[] solution(int[] numbers) {
        int[] answer = new int[numbers.length];
        // 자신보다 1. 뒤에 있는 숫자 중에서 
        // 2. 자신보다 크면서 3. 가장 가까이 있는 수를 뒷 큰수
        // 모든 원소에 대한 뒷 큰수들을 차례로 담은 배열을 return 하도록 solution 함수를 완성
        // 단, 뒷 큰수가 존재하지 않는 원소는 -1
        Arrays.fill(answer, -1);

        Stack<Integer> st = new Stack<>();
        for(int i = 0; i < numbers.length; i++){
            int num = numbers[i];
            while(!st.isEmpty() && numbers[st.peek()] < num){
                answer[st.pop()] = num;  
            }
            st.push(i);
        }
        return answer;
    }
}

문제 설명

가로 길이가 2이고 세로의 길이가 1인 직사각형모양의 타일이 있습니다. 이 직사각형 타일을 이용하여 세로의 길이가 2이고 가로의 길이가 n인 바닥을 가득 채우려고 합니다. 타일을 채울 때는 다음과 같이 2가지 방법이 있습니다.

타일을 가로로 배치 하는 경우
타일을 세로로 배치 하는 경우

예를들어서 n이 7인 직사각형은 다음과 같이 채울 수 있습니다.

직사각형의 가로의 길이 n이 매개변수로 주어질 때, 이 직사각형을 채우는 방법의 수를 return 하는 solution 함수를 완성해주세요.

제한사항

• 가로의 길이 n은 60,000이하의 자연수 입니다.
• 경우의 수가 많아 질 수 있으므로, 경우의 수를 1,000,000,007으로 나눈 나머지를 return해주세요.

풀이

결과

class Solution {
  public static int[] tile;

  public int solution(int n) {
    int answer = 0; 
    tile = new int[60000];
    tile[1] = 1;
    tile[2] = 2;

    for(int i = 3; i <= n; i++) {
      tile[i] = (tile[i-1]+ tile[i-2])%1000000007;
    }

    return tile[n];
  }
}

문제 설명

블라인드 공채를 통과한 신입 사원 라이언은 신규 게임 개발 업무를 맡게 되었다. 이번에 출시할 게임 제목은 프렌즈4블록 (같은 모양의 카카오프렌즈 블록이 2×2 형태로 4개가 붙어있을 경우 사라지면서 점수를 얻는 게임)이다.

만약 판이 위와 같이 주어질 경우, 라이언이 2×2로 배치된 7개 블록과 콘이 2×2로 배치된 4개 블록이 지워진다. 
같은 블록은 여러 2×2에 포함될 수 있으며, 지워지는 조건에 만족하는 2×2 모양이 여러 개 있다면 한꺼번에 지워진다.

블록이 지워진 후에 위에 있는 블록이 아래로 떨어져 빈 공간을 채우게 된다.

만약 빈 공간을 채운 후에 다시 2×2 형태로 같은 모양의 블록이 모이면 다시 지워지고 떨어지고를 반복하게 된다.

입력으로 블록의 첫 배치가 주어졌을 때, 지워지는 블록은 모두 몇 개인지 판단하는 프로그램을 제작하라.

입력 형식

• 입력으로 판의 높이 m, 폭 n과 판의 배치 정보 board가 들어온다.
• 2 ≦ n, m ≦ 30
• board는 길이 n인 문자열 m개의 배열로 주어진다. 블록을 나타내는 문자는 대문자 A에서 Z가 사용된다.

출력 형식

• 입력으로 주어진 판 정보를 가지고 몇 개의 블록이 지워질지 출력하라.

풀이

결과

import java.util.*;

class Solution {
  static boolean[][] visited;

  public int solution(int m, int n, String[] board) {
    int answer = 0;
    char game[][] = new char [m][n];

    // game판에 정보저장.
    for (int i = 0; i < board.length; i++) {
      String b = board[i];
      char[] brr = b.toCharArray();
      for (int j = 0; j < brr.length; j++) {
        char c = brr[j];
        game[i][j] = c;
      }
    }   

    boolean flag = true;
    while(flag) {
      flag = false;
      visited = new boolean[m][n];
      for (int i = 0; i < m - 1; i++) {
        for (int j = 0; j < n - 1; j++) {
          if(game[i][j] == '#') continue;
          if (check(i,j,game)) {
            visited[i][j] = true;
            visited[i + 1][j] = true;
            visited[i][j + 1] = true;
            visited[i + 1][j + 1] = true;
            flag = true;
          }
        }
      }
      answer = remove(m,n,game);
      visited = new boolean[m][n];
    }

    return answer;
  }

  private static boolean check(int x, int y, char[][] game) {
    char ch = game[x][y];
    if(ch == game[x][y+1] && ch== game[x+1][y] && ch == game[x+1][y+1]){
        return true;
    }
    return false;
  }

  private static int remove(int m, int n, char[][] game) {
    int cnt = 0;
    for(int i=0; i<m; i++){
        for(int j=0; j<n; j++){
            if(visited[i][j]) game[i][j] = '#';
        }
    }

    for(int i=0; i<n; i++) {
      Queue<Character> que = new LinkedList<>();
      for(int j=m-1; j>=0; j--) {
        if(game[j][i] == '#') cnt++;
        else que.add(game[j][i]);
      }
      int idx = m-1;
      while(!que.isEmpty()) {
        game[idx--][i] = que.poll();
      }
      for(int j = idx; j >= 0; j--) {
        game[j][i] = '#';
      }
    }
    return cnt;
  }
}

알게 된 점

💥 객체지향적사고방식으로 풀어보자.