뚝딱뚝딱 개발소

[프로그래머스/코딩 테스트] 귤 고르기(JAVA)

"주인장" — Thu, 25 Sep 2025 19:44:32 +0900

문제설명

경화는 과수원에서 귤을 수확했습니다. 경화는 수확한 귤 중 'k'개를 골라 상자 하나에 담아 판매하려고 합니다. 그런데 수확한 귤의 크기가 일정하지 않아 보기에 좋지 않다고 생각한 경화는 귤을 크기별로 분류했을 때 서로 다른 종류의 수를 최소화하고 싶습니다.

예를 들어, 경화가 수확한 귤 8개의 크기가 [1, 3, 2, 5, 4, 5, 2, 3] 이라고 합시다. 경화가 귤 6개를 판매하고 싶다면, 크기가 1, 4인 귤을 제외한 여섯 개의 귤을 상자에 담으면, 귤의 크기의 종류가 2, 3, 5로 총 3가지가 되며 이때가 서로 다른 종류가 최소일 때입니다.

경화가 한 상자에 담으려는 귤의 개수 k와 귤의 크기를 담은 배열 tangerine이 매개변수로 주어집니다. 경화가 귤 k개를 고를 때 크기가 서로 다른 종류의 수의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한 사항

1 ≤ k ≤ tangerine의 길이 ≤ 100,000
1 ≤ tangerine의 원소 ≤ 10,000,000

문제 풀이

// 귤 크기별로 몇 개씩 있는지 저장할 HashMap
HashMap<Integer, Integer> map = new HashMap<>();

● 귤 크기별로 몇개씩 있는지 map에 저장한다.

// tangerine 배열을 순회하면서 귤 크기별 개수를 집계합니다.
for(int i : tangerine) {
    map.put(i, map.getOrDefault(i, 0) + 1);
}

● tangerine 배열을 순회하면서 귤 크기별 개수를 집계한다.

// 귤 크기들만 추출해서 리스트로 만들기
List<Integer> list = new ArrayList<>(map.keySet());

// 귤 개수가 많은 순서대로 정렬
list.sort((o1,o2) -> map.get(o2) - map.get(o1));

● 귤 크기들만 추출해서 리스트로 만든 후 귤 개수가 많은 순서대로 정렬한다.

for(int i : list) {
    // 정렬된 리스트를 순회하면서 귤 담기
    k -= map.get(i);

    // 사용한 귤 종류 수 증가
    answer++;

    // 목표 개수 이상 담았으면 종료
    if(k<=0) break;
}

● 정렬된 리스트를 순회하면서 귤을 담고 answer 변수를 사용하여 귤 종류 수를 중가시킨다. k = 0이 되었을 때는 목표를 달성하였기 때문에 for문을 종료한다.

전체 코드

import java.util.*;

class Solution {
    public int solution(int k, int[] tangerine) {
        int answer = 0;
        
        // 귤 크기별로 몇 개씩 있는지 저장할 HashMap
        HashMap<Integer, Integer> map = new HashMap<>();
        
        // tangerine 배열을 순회하면서 귤 크기별 개수를 집계합니다.
        for(int i : tangerine) {
            map.put(i, map.getOrDefault(i, 0) + 1);
        }
        
        // 귤 크기들만 추출해서 리스트로 만들기
        List<Integer> list = new ArrayList<>(map.keySet());
        
        // 귤 개수가 많은 순서대로 정렬
        list.sort((o1,o2) -> map.get(o2) - map.get(o1));
        
        for(int i : list) {
            // 정렬된 리스트를 순회하면서 귤 담기
            k -= map.get(i);
            
            // 사용한 귤 종류 수 증가
            answer++;
            
            // 목표 개수 이상 담았으면 종료
            if(k<=0) break;
        }
        
        return answer;
    }
}

[프로그래머스/코딩 테스트] 롤케이크 자르기(JAVA)

"주인장" — Wed, 24 Sep 2025 20:53:11 +0900

문제설명

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

예를 들어, 롤케이크에 4가지 종류의 토핑이 올려져 있다고 합시다. 토핑들을 1, 2, 3, 4와 같이 번호로 표시했을 때, 케이크 위에 토핑들이 [1, 2, 1, 3, 1, 4, 1, 2] 순서로 올려져 있습니다. 만약 세 번째 토핑(1)과 네 번째 토핑(3) 사이를 자르면 롤케이크의 토핑은 [1, 2, 1], [3, 1, 4, 1, 2]로 나뉘게 됩니다. 철수가 [1, 2, 1]이 놓인 조각을, 동생이 [3, 1, 4, 1, 2]가 놓인 조각을 먹게 되면 철수는 두 가지 토핑(1, 2)을 맛볼 수 있지만, 동생은 네 가지 토핑(1, 2, 3, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것이 아닙니다. 만약 롤케이크의 네 번째 토핑(3)과 다섯 번째 토핑(1) 사이를 자르면 [1, 2, 1, 3], [1, 4, 1, 2]로 나뉘게 됩니다. 이 경우 철수는 세 가지 토핑(1, 2, 3)을, 동생도 세 가지 토핑(1, 2, 4)을 맛볼 수 있으므로, 이는 공평하게 나누어진 것입니다. 공평하게 롤케이크를 자르는 방법은 여러가지 일 수 있습니다. 위의 롤케이크를 [1, 2, 1, 3, 1], [4, 1, 2]으로 잘라도 공평하게 나뉩니다. 어떤 경우에는 롤케이크를 공평하게 나누지 못할 수도 있습니다.

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

제한사항

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

문제풀이

int count = 0;		   // result 값
int n = topping.length;	   // 매개변수 topping의 길이 

int[] left = new int[n];   // 왼쪽 토핑 종류 수
int[] right = new int[n];  // 오른쪽 토핑 종류 수

Set<Integer> leftSet = new HashSet<>();
Set<Integer> rightSet = new HashSet<>();

왼쪽과 오른쪽으로 구분하여 변수를 구현하였으며, 자료구조는 Set를 사용했다. 이유는 Set은 값을 중복으로 가지지 않아 종류를 비교할 때 편리하기 때문이다.

// 왼쪽
for (int i = 0; i < n; i++) {
    leftSet.add(topping[i]);
    left[i] = leftSet.size();
}

// 오른쪽
for (int i = n-1; i >= 0; i--) {
    rightSet.add(topping[i]);
    right[i] = rightSet.size();
}

leftSet(왼쪽)과 rightSet(오른쪽)에 매개변수 topping의 값을 담고 left, right 변수를 사용해 종류의 총 개수를 담습니다.

// 자르기
for(int i = 0; i < n-1; i++) {
    if(left[i] == right[i+1]) {
        count++;
    }
}

위에서 left과 right를 구분하였기 때문에 모든 구간을 잘라 비교하여 토핑의 종류의 개수가 동일한지 확인한 후 동일한 경우 카운트 +1을 합니다.

전체 코드

import java.util.*;

class Solution {
    public int solution(int[] topping) {
        int count = 0;
        int n = topping.length;
        
        int[] left = new int[n];
        int[] right = new int[n];
        
        Set<Integer> leftSet = new HashSet<>();
        Set<Integer> rightSet = new HashSet<>();
        
        // 왼쪽
        for (int i = 0; i < n; i++) {
            leftSet.add(topping[i]);
            left[i] = leftSet.size();
        }
        
        // 오른쪽
        for (int i = n-1; i >= 0; i--) {
            rightSet.add(topping[i]);
            right[i] = rightSet.size();
        }
        
        // 자르기
        for(int i = 0; i < n-1; i++) {
            if(left[i] == right[i+1]) {
                count++;
            }
        }
        
        return count;
    }
}

[프로그래머스/코딩테스트] 오픈채팅방(JAVA)

"주인장" — Mon, 22 Sep 2025 22:22:40 +0900

문제 설명

카카오톡 오픈채팅방에서는 친구가 아닌 사람들과 대화를 할 수 있는데, 본래 닉네임이 아닌 가상의 닉네임을 사용하여 채팅방에 들어갈 수 있다.

신입사원인 김크루는 카카오톡 오픈 채팅방을 개설한 사람을 위해, 다양한 사람들이 들어오고, 나가는 것을 지켜볼 수 있는 관리자창을 만들기로 했다. 채팅방에 누군가 들어오면 다음 메시지가 출력된다.

"[닉네임]님이 들어왔습니다."

채팅방에서 누군가 나가면 다음 메시지가 출력된다.

"[닉네임]님이 나갔습니다."

채팅방에서 닉네임을 변경하는 방법은 다음과 같이 두 가지이다.

채팅방을 나간 후, 새로운 닉네임으로 다시 들어간다.
채팅방에서 닉네임을 변경한다.
닉네임을 변경할 때는 기존에 채팅방에 출력되어 있던 메시지의 닉네임도 전부 변경된다.

예를 들어, 채팅방에 "Muzi"와 "Prodo"라는 닉네임을 사용하는 사람이 순서대로 들어오면 채팅방에는 다음과 같이 메시지가 출력된다.

"Muzi님이 들어왔습니다."
"Prodo님이 들어왔습니다."

채팅방에 있던 사람이 나가면 채팅방에는 다음과 같이 메시지가 남는다.

"Muzi님이 들어왔습니다."
"Prodo님이 들어왔습니다."
"Muzi님이 나갔습니다."

Muzi가 나간후 다시 들어올 때, Prodo 라는 닉네임으로 들어올 경우 기존에 채팅방에 남아있던 Muzi도 Prodo로 다음과 같이 변경된다.

"Prodo님이 들어왔습니다."
"Prodo님이 들어왔습니다."
"Prodo님이 나갔습니다."
"Prodo님이 들어왔습니다."

채팅방은 중복 닉네임을 허용하기 때문에, 현재 채팅방에는 Prodo라는 닉네임을 사용하는 사람이 두 명이 있다. 이제, 채팅방에 두 번째로 들어왔던 Prodo가 Ryan으로 닉네임을 변경하면 채팅방 메시지는 다음과 같이 변경된다.

"Prodo님이 들어왔습니다."
"Ryan님이 들어왔습니다."
"Prodo님이 나갔습니다."
"Prodo님이 들어왔습니다."

채팅방에 들어오고 나가거나, 닉네임을 변경한 기록이 담긴 문자열 배열 record가 매개변수로 주어질 때, 모든 기록이 처리된 후, 최종적으로 방을 개설한 사람이 보게 되는 메시지를 문자열 배열 형태로 return 하도록 solution 함수를 완성하라.

제한사항

record는 다음과 같은 문자열이 담긴 배열이며, 길이는 1 이상 100,000 이하이다.
다음은 record에 담긴 문자열에 대한 설명이다.
모든 유저는 [유저 아이디]로 구분한다.
[유저 아이디] 사용자가 [닉네임]으로 채팅방에 입장 - "Enter [유저 아이디] [닉네임]" (ex. "Enter uid1234 Muzi")
[유저 아이디] 사용자가 채팅방에서 퇴장 - "Leave [유저 아이디]" (ex. "Leave uid1234")
[유저 아이디] 사용자가 닉네임을 [닉네임]으로 변경 - "Change [유저 아이디] [닉네임]" (ex. "Change uid1234 Muzi")
첫 단어는 Enter, Leave, Change 중 하나이다.
각 단어는 공백으로 구분되어 있으며, 알파벳 대문자, 소문자, 숫자로만 이루어져있다.
유저 아이디와 닉네임은 알파벳 대문자, 소문자를 구별한다.
유저 아이디와 닉네임의 길이는 1 이상 10 이하이다.
채팅방에서 나간 유저가 닉네임을 변경하는 등 잘못 된 입력은 주어지지 않는다.

문제풀이

// 유저 아이디 저장
Map<String, String> userMap = new HashMap<>(); 

// 출력용 로그 저장
List<String[]> logs = new ArrayList<>();

Map을 통해서 유저 아이디를 저장하고, List를 통해 출력용 로그를 저장한다.

for(String rec : record) {
    //record " "로 분리
    String[] parts = rec.split(" ");

    // record에서 분리된 값 변수에 담기
    String action = parts[0];
    String uId = parts[1];

	...

}

매개변수로 받은 record 값을 split로 분리시킨 후 변수를 사용해 값을 저장한다.

// 입장
if(action.equals("Enter")) {
    String nickName = parts[2];
    userMap.put(uId, nickName);
    logs.add(new String[]{action, uId});
// 퇴장
}else if(action.equals("Leave")) {
    logs.add(new String[]{action, uId});
// 닉네임 변경
}else if(action.equals("Change")) {
    String nickname = parts[2];
    userMap.put(uId, nickname);
}

입장, 퇴장, 닉네임 변경을 구분하여 if문 작성 후 값 저장

// 결과 리스트
List<String> result = new ArrayList<>();
for(String[] log : logs) {
    String action = log[0];
    String uId = log[1];
    String nickname = userMap.get(uId);

    // 입장 메시지 생성
    if (action.equals("Enter")) {
        result.add(nickname + "님이 들어왔습니다.");
    // 퇴장 메시지 생성    
    } else if (action.equals("Leave")) {
        result.add(nickname + "님이 나갔습니다.");
    }
}

위에 if문에서 모든 경우의 값을 저장하였으므로, 여기 코드에서는 출력을 위한 입장 메시지, 퇴장 메시지 코드를 작성합니다.

전체코드

import java.util.*;

class Solution {
    public String[] solution(String[] record) {
        // 유저 아이디 저장
        Map<String, String> userMap = new HashMap<>(); 
        
        // 출력용 로그 저장
        List<String[]> logs = new ArrayList<>();
        
        for(String rec : record) {
            //record " "로 분리
            String[] parts = rec.split(" ");
            
            // record에서 분리된 값 변수에 담기
            String action = parts[0];
            String uId = parts[1];
            
            // 입장
            if(action.equals("Enter")) {
                String nickName = parts[2];
                userMap.put(uId, nickName);
                logs.add(new String[]{action, uId});
            // 퇴장
            }else if(action.equals("Leave")) {
                logs.add(new String[]{action, uId});
            // 닉네임 변경
            }else if(action.equals("Change")) {
                String nickname = parts[2];
                userMap.put(uId, nickname);
            }
            
        }
        
        // 결과 리스트
        List<String> result = new ArrayList<>();
        for(String[] log : logs) {
            String action = log[0];
            String uId = log[1];
            String nickname = userMap.get(uId);
            
            // 입장 메시지 생성
            if (action.equals("Enter")) {
                result.add(nickname + "님이 들어왔습니다.");
            // 퇴장 메시지 생성    
            } else if (action.equals("Leave")) {
                result.add(nickname + "님이 나갔습니다.");
            }
        }
        
        
        return result.toArray(new String[0]);
    }
}

[프로그래머스/코딩테스트] 택배 상자 꺼내기(JAVA)

"주인장" — Sat, 20 Sep 2025 21:41:21 +0900

문제설명

1 ~ n의 번호가 있는 택배 상자가 창고에 있습니다. 당신은 택배 상자들을 다음과 같이 정리했습니다.

왼쪽에서 오른쪽으로 가면서 1번 상자부터 번호 순서대로 택배 상자를 한 개씩 놓습니다. 가로로 택배 상자를 w개 놓았다면 이번에는 오른쪽에서 왼쪽으로 가면서 그 위층에 택배 상자를 한 개씩 놓습니다. 그 층에 상자를 w개 놓아 가장 왼쪽으로 돌아왔다면 또다시 왼쪽에서 오른쪽으로 가면서 그 위층에 상자를 놓습니다. 이러한 방식으로 n개의 택배 상자를 모두 놓을 때까지 한 층에 w개씩 상자를 쌓습니다.

프로그래머스 택배 상자 꺼내기

위 그림은 w = 6일 때 택배 상자 22개를 쌓은 예시입니다.
다음 날 손님은 자신의 택배를 찾으러 창고에 왔습니다. 당신은 손님이 자신의 택배 상자 번호를 말하면 해당 택배 상자를 꺼내줍니다. 택배 상자 A를 꺼내려면 먼저 A 위에 있는 다른 모든 상자를 꺼내야 A를 꺼낼 수 있습니다. 예를 들어, 위 그림에서 8번 상자를 꺼내려면 먼저 20번, 17번 상자를 꺼내야 합니다.

당신은 꺼내려는 상자 번호가 주어졌을 때, 꺼내려는 상자를 포함해 총 몇 개의 택배 상자를 꺼내야 하는지 알고 싶습니다.

창고에 있는 택배 상자의 개수를 나타내는 정수 n, 가로로 놓는 상자의 개수를 나타내는 정수 w와 꺼내려는 택배 상자의 번호를 나타내는 정수 num이 매개변수로 주어집니다. 이때, 꺼내야 하는 상자의 총개수를 return 하도록 solution 함수를 완성해 주세요.

제한사항

2 ≤ n ≤ 100
1 ≤ w ≤ 10
1 ≤ num ≤ n

문제 풀이

// 상자 번호는 1부터 시작하고 배열은 0부터 시작
int index = num -1;

// 해당 상자가 몇 층(layer)에 있는지 계산
int layer = index / w;

// 해당 상자가 층 내에서 몇 번째 열에 존재하는지
int col;

로직에 필요한 변수를 선언한다.

if(layer % 2 == 0) {
    // 왼쪽에서 오른쪽
    col = index % w;
}else {
    // 오른쪽에서 왼쪽
    col = w - 1 - (index % w);
}

상자를 쌓을 때, 짝수는 왼쪽에서 오른쪽이고 홀수는 오른쪽에서 왼쪽이다.

// 위에 쌓인 상자 개수 카운트
int count = 0;

// 위에 있는 층들에서 같은 col에 있는 상자 수 세기
for(int i = layer + 1; ; i++) {
    // i층에서 col 위치에 있는 상자 번호
    int upperBoxNum;

    if(i % 2 == 0) {
        // 짝수층은 왼쪽에서 오른쪽으로
        upperBoxNum = i * w + col + 1;
    }else {
        // 홀수층은 오른쪽에서 왼쪽으로
        upperBoxNum = (i + 1) * w - col;
    }

    // 상자 번호가 전체 상자 개수 n을 초과하면
    if (upperBoxNum > n) {
        break;   
    }

    // 존재하는 상자이므로 꺼내야 하는 상자 수 증가
    count++;

}

목표 상자까지 몇 개의 상자를 제거해야하는지에 관한 로직으로 가장 중요한 부분은 i층에서 col 위치에 있는 상자 번호를 찾는 것이다.

// 자기 자신 포함하여 총 개수 반환  
return count + 1;

결과 값을 return한다. 여기서 중요한 점은 위의 로직에서 자기 자신을 제외하였기 때문에 자기 자신을 포함하기 위해 +1 한다.

전체 코드

class Solution {
    public int solution(int n, int w, int num) {
        // 상자 번호는 1부터 시작하고 배열은 0부터 시작
        int index = num -1;
        
        // 해당 상자가 몇 층(layer)에 있는지 계산
        int layer = index / w;
        
        // 해당 상자가 층 내에서 몇 번째 열에 존재하는지
        int col;
        
       
        if(layer % 2 == 0) {
            // 왼쪽에서 오른쪽
            col = index % w;
        }else {
            // 오른쪽에서 왼쪽
            col = w - 1 - (index % w);
        }
        
        // 위에 쌓인 상자 개수 카운트
        int count = 0;
        
        // 위에 있는 층들에서 같은 col에 있는 상자 수 세기
        for(int i = layer + 1; ; i++) {
            // i층에서 col 위치에 있는 상자 번호
            int upperBoxNum;
            
            if(i % 2 == 0) {
                // 짝수층은 왼쪽에서 오른쪽으로
                upperBoxNum = i * w + col + 1;
            }else {
                // 홀수층은 오른쪽에서 왼쪽으로
                upperBoxNum = (i + 1) * w - col;
            }
            
            // 상자 번호가 전체 상자 개수 n을 초과하면
            if (upperBoxNum > n) {
                break;   
            }
            
            // 존재하는 상자이므로 꺼내야 하는 상자 수 증가
            count++;
            
        }
        
      // 자기 자신 포함하여 총 개수 반환  
      return count + 1;
    }
}

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/코딩테스트] 삼총사(JAVA)

"주인장" — Fri, 19 Sep 2025 21:43:20 +0900

안녕하세요!

문제설명

한국중학교에 다니는 학생들은 각자 정수 번호를 갖고 있습니다. 이 학교 학생 3명의 정수 번호를 더했을 때 0이 되면 3명의 학생은 삼총사라고 합니다. 예를 들어, 5명의 학생이 있고, 각각의 정수 번호가 순서대로 -2, 3, 0, 2, -5일 때, 첫 번째, 세 번째, 네 번째 학생의 정수 번호를 더하면 0이므로 세 학생은 삼총사입니다. 또한, 두 번째, 네 번째, 다섯 번째 학생의 정수 번호를 더해도 0이므로 세 학생도 삼총사입니다. 따라서 이 경우 한국중학교에서는 두 가지 방법으로 삼총사를 만들 수 있습니다.

한국중학교 학생들의 번호를 나타내는 정수 배열 number가 매개변수로 주어질 때, 학생들 중 삼총사를 만들 수 있는 방법의 수를 return 하도록 solution 함수를 완성하세요.

제한사항

3 ≤ number의 길이 ≤ 13
-1,000 ≤ number의 각 원소 ≤ 1,000
서로 다른 학생의 정수 번호가 같을 수 있습니다.

문제풀이

// 첫번째 학생
for(int i = 0; i < number.length - 2; i++) {
	...
}

첫번째 학생이 number를 뽑을 수 있는 범위는 다른 학생들과 중복을 피하기 위해서 i = 0 부터 number.length - 2까지이다.

// 두번째 학생
for(int j = i +1; j < number.length - 1; j++) {
    ...
}

두번째 학생이 number를 뽑을 수 있는 범위는 다른 학생들과 중복을 피하기 위해서 j = i + 1 부터 number.length - 1까지이다.

// 세번째 학생
for(int k = j + 1; k < number.length; k++) {
	...
}

세번째 학생이 number를 뽑을 수 있는 범위는 다른 학생들과 중복을 피하기 위해서 k = j + 1 부터 number.length 까지이다.

if(number[i] + number[j] + number[k] == 0) {
    count++;
}

첫번째, 두번째, 세번째 모든 학생의 number를 더한 값이 0일 경우 count를 해서 count 값을 return한다.

전체코드

class Solution {
    public int solution(int[] number) {
        int count = 0;
        
        // 첫번째 학생
        for(int i = 0; i < number.length - 2; i++) {
            // 두번째 학생
            for(int j = i +1; j < number.length - 1; j++) {
                // 세번째 학생
                for(int k = j + 1; k < number.length; k++) {
                    if(number[i] + number[j] + number[k] == 0) {
                        count++;
                    }
                }
            }
        }
        
        return count;
    }
}

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/코딩테스트] 숫자 짝궁(JAVA)

"주인장" — Wed, 17 Sep 2025 20:42:23 +0900

문제설명

두 정수 X, Y의 임의의 자리에서 공통으로 나타나는 정수 k(0 ≤ k ≤ 9)들을 이용하여 만들 수 있는 가장 큰 정수를 두 수의 짝꿍이라 합니다(단, 공통으로 나타나는 정수 중 서로 짝지을 수 있는 숫자만 사용합니다). X, Y의 짝꿍이 존재하지 않으면, 짝꿍은 -1입니다. X, Y의 짝꿍이 0으로만 구성되어 있다면, 짝꿍은 0입니다.

예를 들어, X = 3403이고 Y = 13203이라면, X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 3, 0, 3으로 만들 수 있는 가장 큰 정수인 330입니다. 다른 예시로 X = 5525이고 Y = 1255이면 X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 2, 5, 5로 만들 수 있는 가장 큰 정수인 552입니다(X에는 5가 3개, Y에는 5가 2개 나타나므로 남는 5 한 개는 짝 지을 수 없습니다.)
두 정수 X, Y가 주어졌을 때, X, Y의 짝꿍을 return하는 solution 함수를 완성해주세요.

제한사항

3 ≤ X, Y의 길이(자릿수) ≤ 3,000,000입니다.
X, Y는 0으로 시작하지 않습니다.
X, Y의 짝꿍은 상당히 큰 정수일 수 있으므로, 문자열로 반환합니다.

문제풀이

int[] countX = new int[10];
int[] countY = new int[10];

파라미터 X, Y의 범위가 0 <= k <= 9를 생각하여 변수를 생성한다.

// 각 숫자의 등장 횟수 계산
for (char c : X.toCharArray()) {
    countX[c - '0']++;
}
for (char c : Y.toCharArray()) {
    countY[c - '0']++;
}

X, Y를 Char 타입으로 변환 후 아스키 코드로 변환 시킨다. 그 후 등장한 숫자의 횟수를 count한다.

StringBuilder sb = new StringBuilder();

// 9부터 0까지 숫자를 큰 순서로 채우기
for (int i = 9; i >= 0; i--) {
    int pairCount = Math.min(countX[i], countY[i]);
    for (int j = 0; j < pairCount; j++) {
        sb.append(i);
    }
}

Math.min 함수를 사용하여 최소 길이를 구한 후 StringBuilder에 값을 추가한다.

if (sb.length() == 0) {
    return "-1"; // 공통 숫자 없음
}

if (sb.charAt(0) == '0') {
    return "0"; // 모두 0으로만 이루어짐
}

예외 처리를 한다.

전체코드

import java.util.*;

class Solution {
    public String solution(String X, String Y) {
        int[] countX = new int[10];
        int[] countY = new int[10];

        // 각 숫자의 등장 횟수 계산
        for (char c : X.toCharArray()) {
            countX[c - '0']++;
        }
        for (char c : Y.toCharArray()) {
            countY[c - '0']++;
        }

        StringBuilder sb = new StringBuilder();

        // 9부터 0까지 숫자를 큰 순서로 채우기
        for (int i = 9; i >= 0; i--) {
            int pairCount = Math.min(countX[i], countY[i]);
            for (int j = 0; j < pairCount; j++) {
                sb.append(i);
            }
        }

        if (sb.length() == 0) {
            return "-1"; // 공통 숫자 없음
        }

        if (sb.charAt(0) == '0') {
            return "0"; // 모두 0으로만 이루어짐
        }

        return sb.toString();
    }
}

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/코딩 테스트] 미로 탈출(JAVA)

"주인장" — Thu, 26 Jun 2025 21:56:41 +0900

문제 설명

1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.

미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.

제한 사항

5 ≤ maps의 길이 ≤ 100
5 ≤ maps[i]의 길이 ≤ 100
maps[i]는 다음 5개의 문자들로만 이루어져 있습니다.
S : 시작 지점
E : 출구
L : 레버
O : 통로
X : 벽
시작 지점과 출구, 레버는 항상 다른 곳에 존재하며 한 개씩만 존재합니다.
출구는 레버가 당겨지지 않아도 지나갈 수 있으며, 모든 통로, 출구, 레버, 시작점은 여러 번 지나갈 수 있습니다.

문제 풀이

// 미로
static String[][] miro;

// 좌우
static int[] dx = {-1, 1, 0, 0};

// 상하
static int[] dy = {0, 0, -1, 1};

문제 풀이에 필요한 전역 변수를 선언한다. 2차원 배열인 미로 변수를 생성하고 상하좌우로 움직일 수 있는 변수도 같이 생성한다.

miro = new String[maps.length][maps[0].length()];

// start, labor를 담을 변수 선언
int[] start = new int[2];
int[] labor = new int[2];

miro의 범위를 정하고 start(시작), labor(레버) 위치를 담을 지역 변수를 선언한다.

for(int i = 0; i<maps.length; i++) {
    String[] tmp = maps[i].split("");

    for(int j = 0; j<tmp.length; j++) {
        // 2차원 문자 배열로 변환하여 저장
        miro[i][j] = tmp[j];

        // start 위치 저장
        if(miro[i][j].equals("S")) {
            start = new int[]{i,j};
        }

        // labor 위치 저장
        if(miro[i][j].equals("L")) {
            labor = new int[]{i,j};
        }            
    }
}

매개변수로 받은 maps를 2차원 배열 형식으로 값을 담은 후 start, labor의 위치를 저장한다.

int result = bfs(start, "L");
int result2 = bfs(labor, "E");

result는 시작부분에서 레버로 가는 개수이고, result2는 레버에서 끝으로 가는 개수이다. bfs 메소드는 바로 아래에 설명하겠습니다.

 public int bfs(int[] start, String target) {
        // 큐를 생성하여 2차원 배열 위치의 값과 이동한 수를 담는다.
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{start[0], start[1], 0});
        
        // 방문여부
        boolean[][] visited = new boolean[miro.length][miro[0].length];
        
        while(!queue.isEmpty()) {
            int x = queue.peek()[0];
            int y = queue.peek()[1];
            int count = queue.peek()[2];
            visited[x][y] = true;
            
            if(miro[x][y].equals(target)) {
                return count;
            }
            
            queue.poll();
            
            // 상, 하, 좌, 우 4방향
            for(int i = 0; i<4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                
                // 미로 밖으로 벗어나지 않도록 범위 설정
                if(nx >= 0 && nx < miro.length && 
                   ny >= 0 && ny < miro[0].length && 
                   !visited[nx][ny]) {
                    
                    // 벽이 아닌 경우
                    if(!miro[nx][ny].equals("X")) {
                        visited[nx][ny] = true;
                        queue.add(new int[]{nx, ny, count+1});
                    }
                }
                
            }
            
       }
         
    return -1;   
}

위의 메소드는 bfs(너비 우선 탐색)으로 시작으로부터 가까운 지점 먼저 방문하는 순회 방식이다. queue를 생성하고 위에서 선언했던 상, 하, 좌, 우 4방향으로 한칸씩 움직이면서 목표 지점까지 도달하게 하는 매소드이다. 목표 지점으로 도달하는 과정에서 미로 밖으로 벗어나지 않도록 하는 범위 설정이 필요하다.

전체 코드

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    // 미로
    static String[][] miro;
    
    // 좌우
    static int[] dx = {-1, 1, 0, 0};
    
    // 상하
    static int[] dy = {0, 0, -1, 1};
    
    public int solution(String[] maps) {
        miro = new String[maps.length][maps[0].length()];
        
        // start, labor를 담을 변수 선언
        int[] start = new int[2];
        int[] labor = new int[2];
        
        for(int i = 0; i<maps.length; i++) {
            String[] tmp = maps[i].split("");
            
            for(int j = 0; j<tmp.length; j++) {
                // 2차원 문자 배열로 변환하여 저장
                miro[i][j] = tmp[j];
                
                // start 위치 저장
                if(miro[i][j].equals("S")) {
                    start = new int[]{i,j};
                }
                
                // labor 위치 저장
                if(miro[i][j].equals("L")) {
                    labor = new int[]{i,j};
                }            
            }
        }
        
        int result = bfs(start, "L");
        int result2 = bfs(labor, "E");
        
        if(result == - 1 || result2 == -1) {
            return -1;
        }
        
        return result + result2;
    }
    
    public int bfs(int[] start, String target) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{start[0], start[1], 0});
        
        // 방문여부
        boolean[][] visited = new boolean[miro.length][miro[0].length];
        
        // 
        while(!queue.isEmpty()) {
            int x = queue.peek()[0];
            int y = queue.peek()[1];
            int count = queue.peek()[2];
            visited[x][y] = true;
            
            if(miro[x][y].equals(target)) {
                return count;
            }
            
            queue.poll();
            
            // 상, 하, 좌, 우 4방향
            for(int i = 0; i<4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];
                
                // 미로 밖으로 벗어나지 않도록 범위 설정
                if(nx >= 0 && nx < miro.length && 
                   ny >= 0 && ny < miro[0].length && 
                   !visited[nx][ny]) {
                    
                    // 벽이 아닌 경우
                    if(!miro[nx][ny].equals("X")) {
                        visited[nx][ny] = true;
                        queue.add(new int[]{nx, ny, count+1});
                    }
                }
                
            }
            
        }
         
        return -1;   
    }
    
}

[프로그래머스/코딩테스트] 콜라 문제(JAVA)

"주인장" — Tue, 24 Jun 2025 20:41:52 +0900

문제설명

오래전 유행했던 콜라 문제가 있습니다. 콜라 문제의 지문은 다음과 같습니다.
정답은 아무에게도 말하지 마세요.
콜라 빈 병 2개를 가져다주면 콜라 1병을 주는 마트가 있다. 빈 병 20개를 가져다주면 몇 병을 받을 수 있는가?
단, 보유 중인 빈 병이 2개 미만이면, 콜라를 받을 수 없다.

문제를 풀던 상빈이는 콜라 문제의 완벽한 해답을 찾았습니다. 상빈이가 푼 방법은 아래 그림과 같습니다. 우선 콜라 빈 병 20병을 가져가서 10병을 받습니다. 받은 10병을 모두 마신 뒤, 가져가서 5병을 받습니다. 5병 중 4병을 모두 마신 뒤 가져가서 2병을 받고, 또 2병을 모두 마신 뒤 가져가서 1병을 받습니다. 받은 1병과 5병을 받았을 때 남은 1병을 모두 마신 뒤 가져가면 1병을 또 받을 수 있습니다. 이 경우 상빈이는 총 10 + 5 + 2 + 1 + 1 = 19병의 콜라를 받을 수 있습니다.

출처 - 프로그래머스 콜라 문제

문제를 열심히 풀던 상빈이는 일반화된 콜라 문제를 생각했습니다. 이 문제는 빈 병 a개를 가져다주면 콜라 b병을 주는 마트가 있을 때, 빈 병 n개를 가져다주면 몇 병을 받을 수 있는지 계산하는 문제입니다. 기존 콜라 문제와 마찬가지로, 보유 중인 빈 병이 a개 미만이면, 추가적으로 빈 병을 받을 순 없습니다. 상빈이는 열심히 고심했지만, 일반화된 콜라 문제의 답을 찾을 수 없었습니다. 상빈이를 도와, 일반화된 콜라 문제를 해결하는 프로그램을 만들어 주세요.

콜라를 받기 위해 마트에 주어야 하는 병 수 a, 빈 병 a개를 가져다 주면 마트가 주는 콜라 병 수 b, 상빈이가 가지고 있는 빈 병의 개수 n이 매개변수로 주어집니다. 상빈이가 받을 수 있는 콜라의 병 수를 return 하도록 solution 함수를 작성해주세요.

제한사항

1 ≤ b < a ≤ n ≤ 1,000,000
정답은 항상 int 범위를 넘지 않게 주어집니다.

문제 풀이

        // 상빈이가 가지고 있는 빈 병의 개수가 콜라를 받기 위해 마트에 주어야 하는 병의 개수 보다 적다면 
        while(n >= a) {
        
    		// 상빈이가 받을 수 있는 콜라의 병의 개수
            answer += n / a * b;
            
            // 빈 병을 가져다 주면 마트가 주는 콜라 병의 개수 + 상빈이가 받을 수 있는 콜라의 병의 개수
            n = n % a + n / a * b;
        }

전체 코드

class Solution {
    public int solution(int a, int b, int n) {
        int answer = 0;
        
        while(n >= a) {
            answer += n / a * b;
            n = n % a + n / a * b;
        }
        
        return answer;
    }
}

실전! 스프링 부트와 JPA 활용1 - 웹 애플리케이션 개발(후기)

"주인장" — Sat, 15 Feb 2025 14:37:03 +0900

안녕하세요!

저는 사실 JPA의 필요성을 처음에는 느끼지 못했어요.

JDBC (Java Database Connectivity)를 사용한 DB 연결**

package java_arguments.JDBC_test;
import java.sql.*;

public class DB_Connection {

    static final String DRIVER =  "org.mariadb.jdbc.Driver";
    static final String URL = "jdbc:mariadb://localhost:3306/test_db";
    static final String USER = "root";
    static final String PASSWORD = "testdb";

    Connection con;
    PreparedStatement pstmt;
    ResultSet rs;

    public DB_Connection(){
        try {
            // JDBC 드라이버 로드
            Class.forName(DRIVER);
            // DB 연결
            con = DriverManager.getConnection(URL, USER, PASSWORD);
            if(con != null){
                System.out.println("DB 접속에 성공했습니다.");
            }
        } catch (ClassNotFoundException e) {
            System.out.println("드라이버 로드 실패");
        } catch (SQLException e) {
            System.out.println("DB 접속 실패: " + e.getMessage());
        } finally {
            // 자원 반환: 연결이 성공한 후에 자원 해제하는 코드를 추가해야 합니다.
            if (con != null) {
                try {
                    con.close();
                    System.out.println("DB 연결 종료");
                } catch (SQLException e) {
                    System.out.println("DB 연결 종료 실패: " + e.getMessage());
                }
            }
        }
    }

    public static void main(String[] args) {
        new DB_Connection();  // DB 연결을 시도합니다.
    }
}

위의 코드와 같이 JDBC (Java Database Connectivity)**를 사용한 DB 연결 코드를 사용하다가

MyBatis 를 사용한 DB 연결

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- JDBC 연결 정보 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="org.mariadb.jdbc.Driver"/>
                <property name="url" value="jdbc:mariadb://localhost:3306/test_db"/>
                <property name="username" value="root"/>
                <property name="password" value="testdb"/>
            </dataSource>
        </environment>
    </environments>

    <!-- Mapper 파일 위치 지정 -->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>

</configuration>

위의 코드와 같이 mybatis-config.xml 파일 설정을 하면 DB 연결이 되는 유레카를 봤습니다.

1. 코드 간결화와 유지보수성 향상: JDBC 코드를 직접 작성하는 대신 MyBatis와 같은 ORM 프레임워크를 사용하면 SQL 쿼리를 별도로 관리할 수 있어 코드가 더 깔끔하고 유지보수하기 쉬워집니다.

2. SQL 분리 및 관리: MyBatis는 SQL 문장을 XML 파일로 분리하여 관리하므로, Java 코드에서 직접 SQL을 작성할 필요가 없어 가독성이 높아지고 비즈니스 로직과 데이터베이스 작업을 분리할 수 있습니다.

3. 중앙 집중식 설정 관리: mybatis-config.xml 파일을 사용하여 데이터베이스 연결 정보와 관련된 설정을 한 곳에서 관리할 수 있어, 데이터베이스 변경 시 수정이 용이합니다.

4. 자동 리소스 관리: MyBatis는 SQL 쿼리 실행 후 리소스를 자동으로 반환해주기 때문에, Connection, PreparedStatement, ResultSet과 같은 리소스를 직접 관리할 필요가 없어 코드가 더 간결하고 안전하게 됩니다.

하지만

MyBatis에 익숙해지고 나서

"더 편리한 방법이 있을까?"

라는 생각이 들었습니다.

그래서 JPA라는 유용한 기술이 있다는 걸 떠올리고, 이에 대해 인강을 듣기 시작했습니다.

기초편을 먼저 듣지 않고 실습편을 먼저 들었습니다.

제 스타일을 고려했을 때,

실습을 통해 사전 지식을 쌓은 후

기초편을 들으면 실습편에서 배운 내용을 떠올리며

효과적으로 공부할 수 있을 것 같았습니다.

여러분도 자신만의 스타일에 맞게 공부하시면 좋을 것 같습니다!

이 강의를 듣고 느낀 점은

JAVA와 MyBatis 방식에 익숙하다면 강의를 듣는 데

큰 어려움이 없었을 거라는 생각이 들었습니다.

JPA도 결국 자바 기반이기 때문입니다.

굳이 어려운 점을 꼽자면,

필요한 어노테이션(@)들이 많아 간단한 암기가 필요하고,

데이터베이스 관점이 아닌 객체 지향 관점에서 쿼리가 처리되기 때문에

구조를 잘 이해하고 있어야 한다는 점이었습니다.

감사합니다.

[프로그래머스/코딩테스트] 유연근무제(JAVA)

"주인장" — Thu, 13 Feb 2025 23:02:55 +0900

안녕하세요!!

문제 설명

프로그래머스 사이트를 운영하는 그렙에서는 재택근무와 함께 출근 희망 시각을 자유롭게 정하는 유연근무제를 시행하고 있습니다. 제도 정착을 위해 오늘부터 일주일 동안 각자 설정한 출근 희망 시각에 늦지 않고 출근한 직원들에게 상품을 주는 이벤트를 진행하려고 합니다.

직원들은 일주일동안 자신이 설정한 출근 희망 시각 + 10분까지 어플로 출근해야 합니다. 예를 들어 출근 희망 시각이 9시 58분인 직원은 10시 8분까지 출근해야 합니다. 단, 토요일, 일요일의 출근 시각은 이벤트에 영향을 끼치지 않습니다. 직원들은 매일 한 번씩만 어플로 출근하고, 모든 시각은 시에 100을 곱하고 분을 더한 정수로 표현됩니다. 예를 들어 10시 13분은 1013이 되고 9시 58분은 958이 됩니다.

당신은 직원들이 설정한 출근 희망 시각과 실제로 출근한 기록을 바탕으로 상품을 받을 직원이 몇 명인지 알고 싶습니다.

직원 n명이 설정한 출근 희망 시각을 담은 1차원 정수 배열 schedules, 직원들이 일주일 동안 출근한 시각을 담은 2차원 정수 배열 timelogs, 이벤트를 시작한 요일을 의미하는 정수 startday가 매개변수로 주어집니다. 이때 상품을 받을 직원의 수를 return 하도록 solution 함수를 완성해주세요.

제한사항

1 ≤ schedules의 길이 = n ≤ 1,000
schedules[i]는 i + 1번째 직원이 설정한 출근 희망 시각을 의미합니다.
700 ≤ schedules[i] ≤ 1100
1 ≤ timelogs의 길이 = n ≤ 1,000
timelogs[i]의 길이 = 7
timelogs[i][j]는 i + 1번째 직원이 이벤트 j + 1일차에 출근한 시각을 의미합니다.
600 ≤ timelogs[i][j] ≤ 2359
1 ≤ startday ≤ 7
1은 월요일, 2는 화요일, 3은 수요일, 4는 목요일, 5는 금요일, 6은 토요일, 7은 일요일에 이벤트를 시작했음을 의미합니다.
출근 희망 시각과 실제로 출근한 시각을 100으로 나눈 나머지는 59 이하입니다.

문제 풀이

// 상품을 받을 직원 수
int count = 0;

1. 결과를 return 받을 수 있는 변수를 초기화합니다.

// 각 직원에 대해 반복
for (int i = 0; i < timelogs.length; i++) {         
	...
    // 해당 직원의 일주일 간 출근 기록을 확인
    for (int j = 0; j < timelogs[i].length; j++) {
       ...
    }
    ...
}

2. 이중 for문을 사용하여 해당 직원의 일주일 간 출근 기록을 확인합니다. 이중 for문을 사용하는 이유는 timelogs[i].length 부분에서 i번째를 위해서 입니다.

// 출근 시간이 제한시간을 넘지 않았는지 확인하는 변수
boolean flag = true;

...

// 주말(토요일, 일요일)을 제외한 평일에 대해서만 확인
if (((startday + j) % 7 == 0 || (startday + j) % 7 == 6)) {
    // 주말이라면 출근 시각을 검사할 필요가 없으므로 넘어감
    continue;
}

// 평일에 출근 시간이 제한시간을 초과하면 해당 직원은 지각
if (changeTime(schedules[i]) < timelogs[i][j]) {
    flag = false;  
    break;
}

// 모든 평일에 지각하지 않았다면 상품을 받을 자격이 있음
if (flag) {
    count++; 
}

3. 주말(토요일, 일요일)은 제외한 평일에 대해서만 확인하기 위해 if문을 사용합니다. 그리고 평일 출근 시간이 제한 시간을 초과하면 해당 직원은 지각이므로 count가 되지 않도록 하고 이외에는 count가 되도록 합니다.

// 시간으로 형변환 + 출근 희망 시각에 10분을 더하는 메서드
private int changeTime(int time) {
    // 시각을 분과 시로 분리
    int minute = time % 100;  
    int hour = time / 100;   

    // 10분을 더함
    minute += 10;

    // 만약 10분을 더해서 60분을 넘으면 시각을 1시간 증가시키고, 분은 60으로 나눈 나머지 값을 사용
    if (minute > 59) {
        minute %= 60; 
        hour++;        
    }

    // 계산된 시각을 다시 "HHMM" 형식으로 반환
    return (hour * 100) + minute;
}

4. 이 문제에서 가장 중요한 부분이라고 생각합니다. 모든 시각은 시에 100을 곱하고 분을 더한 정수로 표현하였기 때문에 이것을 시간 형식으로 변환하여 10분을 더하는 작업 후 원래 형식으로 변환하여 return합니다.

전체 코드

class Solution {
    public int solution(int[] schedules, int[][] timelogs, int startday) {
        // 상품을 받을 직원 수
        int count = 0;
        
        // 각 직원에 대해 반복
        for (int i = 0; i < timelogs.length; i++) {         
            // 출근 시간이 제한시간을 넘지 않았는지 확인하는 변수
            boolean flag = true;
            
            // 해당 직원의 일주일 간 출근 기록을 확인
            for (int j = 0; j < timelogs[i].length; j++) {
                
                // 주말(토요일, 일요일)을 제외한 평일에 대해서만 확인
                if (((startday + j) % 7 == 0 || (startday + j) % 7 == 6)) {
                    // 주말이라면 출근 시각을 검사할 필요가 없으므로 넘어감
                    continue;
                }
                
                // 평일에 출근 시간이 제한시간을 초과하면 해당 직원은 지각
                if (changeTime(schedules[i]) < timelogs[i][j]) {
                    flag = false;  
                    break;
                }
            }
            
            // 모든 평일에 지각하지 않았다면 상품을 받을 자격이 있음
            if (flag) {
                count++; 
            }
        }      
        // 상품을 받을 직원 수 반환
        return count;
    }
    
    // 시간으로 형변환 + 출근 희망 시각에 10분을 더하는 메서드
    private int changeTime(int time) {
        // 시각을 분과 시로 분리
        int minute = time % 100;  
        int hour = time / 100;   
        
        // 10분을 더함
        minute += 10;
        
        // 만약 10분을 더해서 60분을 넘으면 시각을 1시간 증가시키고, 분은 60으로 나눈 나머지 값을 사용
        if (minute > 59) {
            minute %= 60; 
            hour++;        
        }
        
        // 계산된 시각을 다시 "HHMM" 형식으로 반환
        return (hour * 100) + minute;
    }
}

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/코딩테스트] 개인정보 수집 유효기간(JAVA)

"주인장" — Fri, 1 Nov 2024 15:14:27 +0900

안녕하세요.
오늘은 개인정보 수집 유효기간이 지났을 때
개인정보를 삭제하는 코드를 가지고 왔습니다!!

문제 설명

고객의 약관 동의를 얻어서 수집된 1~n번으로 분류되는 개인정보 n개가 있습니다. 약관 종류는 여러 가지 있으며 각 약관마다 개인정보 보관 유효기간이 정해져 있습니다. 당신은 각 개인정보가 어떤 약관으로 수집됐는지 알고 있습니다. 수집된 개인정보는 유효기간 전까지만 보관 가능하며, 유효기간이 지났다면 반드시 파기해야 합니다.

예를 들어, A라는 약관의 유효기간이 12 달이고, 2021년 1월 5일에 수집된 개인정보가 A약관으로 수집되었다면 해당 개인정보는 2022년 1월 4일까지 보관 가능하며 2022년 1월 5일부터 파기해야 할 개인정보입니다.
당신은 오늘 날짜로 파기해야 할 개인정보 번호들을 구하려 합니다.

모든 달은 28일까지 있다고 가정합니다.

다음은 오늘 날짜가 2022.05.19일 때의 예시입니다.

약관 종류 유효기간
A 6 달
B 12 달
C 3 달
번호 개인정보수집일자 약관종류
1 2021.05.02 A
2 2021.07.01 B
3 2022.02.19 C
4 2022.02.20 C

첫 번째 개인정보는 A약관에 의해 2021년 11월 1일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
두 번째 개인정보는 B약관에 의해 2022년 6월 28일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
세 번째 개인정보는 C약관에 의해 2022년 5월 18일까지 보관 가능하며, 유효기간이 지났으므로 파기해야 할 개인정보입니다.
네 번째 개인정보는 C약관에 의해 2022년 5월 19일까지 보관 가능하며, 유효기간이 지나지 않았으므로 아직 보관 가능합니다.
따라서 파기해야 할 개인정보 번호는 [1, 3]입니다.

오늘 날짜를 의미하는 문자열 today, 약관의 유효기간을 담은 1차원 문자열 배열 terms와 수집된 개인정보의 정보를 담은 1차원 문자열 배열 privacies가 매개변수로 주어집니다. 이때 파기해야 할 개인정보의 번호를 오름차순으로 1차원 정수 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

제한사항

today는 "YYYY.MM.DD" 형태로 오늘 날짜를 나타냅니다.
1 ≤ terms의 길이 ≤ 20
terms의 원소는 "약관 종류 유효기간" 형태의 약관 종류와 유효기간을 공백 하나로 구분한 문자열입니다.
약관 종류는 A~Z중 알파벳 대문자 하나이며, terms 배열에서 약관 종류는 중복되지 않습니다.
유효기간은 개인정보를 보관할 수 있는 달 수를 나타내는 정수이며, 1 이상 100 이하입니다.
1 ≤ privacies의 길이 ≤ 100
privacies[i]는 i+1번 개인정보의 수집 일자와 약관 종류를 나타냅니다.
privacies의 원소는 "날짜 약관 종류" 형태의 날짜와 약관 종류를 공백 하나로 구분한 문자열입니다.
날짜는 "YYYY.MM.DD" 형태의 개인정보가 수집된 날짜를 나타내며, today 이전의 날짜만 주어집니다.
privacies의 약관 종류는 항상 terms에 나타난 약관 종류만 주어집니다.
today와 privacies에 등장하는 날짜의 YYYY는 연도, MM은 월, DD는 일을 나타내며 점(.) 하나로 구분되어 있습니다.
2000 ≤ YYYY ≤ 2022
1 ≤ MM ≤ 12
MM이 한 자릿수인 경우 앞에 0이 붙습니다.
1 ≤ DD ≤ 28
DD가 한 자릿수인 경우 앞에 0이 붙습니다.
파기해야 할 개인정보가 하나 이상 존재하는 입력만 주어집니다.

문제풀이

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;

1. 날짜, 문자열을 포맷, 동적 배열 구현을 위해 클래스 임포트한다.

// 결과를 저장할 리스트
ArrayList<Integer> list = new ArrayList<>();
// 유효기간 계산에 사용할 날짜 변수
LocalDate plusDate = null;
// 인덱스 초기화
int index = 1;

2. 결과를 저장할 리스트와 변수들을 초기화한다.

// 날짜 형식 지정
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd");
// 오늘 날짜를 LocalDate로 변환
LocalDate currentDate = LocalDate.parse(today, formatter);

3. 날짜 형식을 지정하여 today 변수를 LocalDate로 변환한다.

for(String privacie : privacies) {
    String[] privacyData = privacie.split(" ");

    // 개인정보동의 날짜를 날짜로 변환
    String privacyDateStr = privacyData[0];
    LocalDate privacyDate = LocalDate.parse(privacyDateStr, formatter);

    // 개인정보동의 유형
    String privacyTerm = privacyData[1];

    // 동의 유형에 해당하는 유효기간을 찾기
    for(String term : terms) {
        String[] termInfo = term.split(" ");
        if(termInfo[0].equals(privacyTerm)) {
            plusDate = privacyDate.plusMonths(Integer.parseInt(termInfo[1]));
            break;
        }
    }

    // 유효기간이 null이 아니고 만료 여부 판단
    if (plusDate != null && !plusDate.isAfter(currentDate)) {
        list.add(index);
    }
    index++;
}

4. privacies 값을 동의 날짜, 형식으로 구분하고 terms 값은 형식, 동의 기간으로 구분한다. 그다음 형식이 같으면 동의 날짜에 동의기간을 더한 후의 날짜가 현재 시간보다 과거에 있으면 파쇄해야 할 번호 인덱스를 넣는다.

return list.stream().mapToInt(Integer::intValue).toArray();

5. list는 반환 값이 ArrayList<Integer>라서 반환값 int []에 맞추어 반환한다.

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

김영한의 실전 자바 - 중급 2편 후기

"주인장" — Wed, 30 Oct 2024 16:43:24 +0900

안녕하세요!!

김영한 강사님의 로드맵을
따라가고 있는
주니어 개발자입니다.

벌써 중급 2편에 관한 후기를 작성하네요.

결론부터 말씀드리면
지금 이 강의를 위해
앞의 강의를 들었다고 해도
부족함이 없었던 강의 었어요.

저는 국비 6개월 수료 후
취업을 하여 1년 동안 개발을 하면서
긁지 못하는 가려움(?)이 있었어요.

하지만
드디어!!!!
가려움을 찾았네요.

바로
자료구조에 대한 지식 부족!!
이었던 거 같아요.

취직 후 백엔드 업무를 하면서
전체적인 흐름도 알겠고
알고리즘도 천천히 읽으면 알겠고
업무 하는데도 큰 문제가 없었어요.
하지만 늘 뭔가 부족함이 있었는데 찾았네요.

대부분 업무를 하면 ArrayList를 왜 사용하는지 모르고
"대부분 이렇게 사용하니까" 느낌이 었다면
지금은 이유를 알고 사용하는 느낌입니다.
왜 ArrayList를 사용하는지 알겠어요.

순서 문제
중복 문제
시간복잡도 문제
알고리즘 문제
등등
다양한 이유가 있었네요.

이 강의를 들으니 대부분의 문제를 해결할 수 있었어요.

그 이외에도 제네릭과 컬렉션 프레임워크에 대해서도 공부할 수 있었어요.

시니어가 되기에는 갈길이 멀지만
천천히 걸어가겠습니다.
감사합니다.

김영한의 실전 자바 - 중급 2편 강의 | 김영한 - 인프런

김영한 | 자바 제네릭과 컬렉션 프레임워크를 실무 중심으로 깊이있게 학습합니다. 자료 구조에 대한 기본기도 함께 학습합니다., 국내 개발 분야 누적 수강생 1위, 제대로 만든 김영한의 실전

www.inflearn.com

[프로그래머스/코딩테스트] 둘만의 암호 (JAVA)

"주인장" — Tue, 29 Oct 2024 18:58:11 +0900

안녕하세요.

우리 둘만의 암호를
코딩으로 해석해보겠습니다!

문제설명

두 문자열 s와 skip, 그리고 자연수 index가 주어질 때, 다음 규칙에 따라 문자열을 만들려 합니다. 암호의 규칙은 다음과 같습니다.

문자열 s의 각 알파벳을 index만큼 뒤의 알파벳으로 바꿔줍니다.
index만큼의 뒤의 알파벳이 z를 넘어갈 경우 다시 a로 돌아갑니다.
skip에 있는 알파벳은 제외하고 건너뜁니다.
예를 들어 s = "aukks", skip = "wbqd", index = 5일 때, a에서 5만큼 뒤에 있는 알파벳은 f지만 [b, c, d, e, f]에서 'b'와 'd'는 skip에 포함되므로 세지 않습니다. 따라서 'b', 'd'를 제외하고 'a'에서 5만큼 뒤에 있는 알파벳은 [c, e, f, g, h] 순서에 의해 'h'가 됩니다. 나머지 "ukks" 또한 위 규칙대로 바꾸면 "appy"가 되며 결과는 "happy"가 됩니다.

두 문자열 s와 skip, 그리고 자연수 index가 매개변수로 주어질 때 위 규칙대로 s를 변환한 결과를 return하도록 solution 함수를 완성해주세요.

제한사항

5 ≤ s의 길이 ≤ 50
1 ≤ skip의 길이 ≤ 10
s와 skip은 알파벳 소문자로만 이루어져 있습니다.
skip에 포함되는 알파벳은 s에 포함되지 않습니다.
1 ≤ index ≤ 20

문제풀이

String alphabet = "abcdefghijklmnopqrstuvwxyz";
StringBuilder result = new StringBuilder();

1. alphabet 변수를 생성했어요. 왜냐하면 알파벳의 index를 알기 위해서입니다. 그리고 result 결과 값을 담기 위해서 StringBuilder를 사용한다.

// skip에 포함된 문자 제거
for(char charS : s.toCharArray()) {
    int currentIndex = alphabet.indexOf(charS);
    int count = 0;
    ...(생략)
}

2. 매개변수 값 s를 사용해서 한글자식 뽑고 currentIndex 값을 찾는다. 그리고 count는 매개변수 skip 값이 없을 때 +1를 하여 매개변수 index만큼 이동시키기 위해 있는 변수다.

while(count < index) {
    // alphabet.length()의 길이를 초과할 때 처음부터 시작
    currentIndex = (currentIndex + 1) % alphabet.length();

    // skip에 없을 떄 count 증가
    if(skip.indexOf(alphabet.charAt(currentIndex)) == -1) {
        count++;
    }

}

3. while문을 사용해서 index만큼 돌 수 있다. 그리고 alphabet.length()의 길이를 초과할 때 처음부터 시작하여 currentIndex 초기화를 초기화한다. if문을 사용해서 skip에 문자가 없을 때 count를 증가시킨다.

result.append(alphabet.charAt(currentIndex));

4. 결과값을 담는다. StringBuilder를 사용했기 때문에 append 함수를 사용한다.

 return result.toString();

5. 결과값을 return한다. result가 StringBuilder이기 때문에 toString으로 형변환한다.

전체코드

class Solution {
    public String solution(String s, String skip, int index) {
        String alphabet = "abcdefghijklmnopqrstuvwxyz";
        StringBuilder result = new StringBuilder();
        
        // skip에 포함된 문자 제거
        for(char charS : s.toCharArray()) {
            int currentIndex = alphabet.indexOf(charS);
            int count = 0;
            
            while(count < index) {
                // alphabet.length()의 길이를 초과할 때 처음부터 시작
                currentIndex = (currentIndex + 1) % alphabet.length();
                
                // skip에 없을 떄 count 증가
                if(skip.indexOf(alphabet.charAt(currentIndex)) == -1) {
                    count++;
                }
                
            }
            
            result.append(alphabet.charAt(currentIndex));
            
        }
        return result.toString();
    }
}

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/코딩테스트] 카드 뭉치(JAVA)

"주인장" — Sat, 26 Oct 2024 14:24:22 +0900

안녕하세요!!
벌써 10월 말
날씨가 많이 쌀쌀하네요.
감기 조심!!

오늘은 카드 뭉치들을
순서대로 뽑아 목푯 값과
일치하는지 확인하는 코딩입니다!!

문제 설명

코니는 영어 단어가 적힌 카드 뭉치 두 개를 선물로 받았습니다. 코니는 다음과 같은 규칙으로 카드에 적힌 단어들을 사용해 원하는 순서의 단어 배열을 만들 수 있는지 알고 싶습니다.

원하는 카드 뭉치에서 카드를 순서대로 한 장씩 사용합니다.
한 번 사용한 카드는 다시 사용할 수 없습니다.
카드를 사용하지 않고 다음 카드로 넘어갈 수 없습니다.
기존에 주어진 카드 뭉치의 단어 순서는 바꿀 수 없습니다.
예를 들어 첫 번째 카드 뭉치에 순서대로 ["i", "drink", "water"], 두 번째 카드 뭉치에 순서대로 ["want", "to"]가 적혀있을 때 ["i", "want", "to", "drink", "water"] 순서의 단어 배열을 만들려고 한다면 첫 번째 카드 뭉치에서 "i"를 사용한 후 두 번째 카드 뭉치에서 "want"와 "to"를 사용하고 첫 번째 카드뭉치에 "drink"와 "water"를 차례대로 사용하면 원하는 순서의 단어 배열을 만들 수 있습니다.

문자열로 이루어진 배열 cards1, cards2와 원하는 단어 배열 goal이 매개변수로 주어질 때, cards1과 cards2에 적힌 단어들로 goal를 만들 있다면 "Yes"를, 만들 수 없다면 "No"를 return 하는 solution 함수를 완성해 주세요.

제한사항

1 ≤ cards1의 길이, cards2의 길이 ≤ 10
1 ≤ cards1[i]의 길이, cards2[i]의 길이 ≤ 10
cards1과 cards2에는 서로 다른 단어만 존재합니다.
2 ≤ goal의 길이 ≤ cards1의 길이 + cards2의 길이
1 ≤ goal[i]의 길이 ≤ 10
goal의 원소는 cards1과 cards2의 원소들로만 이루어져 있습니다.
cards1, cards2, goal의 문자열들은 모두 알파벳 소문자로만 이루어져 있습니다.

문제 풀이

// cards1의 인덱스
int index1 = 0;

// cards2의 인덱스
int index2 = 0;

1. 파라미터 값에 카드 뭉치를 2개 주었다. 그래서 카드 뭉치들의 인덱스를 count 하기 위해 변수를 생성했다.

for(String g : goal) {
    if(index1 < cards1.length && cards1[index1].equals(g)) {
        // cards1 단어 사용
        index1++;
    }else if(index2 < cards2.length && cards2[index2].equals(g)) {
        // cards2 단어 사용
        index2++;
    }else {
        // 단어 사용 X
        return "No";
    }
}

2. 목푯 값인 goal를 for문으로 돌리고 if문으로 index를 증가시키므로 순차적으로 값을 비교할 수 있다. 이 코드 전에는 문자열에 담아서 goal과 비교하다 보니 순차적으로 값을 비교할 수 없어 위과 같은 코딩으로 수정했다.

return "Yes";

3. 2번의 for문을 돌고 난 후에 goal 값과 동일하다면 return "Yes"를 빠져나가게 된다.

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

[프로그래머스/ 코딩테스트] 대충 만든 자판(JAVA)

"주인장" — Tue, 22 Oct 2024 17:51:59 +0900

문제 설명

휴대폰의 자판은 컴퓨터 키보드 자판과는 다르게 하나의 키에 여러 개의 문자가 할당될 수 있습니다. 키 하나에 여러 문자가 할당된 경우, 동일한 키를 연속해서 빠르게 누르면 할당된 순서대로 문자가 바뀝니다.

예를 들어, 1번 키에 "A", "B", "C" 순서대로 문자가 할당되어 있다면 1번 키를 한 번 누르면 "A", 두 번 누르면 "B", 세 번 누르면 "C"가 되는 식입니다.

같은 규칙을 적용해 아무렇게나 만든 휴대폰 자판이 있습니다. 이 휴대폰 자판은 키의 개수가 1개부터 최대 100개까지 있을 수 있으며, 특정 키를 눌렀을 때 입력되는 문자들도 무작위로 배열되어 있습니다. 또, 같은 문자가 자판 전체에 여러 번 할당된 경우도 있고, 키 하나에 같은 문자가 여러 번 할당된 경우도 있습니다. 심지어 아예 할당되지 않은 경우도 있습니다. 따라서 몇몇 문자열은 작성할 수 없을 수도 있습니다.

이 휴대폰 자판을 이용해 특정 문자열을 작성할 때, 키를 최소 몇 번 눌러야 그 문자열을 작성할 수 있는지 알아보고자 합니다.

1번 키부터 차례대로 할당된 문자들이 순서대로 담긴 문자열배열 keymap과 입력하려는 문자열들이 담긴 문자열 배열 targets가 주어질 때, 각 문자열을 작성하기 위해 키를 최소 몇 번씩 눌러야 하는지 순서대로 배열에 담아 return 하는 solution 함수를 완성해 주세요.

단, 목표 문자열을 작성할 수 없을 때는 -1을 저장합니다.

제한사항

1 ≤ keymap의 길이 ≤ 100
1 ≤ keymap의 원소의 길이 ≤ 100
keymap[i]는 i + 1번 키를 눌렀을 때 순서대로 바뀌는 문자를 의미합니다.
예를 들어 keymap[0] = "ABACD" 인 경우 1번 키를 한 번 누르면 A, 두 번 누르면 B, 세 번 누르면 A 가 됩니다.
keymap의 원소의 길이는 서로 다를 수 있습니다.
keymap의 원소는 알파벳 대문자로만 이루어져 있습니다.
1 ≤ targets의 길이 ≤ 100
1 ≤ targets의 원소의 길이 ≤ 100
targets의 원소는 알파벳 대문자로만 이루어져 있습니다.

문제 풀이

// 최소 눌림 값을 넣기 위한 HashMap
HashMap<Character,Integer> map = new HashMap<>();

//결과 값을 담을 배열
int[] result = new int[targets.length];

1. 자료구조는 HashMap을 선택했다. 이유는 O(1)의 시간 복잡도로 키에 대한 값을 검색할 수 있고, 최소한의 눌림 횟수를 키-값 쌍으로 저장하기 위해서이다.

//keymap
for(int i = 0; i < keymap.length; i++) {
    for(int j = 0; j <keymap[i].length(); j++) {
       char temp = keymap[i].charAt(j);

       // map에 해당 값이 존재하지 않을 때, 최소 눌림일 때 갱신    
       if(!map.containsKey(temp) || map.get(temp) > j + 1) {
           map.put(temp, j + 1);
       } 
    }
}

2. 매개변수로 받은 keymap 값을 이중 for문을 사용하여 하나의 문자로 구분하고 if문을 사용하여 map에 해당 값이 존재하지 않을 때 또는 최소 눌림일 때 map에 값을 넣는다.

//targets
for(int i = 0; i < targets.length; i++) {
    int count = 0;
    boolean flog = true;

    for(int j = 0; j <targets[i].length(); j++) {
        char temp = targets[i].charAt(j);

        if(map.containsKey(temp)) {
            count += map.get(temp);
        }else {
            flog = false;
            break;
        }    
    }

    result[i] = flog ? count : -1;

}

3. 매개변수로 받은 targets 값을 이중 for문을 사용하여 하나의 문자로 구분하고 if문을 사용하여 map에 값이 존재한다면 map에 들어있는 최소 눌림 값을 count한다. 그리고 값이 존재하지 않는다면 -1 값을 return한다.

전체 코드

import java.util.*;

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        // 최소 눌림 값을 넣기 위한 HashMap
        HashMap<Character,Integer> map = new HashMap<>();
        //결과 값을 담을 배열
        int[] result = new int[targets.length];
        
        //keymap
        for(int i = 0; i < keymap.length; i++) {
            for(int j = 0; j <keymap[i].length(); j++) {
               char temp = keymap[i].charAt(j);
                
               // map에 해당 값이 존재하지 않을 때, 최소 눌림일 때 갱신    
               if(!map.containsKey(temp) || map.get(temp) > j + 1) {
                   map.put(temp, j + 1);
               } 
            }
        }       
        
        //targets
        for(int i = 0; i < targets.length; i++) {
            int count = 0;
            boolean flog = true;
            
            for(int j = 0; j <targets[i].length(); j++) {
                char temp = targets[i].charAt(j);
                
                if(map.containsKey(temp)) {
                    count += map.get(temp);
                }else {
                    flog = false;
                    break;
                }    
            }
            
            result[i] = flog ? count : -1;
            
        }
        
 
        
        return result;
    }
}

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

[프로그래머스/ 코딩테스트] 덧칠하기 (JAVA)

"주인장" — Sun, 20 Oct 2024 21:55:20 +0900

오늘은 페인트 덧칠하기를 가지고 왔습니다.
문제 설명을 읽으니 페인트의 원감 절감에 대해서
굉장히 신경 쓰는 거 같네요.

문제 설명

어느 학교에 페인트가 칠해진 길이가 n미터인 벽이 있습니다. 벽에 동아리 · 학회 홍보나 회사 채용 공고 포스터 등을 게시하기 위해 테이프로 붙였다가 철거할 때 떼는 일이 많고 그 과정에서 페인트가 벗겨지곤 합니다. 페인트가 벗겨진 벽이 보기 흉해져 학교는 벽에 페인트를 덧칠하기로 했습니다.

넓은 벽 전체에 페인트를 새로 칠하는 대신, 구역을 나누어 일부만 페인트를 새로 칠 함으로써 예산을 아끼려 합니다. 이를 위해 벽을 1미터 길이의 구역 n개로 나누고, 각 구역에 왼쪽부터 순서대로 1번부터 n번까지 번호를 붙였습니다. 그리고 페인트를 다시 칠해야 할 구역들을 정했습니다.

벽에 페인트를 칠하는 롤러의 길이는 m미터이고, 롤러로 벽에 페인트를 한 번 칠하는 규칙은 다음과 같습니다.

롤러가 벽에서 벗어나면 안 됩니다.
구역의 일부분만 포함되도록 칠하면 안 됩니다.
즉, 롤러의 좌우측 끝을 구역의 경계선 혹은 벽의 좌우측 끝부분에 맞춘 후 롤러를 위아래로 움직이면서 벽을 칠합니다. 현재 페인트를 칠하는 구역들을 완전히 칠한 후 벽에서 롤러를 떼며, 이를 벽을 한 번 칠했다고 정의합니다.

한 구역에 페인트를 여러 번 칠해도 되고 다시 칠해야 할 구역이 아닌 곳에 페인트를 칠해도 되지만 다시 칠하기로 정한 구역은 적어도 한 번 페인트칠을 해야 합니다. 예산을 아끼기 위해 다시 칠할 구역을 정했듯 마찬가지로 롤러로 페인트칠을 하는 횟수를 최소화하려고 합니다.

정수 n, m과 다시 페인트를 칠하기로 정한 구역들의 번호가 담긴 정수 배열 section이 매개변수로 주어질 때 롤러로 페인트칠해야 하는 최소 횟수를 return 하는 solution 함수를 작성해 주세요

제한사항

1 ≤ m ≤ n ≤ 100,000
1 ≤ section의 길이 ≤ n
1 ≤ section의 원소 ≤ n
section의 원소는 페인트를 다시 칠해야 하는 구역의 번호입니다.
section에서 같은 원소가 두 번 이상 나타나지 않습니다.
section의 원소는 오름차순으로 정렬되어 있습니다.

문제풀이

// 페인트칠 횟수
int count = 0;
// 현재 구역에서 롤러로 칠할 수 있는 마지막 구역
int lastPainted = 0;

1. 변수 선언 부분입니다. 저는 변수를 2개 선언했습니다. count 변수는 롤러로 페인트칠을 몇 번 하였는지 카운트하는 것이고 lastPainted 변수는 현재 구역에서 롤러로 칠할 수 있는 마지막 구역입니다.

for(int i = 0; i < section.length; i++) {
   // 마지막 페인트칠한 끝 번호보다 큰 값이 있다면
   if(section[i] > lastPainted) {
       // 현재 구역에서 롤러로 칠할 수 있는 마지막 구역
       lastPainted = section[i] + m - 1; 
       count++;
   } 

}

2. for문을 돌려 lastPainted 값을 넣고 count 합니다. 하지만 여기에서는 if문으로 조건이 필요합니다. 마지막으로 롤러로 칠했던 구역보다 큰 구역이 있을 경우를 추가합니다.

전체코드

class Solution {
    public int solution(int n, int m, int[] section) {
        // 페인트칠 횟수
        int count = 0;
        // 현재 구역에서 롤러로 칠할 수 있는 마지막 구역
        int lastPainted = 0;

        for(int i = 0; i < section.length; i++) {
           // 마지막 페인트칠한 끝 번호보다 큰 값이 있다면
           if(section[i] > lastPainted) {
               // 현재 구역에서 롤러로 칠할 수 있는 마지막 구역
               lastPainted = section[i] + m - 1; 
               count++;
           } 

        }
        return count;
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/ 코딩테스트] 바탕화면 정리 (JAVA)

"주인장" — Fri, 18 Oct 2024 21:54:14 +0900

오늘의 코딩!!
바탕화면 깨끗이 정리

문제설명

코딩테스트를 준비하는 머쓱이는 프로그래머스에서 문제를 풀고 나중에 다시 코드를 보면서 공부하려고 작성한 코드를 컴퓨터 바탕화면에 아무 위치에나 저장해 둡니다. 저장한 코드가 많아지면서 머쓱이는 본인의 컴퓨터 바탕화면이 너무 지저분하다고 생각했습니다. 프로그래머스에서 작성했던 코드는 그 문제에 가서 다시 볼 수 있기 때문에 저장해 둔 파일들을 전부 삭제하기로 했습니다.

컴퓨터 바탕화면은 각 칸이 정사각형인 격자판입니다. 이때 컴퓨터 바탕화면의 상태를 나타낸 문자열 배열 wallpaper가 주어집니다. 파일들은 바탕화면의 격자칸에 위치하고 바탕화면의 격자점들은 바탕화면의 가장 왼쪽 위를 (0, 0)으로 시작해 (세로 좌표, 가로 좌표)로 표현합니다. 빈칸은 ".", 파일이 있는 칸은 "#"의 값을 가집니다. 드래그를 하면 파일들을 선택할 수 있고, 선택된 파일들을 삭제할 수 있습니다. 머쓱이는 최소한의 이동거리를 갖는 한 번의 드래그로 모든 파일을 선택해서 한 번에 지우려고 하며 드래그로 파일들을 선택하는 방법은 다음과 같습니다.

드래그는 바탕화면의 격자점 S(lux, luy)를 마우스 왼쪽 버튼으로 클릭한 상태로 격자점 E(rdx, rdy)로 이동한 뒤 마우스 왼쪽 버튼을 떼는 행동입니다. 이때, "점 S에서 점 E로 드래그한다"고 표현하고 점 S와 점 E를 각각 드래그의 시작점, 끝점이라고 표현합니다.

점 S(lux, luy)에서 점 E(rdx, rdy)로 드래그를 할 때, "드래그 한 거리"는 |rdx - lux| + |rdy - luy|로 정의합니다.

점 S에서 점 E로 드래그를 하면 바탕화면에서 두 격자점을 각각 왼쪽 위, 오른쪽 아래로 하는 직사각형 내부에 있는 모든 파일이 선택됩니다.

예를 들어 wallpaper = [".#...", "..#..", "...#."]인 바탕화면을 그림으로 나타내면 다음과 같습니다.

[출처] 프로그래머스 > 바탕화면 정리 (1)

이러한 바탕화면에서 다음 그림과 같이 S(0, 1)에서 E(3, 4)로 드래그하면 세 개의 파일이 모두 선택되므로 드래그 한 거리 (3 - 0) + (4 - 1) = 6을 최솟값으로 모든 파일을 선택 가능합니다.

[출처] 프로그래머스 > 바탕화면 정리 (2)

(0, 0)에서 (3, 5)로 드래그해도 모든 파일을 선택할 수 있지만 이때 드래그 한 거리는 (3 - 0) + (5 - 0) = 8이고 이전의 방법보다 거리가 늘어납니다.

머쓱이의 컴퓨터 바탕화면의 상태를 나타내는 문자열 배열 wallpaper가 매개변수로 주어질 때 바탕화면의 파일들을 한 번에 삭제하기 위해 최소한의 이동거리를 갖는 드래그의 시작점과 끝점을 담은 정수 배열을 return하는 solution 함수를 작성해 주세요. 드래그의 시작점이 (lux, luy), 끝점이 (rdx, rdy)라면 정수 배열 [lux, luy, rdx, rdy]를 return하면 됩니다.

제안사항

1 ≤ wallpaper의 길이 ≤ 50
1 ≤ wallpaper[i]의 길이 ≤ 50
wallpaper의 모든 원소의 길이는 동일합니다.
wallpaper[i][j]는 바탕화면에서 i + 1행 j + 1열에 해당하는 칸의 상태를 나타냅니다.
wallpaper[i][j]는 "#" 또는 "."의 값만 가집니다.
바탕화면에는 적어도 하나의 파일이 있습니다.
드래그 시작점 (lux, luy)와 끝점 (rdx, rdy)는 lux < rdx, luy < rdy를 만족해야 합니다.

문제풀이

// S(lux, luy)
int lux = Integer.MAX_VALUE;
int luy = Integer.MAX_VALUE;

// E(rdx, rdy)
int rdx = Integer.MIN_VALUE;
int rdy = Integer.MIN_VALUE;

1. S(Lux, Luy)의 최솟값을 구하기 위해 초기화 값을 Integer.MAX_VALUE를 사용하고 Math.min(lux, i)를 통해 값을 비교하여 최솟값을 찾는다. E(Rdx, Rdy) 값은 최댓값을 구하기 위해 초기화 값을 Integer.MIN_VALUE를 사용하고 Math.max(rdx, i)를 통해 값을 비교하여 최댓값을 찾는다.

for(int i = 0; i < wallpaper.length; i++) {
    for(int j = 0; j < wallpaper[i].length(); j++) {
        if(wallpaper[i].charAt(j) == '#') {
            // S(lux, luy)
            lux = Math.min(lux, i);
            luy = Math.min(luy, j);

            // E(rdx, rdy)
            rdx = Math.max(rdx, i);
            rdy = Math.max(rdy, j);
        }
    }
}

2. 이중 for문을 사용하여 '#' 문자를 찾아 S의 최솟값, E의 최댓값을 비교한다.

return new int[] {lux, luy, rdx + 1, rdy + 1};

3. 값을 return합니다. rdx + 1, rdy +1에 각 +1 한 이유는 좌표를 재설정해주기 위해서이다.

전체코드

class Solution {
    public int[] solution(String[] wallpaper) {
        // S(lux, luy)
        int lux = Integer.MAX_VALUE;
        int luy = Integer.MAX_VALUE;
        
        // E(rdx, rdy)
        int rdx = Integer.MIN_VALUE;
        int rdy = Integer.MIN_VALUE;    
           
        for(int i = 0; i < wallpaper.length; i++) {
            for(int j = 0; j < wallpaper[i].length(); j++) {
                if(wallpaper[i].charAt(j) == '#') {
                    // S(lux, luy)
                    lux = Math.min(lux, i);
                    luy = Math.min(luy, j);
                    
                    // E(rdx, rdy)
                    rdx = Math.max(rdx, i);
                    rdy = Math.max(rdy, j);
                }
            }
        }
        
        return new int[] {lux, luy, rdx + 1, rdy + 1};
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/ 코딩테스트] 공원 산책 (JAVA)

"주인장" — Wed, 16 Oct 2024 17:38:33 +0900

오늘도 등장한 코딩 테스트!!
공원 산책 위험해~

문제설명

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

["방향 거리", "방향 거리" … ]
예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.
위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다.

[출처] 프로그래머스 코딩테스트 연습 > 연습문제 > 공원 산책

공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

3 ≤ park의 길이 ≤ 50
3 ≤ park[i]의 길이 ≤ 50
park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
S : 시작 지점
O : 이동 가능한 통로
X : 장애물
park는 직사각형 모양입니다.
1 ≤ routes의 길이 ≤ 50
routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
op는 다음 네 가지중 하나로 이루어져 있습니다.
N : 북쪽으로 주어진 칸만큼 이동합니다.
S : 남쪽으로 주어진 칸만큼 이동합니다.
W : 서쪽으로 주어진 칸만큼 이동합니다.
E : 동쪽으로 주어진 칸만큼 이동합니다.
1 ≤ n ≤ 9

문제풀이

//현재 위치
int X = 0;
int Y = 0;

1. 현재 위치를 담기 위해서 변수를 초기화한다.

// 시작위치 찾기
for(int i = 0; i < park.length; i++) {
   for(int j = 0; j < park[i].length(); j++) {
       if(park[i].charAt(j) == 'S') {
           X = i;
           Y = j;
       }
   }
}

2. 매개변수 값으로 받은 park를 사용하여 시작위치를 찾는다. park가 2차원 배열은 아니지만 이중 for문을 사용할 수 있었던 이유는 charAt 함수를 사용해서 2차원 배열처럼 사용할 수 있기 때문이다.

// 이동 명령 처리
for(String route : routes) {
    String[] parts = route.split(" ");

    String direction = parts[0];
    int distance = Integer.parseInt(parts[1]);

    ...(생략)
}

3. 매개변수 값인 routes를 사용해서 direction(방향), distance(거리) 변수를 생성한다.

// 임시 변수
int tempX = X;
int tempY = Y;

boolean flog = true;

4. 임시 변수 tempX, tempY를 생성한다. 이유는 공원을 벗어는지, 장애물을 만나는지와 같은 검사를 할 때 for문을 돌 때마다 실시간으로 확인을 해야하기 때문이다.

for(int d = 0; d < distance; d++) {
    if(direction.equals("N")) {
        tempX--;
    } else if(direction.equals("S")) {
        tempX++; 
    } else if(direction.equals("W")) {
        tempY--; 
    } else if(direction.equals("E")) {
        tempY++;
    }

    if(tempX < 0 || tempX >= park.length || tempY < 0 || tempY >= park[0].length() || park[tempX].charAt(tempY) == 'X') {
    flog = false;
    break;
    }

}

if(flog) {
    X = tempX;
    Y = tempY;
}

5. if문을 사용해서 동서남북으로 거리를 이동시킨다. 여기서 중요한 점은 for문을 돌릴 때 distance(거리)로 돌려야 한다는 점이다. 이 후 유효성 if문를 사용하여 X, Y에 값을 넣는다.

return new int[] {X, Y};

6. 배열로 return하기 때문에 X, Y를 담은 객체를 하나 생성한다.

전체코드

class Solution {
    public int[] solution(String[] park, String[] routes) {

        //현재 위치
        int X = 0;
        int Y = 0;
        
        
        // 시작위치 찾기
        for(int i = 0; i < park.length; i++) {
           for(int j = 0; j < park[i].length(); j++) {
               if(park[i].charAt(j) == 'S') {
                   X = i;
                   Y = j;
               }
           }
        }
        
        // 이동 명령 처리
        for(String route : routes) {
            String[] parts = route.split(" ");
            
            String direction = parts[0];
            int distance = Integer.parseInt(parts[1]);
            
            // 임시 변수
            int tempX = X;
            int tempY = Y;
            
            boolean flog = true;
            
            for(int d = 0; d < distance; d++) {
                if(direction.equals("N")) {
                    tempX--;
                } else if(direction.equals("S")) {
                    tempX++; 
                } else if(direction.equals("W")) {
                    tempY--; 
                } else if(direction.equals("E")) {
                    tempY++;
                }
                
                if(tempX < 0 || tempX >= park.length || tempY < 0 || tempY >= park[0].length() || park[tempX].charAt(tempY) == 'X') {
                flog = false;
                break;
                }
                
            }
            
            if(flog) {
                X = tempX;
                Y = tempY;
            }
        }
        
        return new int[] {X, Y};
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/ 코딩테스트] 추억 점수 (JAVA)

"주인장" — Tue, 15 Oct 2024 20:02:08 +0900

점점 성장하는 개발자!!
가 되기 위한
한걸음

문제설명

사진들을 보며 추억에 젖어 있던 루는 사진별로 추억 점수를 매길려고 합니다. 사진 속에 나오는 인물의 그리움 점수를 모두 합산한 값이 해당 사진의 추억 점수가 됩니다. 예를 들어 사진 속 인물의 이름이 ["may", "kein", "kain"]이고 각 인물의 그리움 점수가 [5점, 10점, 1점]일 때 해당 사진의 추억 점수는 16(5 + 10 + 1)점이 됩니다. 다른 사진 속 인물의 이름이 ["kali", "mari", "don", "tony"]이고 ["kali", "mari", "don"]의 그리움 점수가 각각 [11점, 1점, 55점]]이고, "tony"는 그리움 점수가 없을 때, 이 사진의 추억 점수는 3명의 그리움 점수를 합한 67(11 + 1 + 55)점입니다.

그리워하는 사람의 이름을 담은 문자열 배열 name, 각 사람별 그리움 점수를 담은 정수 배열 yearning, 각 사진에 찍힌 인물의 이름을 담은 이차원 문자열 배열 photo가 매개변수로 주어질 때, 사진들의 추억 점수를 photo에 주어진 순서대로 배열에 담아 return하는 solution 함수를 완성해주세요.

제한사항

3 ≤ name의 길이 = yearning의 길이≤ 100
3 ≤ name의 원소의 길이 ≤ 7
name의 원소들은 알파벳 소문자로만 이루어져 있습니다.
name에는 중복된 값이 들어가지 않습니다.
1 ≤ yearning[i] ≤ 100
yearning[i]는 i번째 사람의 그리움 점수입니다.
3 ≤ photo의 길이 ≤ 100
1 ≤ photo[i]의 길이 ≤ 100
3 ≤ photo[i]의 원소(문자열)의 길이 ≤ 7
photo[i]의 원소들은 알파벳 소문자로만 이루어져 있습니다.
photo[i]의 원소들은 중복된 값이 들어가지 않습니다.

문제풀이

//해시맵 객체 생성
HashMap<String, Integer> map = new HashMap<>();

1. 키, 값을 담는 HashMap 자료구조를 사용한다.

// name과 yearning을 map에 저장
for (int i = 0; i < name.length; i++) {
    map.put(name[i], yearning[i]);
}

2. HashMap 자료구조에 값을 넣는다.

// 결과를 담을 배열
int[] answer = new int[photo.length];

3. 결과 값이 배열로 나가기 때문에 배열 객체를 생성하고 길이는 photo의 길이로 한다.

//사진 별 점수 합
for(int i = 0; i < photo.length; i++) {
    int sum = 0;
    for(String ph : photo[i]) {
	...(생략)
    }
}

4. photo의 매개변수가 2차 배열이라서 이중 배열을 사용한다. 그리고 photo의 점수가 필요하기 때문에 지역변수인 int sum를 초기화한다.

if(map.containsKey(ph)) {
   sum += map.get(ph);
}

answer[i] = sum;

5. if문을 사용해서 map에 ph와 동일한 이름이 있다면 sum(합)한다. 그리고 결과 배열에 담는다.

전체코드

import java.util.HashMap;

class Solution {
    public int[] solution(String[] name, int[] yearning, String[][] photo) {
        //해시맵 객체 생성
        HashMap<String, Integer> map = new HashMap<>();
        
        //행시맵 값
        for(int i = 0; i < name.length; i++) {
            map.put(name[i], yearning[i]);
        }
        
        //결과 값 담을 배열
        int[] answer = new int[photo.length];
        
        //사진 별 점수 합
        for(int i = 0; i < photo.length; i++) {
            int sum = 0;
            for(String ph : photo[i]) {
                if(map.containsKey(ph)) {
                   sum += map.get(ph);
                }
            }
            answer[i] = sum;
        }
        
        return answer;
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/ 코딩테스트] 달리기 경주 (JAVA)

"주인장" — Sat, 12 Oct 2024 22:34:58 +0900

안녕하세요.
오늘의 달리기 경주!!
RUN

오늘의 문제 풀이는 2가지입니다.

1. 이중 for문을 사용한 알고리즘

2. HashMap 자료구조를 사용한 알고리즘

문제설명

얀에서는 매년 달리기 경주가 열립니다. 해설진들은 선수들이 자기 바로 앞의 선수를 추월할 때 추월한 선수의 이름을 부릅니다. 예를 들어 1등부터 3등까지 "mumu", "soe", "poe" 선수들이 순서대로 달리고 있을 때, 해설진이 "soe"선수를 불렀다면 2등인 "soe" 선수가 1등인 "mumu" 선수를 추월했다는 것입니다. 즉 "soe" 선수가 1등, "mumu" 선수가 2등으로 바뀝니다.

선수들의 이름이 1등부터 현재 등수 순서대로 담긴 문자열 배열 players와 해설진이 부른 이름을 담은 문자열 배열 callings가 매개변수로 주어질 때, 경주가 끝났을 때 선수들의 이름을 1등부터 등수 순서대로 배열에 담아 return 하는 solution 함수를 완성해주세요.

제한사항

5 ≤ players의 길이 ≤ 50,000
players[i]는 i번째 선수의 이름을 의미합니다.
players의 원소들은 알파벳 소문자로만 이루어져 있습니다.
players에는 중복된 값이 들어가 있지 않습니다.
3 ≤ players[i]의 길이 ≤ 10
2 ≤ callings의 길이 ≤ 1,000,000
callings는 players의 원소들로만 이루어져 있습니다.
경주 진행중 1등인 선수의 이름은 불리지 않습니다.

1. 문제풀이 (이중 for문)

class Solution {
    public String[] solution(String[] players, String[] callings) {
        
        //이중 for문
        for(int i = 0; i < callings.length; i++) {
            for(int j = 0; j < players.length; j++) {
            
            	// 선수 순서바꾸기
                if(callings[i].equals(players[j])) {
                    String temp = players[j-1];
                    players[j-1] = players[j];
                    players[j] = temp;
                    break;
                } 
            }
        } 
        
        return players;
    }
}

1. 이중 for문을 사용하여 선수의 순서를 바꾸는 코드입니다. 이 코드의 문제는 이중 for문을 사용하기 때문에 성능이 좋지 않습니다. 그래서 프로그래머스에서 이 코드를 사용할 경우에 시간 초과로 인한 실패 문구가 뜹니다. 그래서 저는 이중 for문를 사용하지 않고 HashMap를 사용해 다시 코딩을 했어요!

2. 문제풀이 (HashMap)

// 해시맵
HashMap<String, Integer> playerIndex = new HashMap<>();

1. 해시맵 객체를 생성합니다. 키에는 이름이 들어가고 값에는 등수(index)가 들어가요.

// 해시맵 값 저장
for(int i = 0; i < players.length; i++) {
    playerIndex.put(players[i], i);
}

2. 해시맵 객체를 생성했으니 값을 매개변수를 활용해서 값을 넣어요.

// 선수 순서 업데이트
for(String calling : callings) {
	// 불린 선수 현재 인덱스 값
    int currentIndex = playerIndex.get(calling);

    // 1등은 호출되지 않음 2등부터 시작
    if(currentIndex > 0) {
        String temp = players[currentIndex - 1];
        players[currentIndex - 1] = players[currentIndex];
        players[currentIndex] = temp;

		//해시값 업데이트
        playerIndex.put(calling, currentIndex - 1);
        playerIndex.put(temp, currentIndex);

    }

}

3. 불린 선수 인덱스를 가지고 선수의 위치를 변경 후 해쉬맵 값을 업데이트합니다.

전체코드

import java.util.HashMap;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        // 해시맵
        HashMap<String, Integer> playerIndex = new HashMap<>();
        
        // 해시맵 값 저장
        for(int i = 0; i < players.length; i++) {
            playerIndex.put(players[i], i);
        }
        
        // 선수 순서 업데이트
        for(String calling : callings) {
            int currentIndex = playerIndex.get(calling);
            
            // 1등은 호출되지 않음 2등부터 시작
            if(currentIndex > 0) {
                String temp = players[currentIndex - 1];
                players[currentIndex - 1] = players[currentIndex];
                players[currentIndex] = temp;

                
                playerIndex.put(calling, currentIndex - 1);
                playerIndex.put(temp, currentIndex);
                
            }
            
        }
        
        
        return players;
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/ 코딩테스트] PCCE 기출문제 10번 / 데이터 분석 (JAVA)

"주인장" — Mon, 7 Oct 2024 21:22:03 +0900

안녕하세요.
끊임없이 전진하는 개발자가 있다고?
It's me

문제 설명

AI 엔지니어인 현식이는 데이터를 분석하는 작업을 진행하고 있습니다. 데이터는 ["코드 번호(code)", "제조일(date)", "최대 수량(maximum)", "현재 수량(remain)"]으로 구성되어 있으며 현식이는 이 데이터들 중 조건을 만족하는 데이터만 뽑아서 정렬하려 합니다.

예를 들어 다음과 같이 데이터가 주어진다면

data = [[1, 20300104, 100, 80], [2, 20300804, 847, 37], [3, 20300401, 10, 8]]
이 데이터는 다음 표처럼 나타낼 수 있습니다.

code date maximum remain
1 20300104 100 80
2 20300804 847 37
3 20300401 10 8

주어진 데이터 중 "제조일이 20300501 이전인 물건들을 현재 수량이 적은 순서"로 정렬해야 한다면 조건에 맞게 가공된 데이터는 다음과 같습니다.

data = [[3,20300401,10,8],[1,20300104,100,80]]
정렬한 데이터들이 담긴 이차원 정수 리스트 data와 어떤 정보를 기준으로 데이터를 뽑아낼지를 의미하는 문자열 ext, 뽑아낼 정보의 기준값을 나타내는 정수 val_ext, 정보를 정렬할 기준이 되는 문자열 sort_by가 주어집니다.

data에서 ext 값이 val_ext보다 작은 데이터만 뽑은 후, sort_by에 해당하는 값을 기준으로 오름차순으로 정렬하여 return 하도록 solution 함수를 완성해 주세요. 단, 조건을 만족하는 데이터는 항상 한 개 이상 존재합니다.

제한사항

1 ≤ data의 길이 ≤ 500
data[i]의 원소는 [코드 번호(code), 제조일(date), 최대 수량(maximum), 현재 수량(remain)] 형태입니다.
1 ≤ 코드 번호≤ 100,000
20000101 ≤ 제조일≤ 29991231
data[i][1]은 yyyymmdd 형태의 값을 가지며, 올바른 날짜만 주어집니다. (yyyy : 연도, mm : 월, dd : 일)
1 ≤ 최대 수량≤ 10,000
1 ≤ 현재 수량≤ 최대 수량
ext와 sort_by의 값은 다음 중 한 가지를 가집니다.
"code", "date", "maximum", "remain"
순서대로 코드 번호, 제조일, 최대 수량, 현재 수량을 의미합니다.
val_ext는 ext에 따라 올바른 범위의 숫자로 주어집니다.
정렬 기준에 해당하는 값이 서로 같은 경우는 없습니다.

문제풀이

// 필터링된 데이터를 저장할 리스트
List<int[]> filter = new ArrayList<>();

1. return를 위한 값을 위해 리스트 자료형을 사용했다.

        // 조건에 맞는 데이터 찾기
        for(int[] part : data) {
            int extValue = 0;
            
            switch(ext) {
                // 코드 번호    
                case "code":
                     extValue = part[0];
                     break;
                // 제조일      
                case "date":
                     extValue = part[1];
                     break;
                // 최대 수량    
                case "maximum":
                     extValue = part[2];
                     break;
                // 현재 수량    
                case "remain":
                     extValue = part[3];
                     break;                        
            }

            // 조건에 맞는 데이터
            if(extValue < val_ext) {
                filter.add(part);
            }
        }

2. 조건에 맞는 데이터를 찾기 위해 for문을 돌리고 for문 안에 swich문을 사용하여 매개변수가 올바르게 들어가도록 설정한다. 그리고 if문을 사용하여 조건에 맞는 데이터를 추가한다.

 //sort_by에 따라 정렬
Comparator<int[]> comparator = null;

switch(sort_by) {
    case "code":
        comparator = Comparator.comparingInt(arr -> arr[0]);
        break;
    case "date":
        comparator = Comparator.comparingInt(arr -> arr[1]);
        break;
    case "maximum":
        comparator = Comparator.comparingInt(arr -> arr[2]);
        break;
    case "remain":
        comparator = Comparator.comparingInt(arr -> arr[3]);
        break;
    
     // 데이터 정렬 
     filter.sort(comparator);
}

3. 정렬을 하기 위해서 사용자 정의 정렬인 Comparator 비교자를 사용한다. switch문을 사용해 정렬 기준을 무엇으로 할지 설정 후 sort 함수를 사용해 정렬한다.

// 2차 배열로 변환
int[][] result = new int[filter.size()][];
return filter.toArray(result);

4. 2차 배열로 반환하기 위한 2차 배열 (result)을 생성한다. 배열의 크기는 filter에 쌓인 데이터 값으로 하고 toArray 함수를 사용하여 빈 배열인 result에 filter에 쌓인 값을 복사한다.

전체코드

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Solution {
    public int[][] solution(int[][] data, String ext, int val_ext, String sort_by) {
        // 필터링된 데이터를 저장할 리스트
        List<int[]> filter = new ArrayList<>();
        
        // 조건에 맞는 데이터 찾기
        for(int[] part : data) {
            int extValue = 0;
            
            switch(ext) {
                // 코드 번호    
                case "code":
                     extValue = part[0];
                     break;
                // 제조일      
                case "date":
                     extValue = part[1];
                     break;
                // 최대 수량    
                case "maximum":
                     extValue = part[2];
                     break;
                // 현재 수량    
                case "remain":
                     extValue = part[3];
                     break;                        
            }

            // 조건에 맞는 데이터
            if(extValue < val_ext) {
                filter.add(part);
            }
        }
        
        //sort_by에 따라 정렬
        Comparator<int[]> comparator = null;
        
        switch(sort_by) {
            case "code":
                comparator = Comparator.comparingInt(arr -> arr[0]);
                break;
            case "date":
                comparator = Comparator.comparingInt(arr -> arr[1]);
                break;
            case "maximum":
                comparator = Comparator.comparingInt(arr -> arr[2]);
                break;
            case "remain":
                comparator = Comparator.comparingInt(arr -> arr[3]);
                break;
        }
        
       // 데이터 정렬 
       filter.sort(comparator);
       
       // 2차 배열로 변환
       int[][] result = new int[filter.size()][];
       return filter.toArray(result);
        
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/코딩 테스트] PCCE 기출문제 9번 / 이웃한 칸 (JAVA)

"주인장" — Fri, 4 Oct 2024 23:15:16 +0900

오늘도
아자아자!!!

문제 설명

각 칸마다 색이 칠해진 2차원 격자 보드판이 있습니다. 그중 한 칸을 골랐을 때, 위, 아래, 왼쪽, 오른쪽 칸 중 같은 색깔로 칠해진 칸의 개수를 구하려고 합니다.

보드의 각 칸에 칠해진 색깔 이름이 담긴 이차원 문자열 리스트 board와 고른 칸의 위치를 나타내는 두 정수 h, w가 주어질 때 board[h][w]와 이웃한 칸들 중 같은 색으로 칠해져 있는 칸의 개수를 return 하도록 solution 함수를 완성해 주세요.

이웃한 칸들 중 몇 개의 칸이 같은 색으로 색칠되어 있는지 확인하는 과정은 다음과 같습니다.

제한사항

1 ≤ board의 길이 ≤ 7
board의 길이와 board[n]의 길이는 동일합니다.
0 ≤ h, w < board의 길이
1 ≤ board[h][w]의 길이 ≤ 10
board[h][w]는 영어 소문자로만 이루어져 있습니다.

문제풀이

int n = board.length;

1. 정수를 저장할 변수 n을 만들고 board의 길이를 저장합니다.

int count = 0;

2. 같은 색으로 색칠된 칸의 개수를 저장할 변수 count를 만들고 0을 저장합니다.

int[] dh = {0,1,-1,0};
int[] dw = {1,0,0,-1};

3. h와 w의 변화량을 저장할 정수 리스트 dh, dw를 만들고 각각 [0, 1, -1, 0], [1, 0, 0, -1]을 저장합니다.

 for(int i=0; i< 4; i++) {
  '''(생략)
 }

4. 반복문을 이용해 i 값을 0부터 3까지 1 씩 증가시키며 아래 작업을 반복합니다.

int h_check = h + dh[i];
int w_check = w + dw[i];

4-1. 체크할 칸의 h, w 좌표를 나타내는 변수 h_check, w_check를 만들고 각각 h + dh[i], w + dw[i]를 저장합니다.

 if(h_check >= 0 && h_check < n && w_check >= 0 && w_check < n) {
 	...(생략)
 }

4-2. h_check가 0 이상 n 미만이고 w_check가 0 이상 n 미만이라면 다음을 수행합니다.

if(board[h][w].equals(board[h_check][w_check])) {
  count++;
}

4-3 board[h][w]와 board[h_check][w_check]의 값이 동일하다면 count의 값을 1 증가시킵니다.

전체코드

class Solution {
    public int solution(String[][] board, int h, int w) {
        int n = board.length;
        int count = 0;
        int[] dh = {0,1,-1,0};
        int[] dw = {1,0,0,-1};
        
        for(int i=0; i< 4; i++) {
            int h_check = h + dh[i];
            int w_check = w + dw[i]; 
            
            if(h_check >= 0 && h_check < n && w_check >= 0 && w_check < n) {
                if(board[h][w].equals(board[h_check][w_check])) {
                    count++;
                }
            }
        }
        
        return count;
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/코딩 테스트] 붕대 감기 (JAVA)

"주인장" — Mon, 30 Sep 2024 00:49:27 +0900

이번 문제 쉽지 않았다.
고민고민하다가 다른 분 코드를 조금 참고했다.
특히 시간 초 count 하는 부분이 헷갈렸다.
꾸준히 하다 보면 익숙해지겠지
아자아자!!

문제 설명

어떤 게임에는 붕대 감기라는 기술이 있습니다.

붕대 감기는 t초 동안 붕대를 감으면서 1초마다 x만큼의 체력을 회복합니다. t초 연속으로 붕대를 감는 데 성공한다면 y만큼의 체력을 추가로 회복합니다. 게임 캐릭터에는 최대 체력이 존재해 현재 체력이 최대 체력보다 커지는 것은 불가능합니다.

기술을 쓰는 도중 몬스터에게 공격을 당하면 기술이 취소되고, 공격을 당하는 순간에는 체력을 회복할 수 없습니다. 몬스터에게 공격당해 기술이 취소당하거나 기술이 끝나면 그 즉시 붕대 감기를 다시 사용하며, 연속 성공 시간이 0으로 초기화됩니다.

몬스터의 공격을 받으면 정해진 피해량만큼 현재 체력이 줄어듭니다. 이때, 현재 체력이 0 이하가 되면 캐릭터가 죽으며 더 이상 체력을 회복할 수 없습니다.

당신은 붕대감기 기술의 정보, 캐릭터가 가진 최대 체력과 몬스터의 공격 패턴이 주어질 때 캐릭터가 끝까지 생존할 수 있는지 궁금합니다.

붕대 감기 기술의 시전 시간, 1초당 회복량, 추가 회복량을 담은 1차원 정수 배열 bandage와 최대 체력을 의미하는 정수 health, 몬스터의 공격 시간과 피해량을 담은 2차원 정수 배열 attacks가 매개변수로 주어집니다. 모든 공격이 끝난 직후 남은 체력을 return 하도록 solution 함수를 완성해 주세요. 만약 몬스터의 공격을 받고 캐릭터의 체력이 0 이하가 되어 죽는다면 -1을 return 해주세요.

제한사항

bandage는 [시전 시간, 초당 회복량, 추가 회복량] 형태의 길이가 3인 정수 배열입니다.
1 ≤ 시전 시간 = t ≤ 50
1 ≤ 초당 회복량 = x ≤ 100
1 ≤ 추가 회복량 = y ≤ 100
1 ≤ health ≤ 1,000
1 ≤ attacks의 길이 ≤ 100
attacks[i]는 [공격 시간, 피해량] 형태의 길이가 2인 정수 배열입니다.
attacks는 공격 시간을 기준으로 오름차순 정렬된 상태입니다.
attacks의 공격 시간은 모두 다릅니다.
1 ≤ 공격 시간 ≤ 1,000
1 ≤ 피해량 ≤ 100

문제풀이

    // 추가 회복량 카운트(초)
    int healingTime = 0;
    // 최대 체력
    int maxHealth;

1. 전역 변수이다. healingTime 변수는 bandage[0]와 비교하여 y(추가 회복량)를 줄지 말지 결정을 위한 변수이다. maxHealth는 health값을 사용하여 최대값을 확인할 수 있는 변수이다.

	maxHealth = health;  // 최대 체력 설정
        int currentTime = 0; // 현재 시간
        
        // 전체 공격
        for (int[] attack : attacks) {
            int attackTime = attack[0];   // 공격시간
            int damage = attack[1];       // 피해량
            ...
            ...(생략)
            ...
            
            health -= damage; // 공격에 의한 체력 감소
            healingTime = 0;  // 공격을 받으면 추가 회복량 카운트(초) 초기화
            
            // 체력이 0 이하가 되면 -1 return
            if (health <= 0) {
               return -1;  
            }
            
            currentTime++; // 시간 증가
        }

2. health값을 사용하여 maxHealth 변수에 최대 체력을 설정 및 현재 시간을 초기화한다. 그다음 전체 공격을 파악하기 위해 for문을 사용한다. attackTime(공격시간), damage(피해량) 변수에 값을 넣고 health(현재 체력)에 damage 값을 뺀다. 마지막에는 currentTime(현재시간)을 증가시킨다.

            // 전체 회복
            while (currentTime < attackTime) {
                // x 회복
                if (health + bandage[1] <= maxHealth) {
                    health += bandage[1];
                } else {
                    health = maxHealth; 
                }

                healingTime++; // 회복 시간 증가
                currentTime++; // 시간 증가

                // y 회복
                if (healingTime == bandage[0]) {
                    if (health + bandage[2] <= maxHealth) {
                        health += bandage[2];
                    } else {
                        health = maxHealth; 
                    }
                    healingTime = 0; // 추가 회복량 카운트(초) 초기화
                }
            }

3. x 회복은 초당 회복량을 위한 코드이고, y 회복은 추가 회복량을 위한 코드이다. 중요한 부분은 maxHealth 보다 크면 안 되기 때문에 if문 처리를 해야 한다.

전체코드

class Solution {
    // 추가 회복량 카운트(초)
    int healingTime = 0;
    // 최대 체력
    int maxHealth;

    public int solution(int[] bandage, int health, int[][] attacks) {
        maxHealth = health;  // 최대 체력 설정
        int currentTime = 0; // 현재 시간
        
        // 전체 공격
        for (int[] attack : attacks) {
            int attackTime = attack[0];   // 공격시간
            int damage = attack[1];       // 피해량

            // 전체 회복
            while (currentTime < attackTime) {
                // x 회복
                if (health + bandage[1] <= maxHealth) {
                    health += bandage[1];
                } else {
                    health = maxHealth; 
                }

                healingTime++; // 회복 시간 증가
                currentTime++; // 시간 증가

                // y 회복
                if (healingTime == bandage[0]) {
                    if (health + bandage[2] <= maxHealth) {
                        health += bandage[2];
                    } else {
                        health = maxHealth; 
                    }
                    healingTime = 0; // 추가 회복량 카운트(초) 초기화
                }
            }
           
            health -= damage; // 공격에 의한 체력 감소
            healingTime = 0;  // 공격을 받으면 추가 회복량 카운트(초) 초기화
            
            // 체력이 0 이하가 되면 -1 return
            if (health <= 0) {
               return -1;  
            }
            
            currentTime++; // 시간 증가
        }
        
        return health;  // 모든 공격을 견뎌낸 후의 남은 체력 반환
    }
}

[프로그래머스/코딩테스트] PCCE 기출문제 10번 / 공원(JAVA)

"주인장" — Thu, 26 Sep 2024 20:42:55 +0900

안녕하세요.
이번에는 공원 빈자리에 돗자리를 까는
코딩 문제를 가지고 왔어요.

2차원 배열이라서 그런지
for문 지옥이었어요.

문제 설명

지민이는 다양한 크기의 정사각형 모양 돗자리를 가지고 공원에 소풍을 나왔습니다. 공원에는 이미 돗자리를 깔고 여가를 즐기는 사람들이 많아 지민이가 깔 수 있는 가장 큰 돗자리가 어떤 건지 확인하려 합니다. 예를 들어 지민이가 가지고 있는 돗자리의 한 변 길이가 5, 3, 2 세 종류이고, 사람들이 다음과 같이 앉아 있다면 지민이가 깔 수 있는 가장 큰 돗자리는 3x3 크기입니다.

출처: 프로그래머스 [PCCE 기출문제] 10번

지민이가 가진 돗자리들의 한 변의 길이들이 담긴 정수 리스트 mats, 현재 공원의 자리 배치도를 의미하는 2차원 문자열 리스트 park가 주어질 때 지민이가 깔 수 있는 가장 큰 돗자리의 한 변 길이를 return 하도록 solution 함수를 완성해 주세요. 아무런 돗자리도 깔 수 없는 경우 -1을 return합니다.

제한사항

1 ≤ mats의 길이 ≤ 10
1 ≤ mats의 원소 ≤ 20
mats는 중복된 원소를 가지지 않습니다.
1 ≤ park의 길이 ≤ 50
1 ≤ park[i]의 길이 ≤ 50
park[i][j]의 원소는 문자열입니다.
park[i][j]에 돗자리를 깐 사람이 없다면 "-1", 사람이 있다면 알파벳 한 글자로 된 값을 갖습니다.

문제풀이

    // 세로
    int rows = park.length; 

    // 가로
    int cols = park[0].length;

1. 파라미터인 String[][] park에서 받은 2차원 배열 값의 세로 길이, 가로 길이를 구한다.

    // 돗자리 크기 내림차순 정렬
    Arrays.sort(mats);

    // 돗자리를 큰 것부터 확인
    for(int z = mats.length -1; z>=0; z--) {
        // 현재 돗자리 크기
        int size = mats[z];
    }

2. 지문에서 지민이가 깔 수 있는 가장 큰 돗자리의 한 변의 길이를 원하였기 때문에 내림차순 정렬을 사용 후 for문을 사용하여 size에 5 → 3 → 2 순으로 값이 들어가게 한다.

    // 모든 위치에 돗자리를 놓을 수 있는 곳 확인 (2차 배열이라서 2중 for문 사용)
    for(int row = 0; row <= rows - size; row++) {
        for(int col = 0; col <= cols - size; col++) {
        }
    }

3. 2차원 배열은 2중 for문을 사용해야 하며, 모든 위치에 돗자리를 놓을 수 있는 곳을 확인한다.

    // 현재 위치 돗자리 가능 여부
    boolean place = true;

    // 위의 조건을 마친 후 돗자리가 이미 존재 유무 판단을 위해 다시 2중 for문 사용
    for(int i = row; i < row + size; i++) {
        for(int j = col; j < col + size; j++) {
            // 다른 사람의 돗자리가 없는 곳 확인
            if(!park[i][j].equals("-1")) {
                place = false;
                break;
            }                        
        }
        // 2중 for문이라 다시한번 다른 사람의 돗자리가 없는 곳 확인
        if(!place) {
            break;
        }
    }

    // 빈자리의 경우 돗자리의 사이즈 반환
    if(place) {
        return size;
    }

4. 모든 위치에 돗자리를 놓을 수 있는 곳을 확인 후 다시 한번 2중 for문을 돌려야 한다. 왜냐하면 그 장소에 이미 돗자리가 깔린 자리가 있을 수 있으므로 if 조건문을 사용하여 필터링한다. 여기서 중요한 부분은 boolean place라는 변수를 사용하여 flag를 한다. 조건이 다 끝난 후 돗자리의 사이즈를 반환한다.

    // 돗자리를 놓을 수 없는 경우 -1
    return -1;

5. 돗자리를 놓을 수 없는 경우에는 -1 값을 return한다.

전체코드

import java.util.Arrays;

class Solution {
    public int solution(int[] mats, String[][] park) {
        // 세로
        int rows = park.length; 
        
        // 가로
        int cols = park[0].length;
        
        // 돗자리 크기 내림차순 정렬
        Arrays.sort(mats);
        
        // 돗자리를 큰 것부터 확인
        for(int z = mats.length -1; z>=0; z--) {
            // 현재 돗자리 크기
            int size = mats[z];
            
            // 모든 위치에 돗자리를 놓을 수 있는 곳 확인 (2차 배열이라서 2중 for문 사용)
            for(int row = 0; row <= rows - size; row++) {
                for(int col = 0; col <= cols - size; col++) {
                    // 현재 위치 돗자리 가능 여부
                    boolean place = true;
                    
                    // 위의 조건을 마친 후 돗자리가 이미 존재 유무 판단을 위해 다시 2중 for문 사용
                    for(int i = row; i < row + size; i++) {
                        for(int j = col; j < col + size; j++) {
                            // 다른 사람의 돗자리가 없는 곳 확인
                            if(!park[i][j].equals("-1")) {
                                place = false;
                                break;
                            }                        
                        }
                        // 2중 for문이라 다시한번 다른 사람의 돗자리가 없는 곳 확인
                        if(!place) {
                            break;
                        }
                    }
                    
                    // 빈자리의 경우 돗자리의 사이즈 반환
                    if(place) {
                        return size;
                    }
                    
                }
            }
            
        }
        
        // 돗자리를 놓을 수 없는 경우 -1
        return -1;
        
    }
}

프로그래머스

programmers.co.kr

[프로그래머스/코딩 테스트] PCCE 기출문제 9번 / 지폐 접기(JAVA)

"주인장" — Mon, 23 Sep 2024 18:48:46 +0900

안녕하세요.
오늘은 지폐 접기 관련 코딩 테스트를 풀어 보왔는데요.
LV.1이라서 그런지 문제가 어렵지 않아요!!
하지만 다른 분들의 풀이를 보니
"휠씬 깔끔하게 코딩을 할 수 있었구나"
라고 느껴 LV.2로 바로 가지 않고
차근차근 LV.1부터 끝까지 해보겠습니다.
시간은 나의 편 Maybe

문제 설명

민수는 다양한 지폐를 수집하는 취미를 가지고 있습니다. 지폐마다 크기가 달라 지갑에 넣으려면 여러 번 접어서 넣어야 합니다. 예를 들어 지갑의 크기가 30 * 15이고 지폐의 크기가 26 * 17이라면 한번 반으로 접어 13 * 17 크기로 만든 뒤 90도 돌려서 지갑에 넣을 수 있습니다. 지폐를 접을 때는 다음과 같은 규칙을 지킵니다.

지폐를 접을 때는 항상 길이가 긴 쪽을 반으로 접습니다.
접기 전 길이가 홀수였다면 접은 후 소수점 이하는 버립니다.
접힌 지폐를 그대로 또는 90도 돌려서 지갑에 넣을 수 있다면 그만 접습니다.
지갑의 가로, 세로 크기를 담은 정수 리스트 wallet과 지폐의 가로, 세로 크기를 담은 정수 리스트 bill가 주어질 때, 지갑에 넣기 위해서 지폐를 최소 몇 번 접어야 하는지 return하도록 solution함수를 완성해 주세요.

지폐를 지갑에 넣기 위해 접어야 하는 최소 횟수를 구하는 과정은 다음과 같습니다.

1. 지폐를 접은 횟수를 저장할 정수 변수 answer를 만들고 0을 저장합니다.
2. 반복문을 이용해 bill의 작은 값이 wallet의 작은 값 보다 크거나 bill의 큰 값이 wallet의 큰 값 보다 큰 동안 아래 과정을 반복합니다.
    2-1. bill[0]이 bill[1]보다 크다면
        bill[0]을 2로 나누고 나머지는 버립니다.
    2-2. 그렇지 않다면
        bill[1]을 2로 나누고 나머지는 버립니다.
    2-3. answer을 1 증가시킵니다.
3. answer을 return합니다.
위의 의사코드와 작동방식이 다른 코드를 작성해도 상관없습니다.

제한사항

wallet의 길이 = bill의 길이 = 2
10 ≤ wallet[0], wallet[1] ≤ 100
10 ≤ bill[0], bill[1] ≤ 2,000

문제풀이

    // 지갑 크기 할당
    int wWidth = wallet[0];
    int wHeight = wallet[1];
    
    // 지폐 크기 할당
    int bWidth = bill[0];
    int bHeight = bill[1];

1. 배열로 들어온 값들을 int 형 변수에 담았어요. int형 변수를 사용한 이유는 지문에서 지폐를 접었을 때 소수점이 나오면 소수점을 제거하라고 하였기때문에 소수점을 버리기 위해서 int형을 사용했어요.

// 지폐를 지갑에 넣기 위해 접어야 하는지 확인하는 반복문
    while((bWidth > wWidth || bHeight > wHeight) && (bHeight > wWidth || bWidth > wHeight)) {
   
        // 지폐의 큰 값을 반으로 접음
        if(bWidth > bHeight) {
            bWidth = bWidth / 2;
        } else {
            bHeight = bHeight / 2;  
        }
         answer++;
    }

2. while 안에 조건이 긴 이유는 지폐를 90도로 돌려서 지갑에 넣을 수 있기 때문 경우의 수가 많았어요. 그리고 조건문을 통과하면 지폐의 큰 값을 반으로 접는 행위를 반복하고 몇 번 접었는지만 count하면 코딩 끝!!

느낀점

저는 오늘 반성을 조금 했어요. 다른 분들의 코드를 읽어보니 while문 조건이 길기 때문에 메소드로 따로 빼서 코드의 가독성을 높이고, 변수를 사용할 때 max, min 함수를 사용해서 더욱 간편한 코딩을 하는 모습을 봤어요. 문제가 쉬워서 괜히 풀었나 라는 생각이 사라지고 더욱 정신이 번쩍드는 코딩 테스트 문제었습니다.

전체코드

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> wallet, vector<int> bill) {
    int answer = 0;

    // 지갑 크기 할당
    int wWidth = wallet[0];
    int wHeight = wallet[1];
    
    // 지폐 크기 할당
    int bWidth = bill[0];
    int bHeight = bill[1];

    // 지폐를 지갑에 넣기 위해 접어야 하는지 확인하는 반복문
    while((bWidth > wWidth || bHeight > wHeight) && (bHeight > wWidth || bWidth > wHeight)) {
   
        // 지폐의 큰 값을 반으로 접음
        if(bWidth > bHeight) {
            bWidth = bWidth / 2;
        } else {
            bHeight = bHeight / 2;  
        }
         answer++;
    }
    return answer;
}

프로그래머스

programmers.co.kr

[프로그래머스/코딩 테스트] PCCP 기출문제 1번 / 동영상 재생기(JAVA)

"주인장" — Fri, 20 Sep 2024 21:17:39 +0900

안녕하세요.
동영상 재생기 문제를 자바 언어로 코딩해봤습니다.
긍정 코딩 테스트!!

문제 설명

당신은 동영상 재생기를 만들고 있습니다. 당신의 동영상 재생기는 10초 전으로 이동, 10초 후로 이동, 오프닝 건너뛰기 3가지 기능을 지원합니다. 각 기능이 수행하는 작업은 다음과 같습니다.

10초 전으로 이동: 사용자가 "prev" 명령을 입력할 경우 동영상의 재생 위치를 현재 위치에서 10초 전으로 이동합니다. 현재 위치가 10초 미만인 경우 영상의 처음 위치로 이동합니다. 영상의 처음 위치는 0분 0초입니다.
10초 후로 이동: 사용자가 "next" 명령을 입력할 경우 동영상의 재생 위치를 현재 위치에서 10초 후로 이동합니다. 동영상의 남은 시간이 10초 미만일 경우 영상의 마지막 위치로 이동합니다. 영상의 마지막 위치는 동영상의 길이와 같습니다.
오프닝 건너뛰기: 현재 재생 위치가 오프닝 구간(op_start ≤ 현재 재생 위치 ≤ op_end)인 경우 자동으로 오프닝이 끝나는 위치로 이동합니다.

동영상의 길이를 나타내는 문자열 video_len, 기능이 수행되기 직전의 재생위치를 나타내는 문자열 pos, 오프닝 시작 시각을 나타내는 문자열 op_start, 오프닝이 끝나는 시각을 나타내는 문자열 op_end, 사용자의 입력을 나타내는 1차원 문자열 배열 commands가 매개변수로 주어집니다. 이때 사용자의 입력이 모두 끝난 후 동영상의 위치를 "mm:ss" 형식으로 return 하도록 solution 함수를 완성해 주세요.

제한사항

video_len의 길이 = pos의 길이 = op_start의 길이 = op_end의 길이 = 5
video_len, pos, op_start, op_end는 "mm:ss" 형식으로 mm분 ss초를 나타냅니다.
0 ≤ mm ≤ 59
0 ≤ ss ≤ 59
분, 초가 한 자리일 경우 0을 붙여 두 자리로 나타냅니다.
비디오의 현재 위치 혹은 오프닝이 끝나는 시각이 동영상의 범위 밖인 경우는 주어지지 않습니다.
오프닝이 시작하는 시각은 항상 오프닝이 끝나는 시각보다 전입니다.
1 ≤ commands의 길이 ≤ 100
commands의 원소는 "prev" 혹은 "next"입니다.
"prev"는 10초 전으로 이동하는 명령입니다.
"next"는 10초 후로 이동하는 명령입니다.

문제풀이

    // 문자열 형식을 숫자로 변환
    private int intTime(String pos) {
        String[] parts = pos.split(":");
        int minutes = Integer.parseInt(parts[0]);
        int seconds = Integer.parseInt(parts[1]);
        return minutes * 60 + seconds;
    }
    
    // 숫자를 문자열 형식에 맞춰 변환
    private String stringTime(int intTime) {
        int minutes = intTime / 60;
        int seconds = intTime % 60;
        return String.format("%02d:%02d", minutes, seconds);
    }

기능이 수행되기 직전의 재생위치를 나타내는 pos가 String이라서 연산을 위해 int로 변형합니다.
그 전에 "mm:ss" 형식으로 값이 들어오기 때문에 split 함수를 사용하여 형식을 연산이 쉬운 형태로 변경합니다.
문자열 → 숫자, 숫자 → 문자로 형변환 하는 부분이 많아서 따로 메서드로 작성하였습니다.

    public String solution(String video_len, String pos, String op_start, String op_end, String[] commands) {
        int videoLenSec = intTime(video_len);
        int currentPosSec = intTime(pos);
        int opStartSec = intTime(op_start);
        int opEndSec = intTime(op_end);
        
        // pos 시간을 체크하여 오프닝 종료시간으로 자동 이동
        if (currentPosSec >= opStartSec && currentPosSec <= opEndSec) {
           currentPosSec = opEndSec;
        }
        
        // commands배열을 문자열로 변환하여 값에 따라 prev, next 기능 동작
        for (String command : commands) {
            if (command.equals("prev")) {
                currentPosSec = currentPosSec - 10; 
            } else if (command.equals("next")) {
                currentPosSec = currentPosSec + 10;  
            }
            
            // 현재 위치가 음수면 0으로 설정
            if (currentPosSec < 0) {
                currentPosSec = 0;
            }
            
            // 동영상 길이 보다 현재 시간이 길면 동영상 길이로 설정
            if (currentPosSec > videoLenSec) {
                currentPosSec = videoLenSec;
            }
            
            // pos 시간을 체크하여 오프닝 종료시간으로 자동 이동
            if (currentPosSec >= opStartSec && currentPosSec <= opEndSec) {
                currentPosSec = opEndSec;
            }
            

        }
        
        return stringTime(currentPosSec);
    }

현재 시간(pos)이 String으로 나오기 때문에 int로 형변환하는 intTime 메소드를 사용한다.
현재 시간(pos)를 확인하여 오프닝 시간이면 오프닝 종료시간으로 시간을 변경한다.
commands 배열을 문자열로 변환하여 값에 따라 prev, next 기능이 작동하도록 한다.
만약 기능이 다 동작 중 현재 위치가 음수가 나왔을 경우에는 0으로 초기화시키고 동영상 보다 현재 시간이 길 경우에는 영상 길이로 초기화한다. (이 부분을 생각하지 못해서 고민을 조금했어요.)
다시 한번 현재 시간을 확인하여 오프닝 시간이면 오프닝 종료시간으로 시간을 변경한다.
int를 String으로 형변환 하는 stringTime 메소드를 사용하여 return한다.

전체 코드

class Solution {
    // 문자열 형식을 숫자로 변환
    private int intTime(String pos) {
        String[] parts = pos.split(":");
        int minutes = Integer.parseInt(parts[0]);
        int seconds = Integer.parseInt(parts[1]);
        return minutes * 60 + seconds;
    }
    
    // 숫자를 문자열 형식에 맞춰 변환
    private String stringTime(int intTime) {
        int minutes = intTime / 60;
        int seconds = intTime % 60;
        return String.format("%02d:%02d", minutes, seconds);
    }

    public String solution(String video_len, String pos, String op_start, String op_end, String[] commands) {
        int videoLenSec = intTime(video_len);
        int currentPosSec = intTime(pos);
        int opStartSec = intTime(op_start);
        int opEndSec = intTime(op_end);
        
        // pos 시간을 체크하여 오프닝 종료시간으로 자동 이동
        if (currentPosSec >= opStartSec && currentPosSec <= opEndSec) {
           currentPosSec = opEndSec;
        }
        
        // commands배열을 문자열로 변환하여 값에 따라 prev, next 기능 동작
        for (String command : commands) {
            if (command.equals("prev")) {
                currentPosSec = currentPosSec - 10; 
            } else if (command.equals("next")) {
                currentPosSec = currentPosSec + 10;  
            }
            
            // 현재 위치가 음수면 0으로 설정
            if (currentPosSec < 0) {
                currentPosSec = 0;
            }
            
            // 동영상 길이 보다 현재 시간이 길면 동영상 길이로 설정
            if (currentPosSec > videoLenSec) {
                currentPosSec = videoLenSec;
            }
            
            // pos 시간을 체크하여 오프닝 종료시간으로 자동 이동
            if (currentPosSec >= opStartSec && currentPosSec <= opEndSec) {
                currentPosSec = opEndSec;
            }
            

        }
        
        return stringTime(currentPosSec);
    }
    

}

프로그래머스

programmers.co.kr

도커(Docker)

"주인장" — Tue, 16 Jul 2024 16:52:59 +0900

프로젝트 개발을 완료한 후 도커 서버에 프로젝트를 배포했을 때, 개발 서버에서는 잘 동작하던 코드가 도커 서버에서는 인식되지 않아 도커 서버에 맞춰 다시 코딩해야 했던 경험이 있다. 당시 신입 3개월 차였던 저는 그 이유를 몰랐지만, 시간이 지나면서 이유를 알게 됐다. 이유는 운영 환경이 달랐기 때문이다!!!

도커(Docker)란?

도커는 애플리케이션을 컨테이너라는 경량화되고 이식 가능한 환경에 패키징하여 개발, 배포, 실행할 수 있게 해주는 플랫폼이다. 이를 통해 애플리케이션을 일관된 환경에서 실행할 수 있다.

1. 도커의 주요 특징

컨테이너화(Containerization: 컨테이너는 애플리케이션과 그 종속성을 하나의 패키지로 묶어 독립된 실행 환경을 제공한다. 가상머신과 달리 호스트 OS 커널을 공유하면서도 격리된 환경을 제공하여, 일관된 실행을 보장한다. 이로 인해 개발, 테스트, 운영 환경에서 동일하게 동작한다.

이식성(Portability): 도커 이미지를 사용하면 로컬 개발 환경, 테스트 서버, 클라우드 등 어디서나 동일하게 실행할 수 있습니다. 이는 환경 간 차이로 인한 문제를 최소화합니다.

경량성(Lightweight): 컨테이너는 호스트 os를 공유하여 가상머신보다 가볍고 빠르게 실행됩니다. 시스템 자원을 효율적으로 사용하며, 빠른 시작 시간과 높은 성능을 제공합니다.

2. 장점

일관성: 애플리케이션이 어디서나 동일하게 동작하여 개발과 운영 환경 간의 불일치 문제를 해결한다.
효율성: 컨테이너는 가상머신보다 가볍고 빠르며, 시스템 자원을 효율적으로 사용한다.
확장성: 필요에 따라 컨테이너를 손쉽게 추가하거나 제거할 수 있어, 애플리케이션의 확장과 축소가 용이하다.

3. 단점

복잡성: 초기 설정과 학습에 시간이 필요하며, 특히 복장한 오케스트레이션 도구를 사용할 때 더 많은 학습이 요구 될 수 있다.

보안 문제: 호스트 os를 고유하므로 보안 격리가 가상머신만큼 강력하지 않을 수 있다. 컨테이너 간 보안 격리에 주의가 필요하다.

웹 소켓(WebSocket)

"주인장" — Fri, 12 Jul 2024 14:38:31 +0900

1. 웹소켓이란?

웹 소켓(WebSocket)은 웹 애플리케이션과 서버 사이의 실시간 양방향 통신을 가능케하는 프로토콜이다.

웹소켓을 이용하면 클라이언트와 서버가 지속적으로 연결된 상태에서 데이터를 주고 받을 수 있어, 채팅 앱, 실시간 게임, 주식 거래 시스템 등 즉각적인 데이터 전송이 필요한 애플이케이션에 유용하다.

2. 웹소켓의 특징

양방향 통신: 클라이언트와 서버가 동시에 데이터를 주고 받을 수 있다.
지속적인 연결: 한 번 연결이 수립되면 여러 차례 데이터를 주고 받을 수 있어 HTTP보다 효율적이다.
낮은 지연시간: 연결이 유지되는 동안 데이터 전송이 빠르고 실시간성이 뛰어나다.

3. 웹소켓의 문제점

복잡성 증가: 웹소켓을 구현하고 관리하는 것은 HTTP보다 더 복잡할 수 있다.
보안 문제: 지속적인 연결을 유지하므로, 보안에 더 주의를 기울여야합니다. DDoS 공격에 취약할 수 있습니다.
브라우저 호환성: 일부 구형 브라우저에서는 웹소켓 지원이 제한적일 수 있다.
서버 리소스: 많은 동시 연결을 유지해야 할 경우 서버 리소스 관리에 주의가 필요하다.

5. 웹소켓의 동작 방법

핸드셰이크: 클라이언트가 HTTP 요청을 통해 웹소켓 연결을 시도한다.
연결 수립: 서버가 요청을 수락하면, HTTP연걸이 웹소켓 연결로 업그레이드된다.
데이터 전송: 양방향 통신이 시작되어 클라이언트와 서버가 실시간으로 데이터를 주고받는다.
연결 종료: 클라이언트나 서버 중 어느 쪽에서든 연결을 종료할 수 있다.

4. 웹소켓API

JavaScript에서는 WebSocket API를 통해 쉽게 웹소켓을 구현할 수 있다.

// 웹소켓 연결 생성
const socket = new WebSocket('ws://example.com/socket');

// 연결이 수립되었을 때 호출되는 이벤트 핸들러
socket.onopen = function(event) {
    console.log('서버 연결!');
};

// 서버로부터 메시지를 받았을 때 호출되는 이벤트 핸들러
socket.onmessage = function(event) {
    console.log('서버 메시지: ', event.data);
};

// 연결이 종료되었을 때 호출되는 이벤트 핸들러
socket.onclose = function(event) {
    console.log('서버 해제!');
};

// 에러가 발생했을 때 호출되는 이벤트 핸들러
socket.onerror = function(event) {
    console.error('웹소켓 에러: ', event);
};

6. 결론

웹소켓은 기본 HTTP 요청 - 응답 방식의 한계를 뛰어넘어, 실시간 양방향 통신이 필요한 다양한 애플리케이션에서 필수적인 기술로 자리 잡았다. 웹소켓을 통해 실시간 채팅, 실시간 게임, 실시간 데이터 스트리밍 등의 애플리케이션을 보다 효과적으로 구현할 수 있게 되었다. 웹 소켓은 현대 웹 개발에서 매우 중요한 역할을 하고 있으며, 실시간 데이터 전송이 요구되는 다양한 분야에서 그 중요성이 커지고 있다.

김영한의 실전 자바 - 중급 1편 후기

"주인장" — Sun, 7 Jul 2024 18:46:04 +0900

하하하

안녕하세요!
벌써 자바 - 중급 1편 후기를 작성하게 되었네요.

중급 1편 - 섹션

1. Object 클래스

2. 불변 객체

3. String 클래스

4. 래퍼, Class 클래스

5. 열거형 - ENUM

6. 날짜와 시간

7. 중첩 클래스, 내부 클래스1

8. 중첩 클래스, 내부 클래스2

9. 예외 처리1 - 이론

10. 예외 처리2 - 실습

느낀점

중급 편 강의는 코드가 과거부터 지금까지 어떻게 발전해 왔는지에 초점을 맞춘 것 같았습니다.
현재 코드가 이렇게 사용되는 이유를 이해할 수 있어 매우 좋았으며,
무작정 암기보다는 이해를 통한 암기라는 느낌이 들었습니다.

하지만 제가 복습이 부족해서 기본 편보다 한 번에 이해되는 부분이 적었습니다. 복습은 필수입니다!!!
변명 아닌 변명을 하자면, 직장, 대학 편입, 프로젝트를 진행하면서 인강을 듣다 보니, 다시 들을 때 앞의 내용이 기억나지 않았습니다. 확실히 중급 편이라는 생각이 듭니다. 강의를 다시 듣기보다는 강의에서 제공하는 자료를 통해 복습을 진행할 예정입니다.

자바 중급 - 2편이 굉장히 기대됩니다.

늘 궁금했던 제네릭과 자바 컬렉션에 대해서 배울 수 있기 때문입니다.
자바 고급 편은 다음에 기회가 된다면 들을 생각입니다. 스프링 프레임워크와 JPA에 대해서 공부하고 싶기 때문이며,

진도를 나가는 것보다는 내가 충분히 이해하는 것이 중요하다고 생각하기에 중급 1,2편을 더 복습할 생각입니다.

김영한의 실전 자바 - 중급 1편 강의 | 김영한 - 인프런

김영한 | 실무에 필요한 자바의 다양한 중급 기능을 예제 코드로 깊이있게 학습합니다., 국내 개발 분야 누적 수강생 1위, 제대로 만든 김영한의 실전 자바[사진][임베딩 영상]단순히 자바 문법을

www.inflearn.com

[JAVA] 자바 컬렉션 프레임워크 'List', 'Set', 'Map'

"주인장" — Sun, 30 Jun 2024 18:44:41 +0900

안녕하세요!
코딩테스트를 준비 중에 자바 컬렉션 프레임워크를 활용한 문제가 많이 보였습니다.
그래서 꼭 한번 정리가 필요하다고 생각하여 이렇게 글을 작성합니다.

1. List 인터페이스

'List' 인터페이스는 순서가 있는 요소의 컬렉션을 나타내며, 중복을 허용합니다.

주요 구현 클래스로는 'ArrayList ', 'LinkedList' 등이 있습니다.

특징

순서 O: 'List'는 요소들이 삽입된 순서를 유지합니다.
중복 O: 동일한 요소를 여러 번 추가할 수 있습니다.
인덱스 접근: 요소에 인덱스로 접근할 수 있습니다.

ArrayList

동적 배열을 사용하여 요소를 관리합니다.
요소의 삽입과 삭제가 배열 크기를 변경하는 경우 성능이 떨어질 수 있습니다.
배열 기반 자료구조로, 인덱스를 사용한 임의 접근이 빠릅니다.

LinkedList

이중 연결 리스트를 사용하여 요소를 관리합니다.
각 요소가 이전 요소와 다음 요소를 직접 가리키는 링크를 가지고 있어, 요소의 삽입과 삭제가 빠릅니다.
연결 리스트 기반 자료구조로, 특정 인덱스에 접근하려면 처음부터 해당 인덱스까지 순차적으로 노드를 탐색해야 하기 때문에 접근 속도가 느릴 수 있습니다.

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // ArrayList 예제
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");
        System.out.println("ArrayList: " + arrayList);

        // LinkedList 예제
        List<String> linkedList = new LinkedList<>();
        linkedList.add("Dog");
        linkedList.add("Elephant");
        linkedList.add("Fox");
        System.out.println("LinkedList: " + linkedList);
    }
}

2. Map 인터페이스

'Map' 인터페이스는 키-값 쌍을 저장하는 자료구조를 나타냅니다. 키는 중복을 허용하지 않으며, 각 키는 하나의 값과 매핑됩니다. 주요 구현 클래스로는 'HashMap', 'TreeMap' 등이 있습니다.

특징

순서 X: 'Map'은 기본적으로 요소들의 순서를 보장하지 않습니다. (예외: TreeMap, LinkedHashMap)
키 중복 X: 각 키는 유일해야 하며, 동일한 키를 여러 번 추가할 수 없습니다.
값 중복 O: 동일한 값을 여러 번 추가할 수 있습니다..

HashMap

해시 테이블을 이용하여 키-값 쌍을 저장합니다.
해시 테이블을 사용하여 키의 해시 코드를 계산하고 이를 기반으로 데이터에 접근하기 때문에 키와 값의 삽입, 삭제, 검색이 빠릅니다.
키의 순서를 유지하지 않습니다.

TreeMap

이진 트리를 이용하여 키-값 쌍을 저장합니다.
이진 트리의 균형을 유지하기 위한 추가적인 관리 작업이 필요하기 때문에 삽입, 삭제, 검색이 비교적 느립니다.
키에 따라 자동으로 정렬됩니다.

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapExample {
    public static void main(String[] args) {
        // HashMap 예제
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Apple", 1);
        hashMap.put("Banana", 2);
        hashMap.put("Cherry", 3);
        System.out.println("HashMap: " + hashMap);
        System.out.println("HashMap get('Banana'): " + hashMap.get("Banana"));

        // TreeMap 예제
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Dog", 4);
        treeMap.put("Elephant", 5);
        treeMap.put("Fox", 6);
        System.out.println("TreeMap: " + treeMap);
        System.out.println("TreeMap get('Elephant'): " + treeMap.get("Elephant"));
    }
}

3. Set 인터페이스

'Set' 인터페이스는 중복을 허용하지 않는 요소의 집합을 나타냅니다. 주요 구현 클래스로는 'HashSet', 'TreeSet' 등이 있습니다.

특징

순서 X: 'Set'은 요소들의 순서를 보장하지 않습니다 (예외: 'TreeSet', 'LinkedHashSet')

중복 X: 동일한 요소를 여러 번 추가할 수 없습니다.

HashSet

해시 테이블을 이용하여 요소를 저장합니다.
해시 테이블을 사용하여 키의 해시 코드를 계산하고 이를 기반으로 데이터에 접근하기 때문에 요소의 삽입, 삭제, 검색이 빠릅니다.
요소의 순서를 유지하지 않습니다.

TreeSet

이진 트리를 이용하여 요소를 저장합니다.
이진 트리의 균형을 유지하기 위한 추가적인 관리 작업이 필요하기 때문에 삽입, 삭제, 검색이 비교적 느립니다.
요소를 정렬된 상태로 유지하기 위해 추가적인 관리 작업이 필요하기 때문에 요소가 순서를 유지합니다

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        // HashSet 예제
        Set<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");
        hashSet.add("Apple"); // 중복된 요소 추가 시도
        System.out.println("HashSet: " + hashSet);

        // TreeSet 예제
        Set<String> treeSet = new TreeSet<>();
        treeSet.add("Dog");
        treeSet.add("Elephant");
        treeSet.add("Fox");
        System.out.println("TreeSet: " + treeSet);
    }
}

4. 정리

List: 순서가 있는 요소의 컬렉션으로, 중복을 허용하여 인덱스로 접근할 수 있습니다.

Map: 중복을 허용하지 않는 요소의 집합으로, 기본적으로 순서를 유지하지 않습니다.

Set: 중복을 허용하지 않는 요소의 집합으로, 기본적으로 순서를 유지하지 않습니다.

[프로그래머스] 가장 많이 받은 선물(JAVA)

"주인장" — Sat, 22 Jun 2024 14:00:08 +0900

안녕하세요.
알고리즘을 공부하면서 스스로 해결하지 못한 문제들을 정리하려고 합니다.
언어는 JAVA를 사용했습니다.

1. 문제

선물을 직접 전하기 힘들 때 카카오톡 선물하기 기능을 이용해 축하 선물을 보낼 수 있습니다.

당신의 친구들이 이번 달까지 선물을 주고받은 기록을 바탕으로 다음 달에 누가 선물을 많이 받을지 예측하려고 합니다.

두 사람이 선물을 주고받은 기록이 있다면, 이번 달까지 두 사람 사이에 더 많은 선물을 준 사람이 다음 달에 선물을 하나 받습니다.
예를 들어 A가 B에게 선물을 5번 줬고, B가 A에게 선물을 3번 줬다면 다음 달엔 A가 B에게 선물을 하나 받습니다.
두 사람이 선물을 주고받은 기록이 하나도 없거나 주고받은 수가 같다면, 선물 지수가 더 큰 사람이 선물 지수가 더 작은 사람에게 선물을 하나 받습니다.
선물 지수는 이번 달까지 자신이 친구들에게 준 선물의 수에서 받은 선물의 수를 뺀 값입니다.
예를 들어 A가 친구들에게 준 선물이 3개고 받은 선물이 10개라면 A의 선물 지수는 -7입니다. B가 친구들에게 준 선물이 3개고 받은 선물이 2개라면 B의 선물 지수는 1입니다. 만약 A와 B가 선물을 주고받은 적이 없거나 정확히 같은 수로 선물을 주고받았다면, 다음 달엔 B가 A에게 선물을 하나 받습니다.
만약 두 사람의 선물 지수도 같다면 다음 달에 선물을 주고받지 않습니다.
위에서 설명한 규칙대로 다음 달에 선물을 주고받을 때, 당신은 선물을 가장 많이 받을 친구가 받을 선물의 수를 알고 싶습니다.

2. 문제 해결 과정에서 발생한 어려움 및 극복한 경험

문제를 읽고 변수를 어떤 기준으로 생성해야 할지 의문이 들었습니다. 코드에 절대적인 정답은 없지만, 더 나은 방법이 있을까 고민하게 되었습니다. 이로 인해 코드 작성에 조심스러워졌습니다. 일단 코드를 완성한 후에 클린 코드를 고려하는 방식이 더 도움이 될 것 같아 다음부터는 먼저 코드를 완성한 후에 클린 코드를 생각하는 습관을 기르고자 합니다.

3. 코드

import java.util.HashMap;
import java.util.Map;

class Solution {
    public int solution(String[] friends, String[] gifts) {
        // 친구의 수를 n에 저장
        int n = friends.length;
        
        // 친구의 이름을 키, 인덱스 값으로 하는 맵 생성
        Map<String, Integer> friendIndex = new HashMap<>();
        
        // 친구 배열을 순회하면서 이름과 인덱스를 맵에 저장
        for (int i = 0; i < n; i++) {
            friendIndex.put(friends[i], i);
        }
        
        // 각 친구가 다른 친구에게 준 선물의 수를 저장할 2차원 배열
        int[][] giftTotal = new int[n][n];
        
        // 각 친구가 준 선물의 총 수(+)와 받은 선물의 총 수(-)를 저장할 배열
        int[] giftRate = new int[n];
        
        // 다음달 받을 선물 수
        int[] giftPref = new int[n];
        
        // 선물 배열을 순회하며 선물 정보를 처리
        for(String gift : gifts) {
        	// 선물 정보를 공백으로 분리
            String[] giftSplit = gift.split(" "); 
            
            // 선물 주는 사람의 인덱스를 얻음
            int giver = friendIndex.get(giftSplit[0]);
            
            // 선물 받는 사람의 인덱스를 얻음
            int receiver = friendIndex.get(giftSplit[1]); 
            
            // 선물 주는 사람과 받는 사람의 관계를 2차원 배열에 기록
            giftTotal[giver][receiver]++;
            
            // 선물 주는 사람의 선물 수 증가
            giftRate[giver]++;
            
            // 선물 받는 사람의 선물 수 감소
            giftRate[receiver]--;
        }
        
        // 각 친구를 비교하여 선호도를 계산
        for (int i = 0; i < n; i++) {  
            for (int j = i + 1; j < n; j++) {
                    if (giftTotal[i][j] > giftTotal[j][i]) {
                    	// i가 j보다 더 많이 선물하면 i의 선물 수 증가
                        giftPref[i]++;
                    } else if (giftTotal[i][j] < giftTotal[j][i]) {
                    	// j가 i보다 더 많이 선물하면 j의 선물 수 증가
                        giftPref[j]++;
                    } else if(giftRate[i] > giftRate[j]) {
                        // 선물의 총 수가 같다면, 더 많이 선물한 i의 선물 수 증가	
                            giftPref[i]++;
                    } else if (giftRate[i] < giftRate[j]) {
                    	// 선물의 총 수가 같다면, 더 많이 선물한 j의 선물 수 증가
                            giftPref[j]++;
                    }
            }
        }
        
        // 최대 선물 수
        int answer = 0;
        for (int i = 0; i < n; i++) {
            answer = Math.max(answer, giftPref[i]);
        }
        return answer;
    }
}

HTML, CSS, JavaScript 로딩되는 순서

"주인장" — Thu, 2 May 2024 14:30:16 +0900

안녕하세요!
오늘은 HTML, JS, CSS가 로딩되는 순서에 대해 알아 볼려고 합니다.
웹 페이지가 어떻게 렌더링되고 사용자에게 표시되는지를 결정하는 중요한 요소입니다.

1. HTML 로드 및 파싱

브라우저는 HTML 문서를 위에서 아래로 순차적으로 로드하고 파싱합니다.
HTML 요소들이 파싱됨에 따라 DOM(Document Oject Model)을 구축합니다.

2. CSS 로드 및 파싱

HTML 문서에서 '<link>' 태그를 통해 참조된 CSS 파일들은 비동기적으로 로드됩니다.
CSS 파일이 로드되고 파싱되면, 브라우저는 CSSOM(CSS Object Model)을 구축합니다.
CSSOM이 준비되기 전까지는 페이지의 스타일이 적용되지 않으므로, CSS 파일이 로드될 때까지 페이지 렌더링이 일시 중단될 수 있습니다.

3. CSS 적용

DOM과 CSSOM이 모두 준비되면, 브라우저는 이를 결합하여 렌더 트리를 생성합니다.
이 렌더 트리를 기반으로 페이지가 스타일링되어 화면에 렌더링 됩니다.

4. JS 로드 및 실행

HTML 문서에서 '<script>' 태그를 만나면, 브라우저는 해당 JavaScipt 파일을 로드합니다.
기본적으로'<script>' 태그는 HTML 파싱을 중단시키고, JavaScript 파일을 동기적으로 로드 및 실행합니다.
'<script>' 태그에 'async' 속성을 추가하면, JavaScript 파일이 비동기적으로 로드되며, 로드가 완료되는 즉시 실행됩니다.
'<script>' 태그에 'defer' 속성을 추가하면, HTML 파싱 후에 실행되도록 합니다.

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>

        <!-- CSS 로드 -->
        <link rel="stylesheet" href="styles.css">

        <!-- 비동기 JavaScript 로드 -->
        <script src="script.js" async></script>

        <!-- 지연 JavaScript 로드 -->
        <script src="deferred-script.js" defer></script>
    </head>
    <body>
        <h1>뚝딱뚝딱 개발소</h1>

        <!-- 동기 JavaScript 로드 -->
        <script src="sync-script.js"></script>
    </body>
</html>

정리

1. HTML: HTML이 로드되고 파싱되면서 DOM이 구성됩니다.

2. CSS: CSS 파일들이 로드되고 파싱되어 CSSOM이 구축됩니다.

3.JavaScript: '<script>' 태그의 위치와 속성에 따라 JavaSscript 파일이 로드되고 실행됩니다.

3-1. 기본적으로 HTML 파싱을 중단시키고 동기적으로 실행됩니다.

3-2. defer 속성은 HTML 파싱 후에 실행되도록 합니다.

3-3. async 속성은 비동기적으로 로드되고 즉시 실행됩니다.

스프링 핵심 원리 - 기본편 후기

"주인장" — Thu, 4 Apr 2024 20:11:02 +0900

안녕하세요.

스프링 핵심 원리 - 기본편 인강 후기를 가지고 왔습니다.

한줄평

강의 전반적으로 실전 기반이지만

과거부터 지금까지 코드가 어떻게 변화하였는지

설명을 해주는 부분도 있어서 좋았습니다.

느낀점

처음에 스프링으로 바로 강의를 시작하지 않고

먼저 자바만 사용하여 간단하게

회원 → 주문 → 할인

코드를 작성하여 빌드업했습니다.

자바만 사용한 코드를 스프링 방식으로

조금씩 수정해 나가는 수업 방식입니다.

스프링 방식으로 수정해 나가다 보면 코드양도 줄어들면서

스프링이 편리하다는 것을 느낄 수 있습니다.

하지만 편리한 만큼 스프링이 제공하는 코드를 알기 위해

공부해야 한다고 느꼈습니다.

퇴근 후 지옥철을 겪고 저녁밥 후에 오는 식곤증으로

강의를 매일 들을 수는 없다 보니 앞에 내용을 부분적으로

기억이 나지 않는 경우도 있지만

강의에서 제공해 주는 자료를 통해 극복할 수 있는 부분도 있습니다.

다른 직장인분들도 앞에 내용이 기억나지 않는다면

자료를 통해 복습하면 좋을 것 같습니다.

스프링 핵심 원리 - 기본편 강의 | 김영한 - 인프런

김영한 | 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다., 스프링 핵심 원리를 이해하고, 성장하는 백엔드 개발자가 되어보

www.inflearn.com

코딩 테스트를 위한 자료구조

"주인장" — Fri, 15 Mar 2024 21:50:09 +0900

자료구조를 설명하기 전에
코딩 테스트 준비를 하려는 가장 큰 이유는
뛰어난 사람과 같이 일하고 싶기 때문이다.

그래서 코딩 테스트를 잘 하기 위한 공부인 자료구조에 대해 설명하겠습니다.

자료구조

데이터를 효율적으로 구성하고 저장하는 방법을 제공합니다.

이러한 자료구조는 다양한 형태과 기능을 가지고 있습니다.

가장 일반적으로 사용자는 자료구조의 종류에 대해서 설명하겠습니다.

1. 배열(Array)

배열은 동일한 자료형의 데이터를 순차적으로 저장하는 선형 자료구조입니다.

메모리 상에 연속적인 공간을 할당하고 각 요소에 인덱스를 통해 접근할 수 있습니다.

배열의 장점은 인덱스를 이용하여 빠르게 요소에 접근할 수 있다는 것이며,

단점은 크기가 고정되어 있어 삽입/삭제 연산이 비효율적일 수 있다는 것입니다.

2. 연결 리스트(Linked List)

연결 리스트는 데이터 요소가 노드로 구성되며, 각 노드는 데이터와 다음 노드를 가리키는 포인터로 구성됩니다.

연결 리스트는 메모리 상에 불연속적으로 위치할 수 있으며, 삽입/삭제 연산이 배열보다 유연하고 빠릅니다.

3. 스택(Stack)

후입선출(LIFO, Lat-In-First-Out)의 원리에 따라 데이터를 저장하는 자료구조입니다.

데이터는 스택의 맨위에 추가되거나 삭제됩니다.

주요연산은 push(삽입)와 pop(삭제)입니다.

4. 큐(Queue)

선입선출(LIFO, Last-In-First-Out)의 원리에 따라 데이터를 저장하는 자료구조입니다.

데이터는 한쪽 끝에서 추가되고 다른 한쪽 끝에서 제거됩니다.

주요 연산은 enqueue(삽입)과 dequeue(삭제)입니다.

5. 트리(Tree)

계층적인 구조를 갖는 비선형 자료구조입니다.

부모-자식 관계로 이루어진 노드를의 집합입니다.

이진트리(Binary Tree), 이진 탐색 트리(Binary Search Tree), AVL트리 등 다양한 종류가 있습니다.

6. 그래프(Graph)

그래프는 노드와 노드를 연결하는 간선들의 집합입니다.

방향성에 따라 유향 그래프와 무향 그래프로 나뉘며, 간선에 가중치가 있는 경우도 있습니다.

네트워크 모델이나 많은 문제를 그래프로 표현할 수 있습니다.

7. 해시 테이블(Hash Table)

해시 테이블은 키-값(key-value)쌍을 저장하는 자료구조로,

해시 함수를 사용하여 키를 값에 매핑합니다.

해시 충돌을 처리하기 위한 다양한 방법이 있으며,

상수 시간에 데이터를 검색, 삽입, 삭제할 수 있는 효율성을 가지고 있습니다.

8. 힙(Heap)

힙은 최댓값 또는 최솟값을 빠르게 찾아내기 위해 설계된 완전 이진트리입니다.

주로 우선순위 큐를 구현하는 데 사용됩니다.

최대 힙과 최소 힙이 있으며,

힙 조건을 유지하기 위해 힙의 구조를 유지하는 연산이 필요합니다.

그 외에도 많은 자료 구조들이 존재합니다.

이들은 특정한 문제를 해결하기 위해 설계되었거나

특정한 상황에서 효율적인 작업을 수해아기 위해 사용됩니다.

김영한의 실전 자바 - 기본편 후기

"주인장" — Tue, 30 Jan 2024 15:30:49 +0900

안녕하세요

새해 인사드린지 엊그제 같은데 벌써 1월 말이네요.
그 사이에 저는 김영한의 실전 자바 - 기본편을 수강완료했어요.

후기

강의 시간은 약17 시간이었지만 역시 강사님이 IT 쪽에 오랫동안 있으셔서 그런지 타자 속도도 빠르고 단축키도 아시는 게 많아 정지 재생 반복을 하느라 시간이 더 걸려 약 20시간 정도 강의를 들었어요. 하지만 같이 타이핑하면서 단축키를 많이 배우게 됐어요. 강사님은 Mac을 사용하시지만, 저는 Windows를 사용하고 있어서 단축키가 다르긴 했지만 큰 어려움 없이 강의를 따라갈 수 있었어요. (Window는 자막(?)으로 볼 수 있었습니다.)

자바 수업을 듣고 다시 들으니 국비 때 수업을 들었던 내용이 뜨문뜨문 기억이 나고 다시 한번 기초를 다질 수 있어서 좋았어요. 그리고 인강을 듣고 자료를 통해 또다시 복습하고 하니 스스로 성장하는 느낌이 들었습니다.

하지만 여기서 만족하지 않고 더 성장해서 후기 남기겠습니다.!!!!

김영한의 실전 자바 - 중급 1편

하하하안녕하세요!벌써 자바 - 중급 1편 후기를 작성하게 되었네요. 중급 1편 - 섹션1. Object 클래스2. 불변 객체3. String 클래스4. 래퍼, Class 클래스5. 열거형 - ENUM6. 날짜와 시간7. 중첩 클래스, 내부

king-developer.tistory.com

김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 후기

"주인장" — Tue, 2 Jan 2024 17:58:08 +0900

안녕하세요!
2024년 새해가 밝았네요. 새해 복 많이 받으세요.

국비학원에서 6개월동안 급하게 배우고 취업을 하다보니
제가 기초가 제대로 잡혀있는 것인지 의문이 들기 시작하였고
그 의문을 풀기 위해 자바 입문 강의를 시작하게 되었습니다.

김영한의 자바 입문 강의를 시작한 이유

김영한 강사님에게는 백엔드 로드맵이 있다는 점입니다.
물론, 나만의 로드맵을 만들 수는 있겠지만
'내가 만든 로드맵이 제대로 만들었는가?'
라는 의구심이 자기 자신을 불안하게 만들 것 같아서
제가 만든 로드맵보다는 IT에서 오랫동안 경력을 쌓았던 분의 로드맵을

따라가는 것이 적절하다고 판단했습니다.

기본편부터 시작하지 않고 입문편부터 시작한 이유

가장 큰 이유는 강사님들이 같은 IT 용어를 사용하더라도

의미를 조금씩 다르게 사용하실 수 있어서

강의를 듣는 동안 혼란이 생길 것 같아

처음부터 시작하게 되었습니다.

그리고 유명한 강사님이지만 제게 적합한지 확인이 필요했습니다.

후기

처음 자바를 시작하는 분이라면 이 강의를 추천합니다.

왜냐하면 개발 환경 설정까지 친절하게 설명해 주고

강의 구조가 학습 → 예제 → 문제와 풀기 → 정리 순으로 되어있어

기초부터 응용까지 한번에 가능하고

강의가 평균적으로 20분으로 강의시간이 길지 않아서

직장인이라도 평일에 1~2강씩 시청을 할 수 있습니다.

이론 중심보다는 실전 위주로 수업을 나가기 때문에

같이 코딩을 따라 칠 수 있습니다.

입문편은 무료( 2024.01.03 기준)이기 때문에

코딩이 자기와 적성이 맞는지 확인하는데 용이할 것 같습니다.

김영한의 실전 자바 - 기본편

안녕하세요 새해 인사드린지 엊그제 같은데 벌써 1월 말이네요. 그 사이에 저는 김영한의 실전 자바 - 기본편을 수강완료했어요. 후기 강의 시간은 약17 시간이었지만 역시 강사님이 IT 쪽에 오랫

king-developer.tistory.com

Amazon EC2와 Amazon RDS 공통점·차이점

"주인장" — Fri, 3 Nov 2023 15:19:43 +0900

공통점

1. Amazon EC2와 Amazon RDS 모두 Amazon Web Service(AWS)의 일부로 제공됩니다. 클라우드 컴퓨팅 및 데이터베이스 관리를 위한 서비스로서 AWS의 기능과 이점을 사용할 수 있습니다.

2. 두 서비스는 필요에 따라 확장 가능하며, 사용자는 자원의 크기를 조정하거나 인스턴스를 추가하여 애플리케이션 또는 데이터베이스 성능을 향상시킬 수 이습니다.

3. AWS는 보안,로깅 및 관리 기능을 제공하여 사용자가 애플리케이션 및 데이터베이스를 안전하게 유지하고 관리할 수 있습니다.

차이점

1. Amazon EC2는 가상 서버를 호스팅하기 위한 서비스로, 다양한 용도로 사용할 수 있지만 Amazon RDS는 관계형 데이터베이스를 호스팅하고 관리하기 위한 서비스입니다.

2. Amazon EC2는 사용자가 가상 서버의 운영체제, 애플리케이션 소프트웨어 및 보안 업데이트를 관리해야 하지만 Amazon RDS는 데이터 베이스 관리를 간소화하고, 백업, 복원, 보안 등을 AWS가 대부분 처리합니다.

3. Amazon EC2에서 데이터베이스를 실행하려면 데이터베이스 소프트웨어의 업그레이트 및 유지 관리를 사용자가 직접 처리해야 합니다. 하지만 Amazon RDS를 사용하면 업그레이드 및 유지 보수가 AWS에 의해 관리되므로 관리 부담이 덜합니다.

Spring Framework 개념, 특징

"주인장" — Fri, 28 Jul 2023 10:35:34 +0900

Spring Framework

JAVA 언어를 기반으로 한 오픈 소스 애플리케이션 프레임워크입니다.

대규모 기업이나 조직에서 사용할 수 있도록 고려되어 프로그램 개발을 단순화하고 향상시키기 위해 만들어졌으며, 다양한 기능을 제공하여 개발자가 애플리케이션을 빠르게 개발하고 유지보수하는 데 도움을 줍니다.

1. 의존성 주입(DI: Dependency Injection)

개발자가 직접 객체를 생성하고 관리하는 대신, Spring 프레임워크는 애플리케이션의 설정 파일이나 어노테이션을 통해 객체 간의 의존성을 정의합니다. 그 다음 Spring 컨테이너가 이러한 객체를 생성하고 관리하며 필요한 곳에 주입합니다. 이렇게 하면 개발자는 객체의 생성 및 관리에 대한 부담이 줄어들게 됩니다.

2. 제어의 역전(IOC :Inversion of Control)

기본의 제어 흐름은 보통 애플리케이션 코드가 모든 것을 제어하고 결정합니다. 예를 들어, 객체의 생성, 초기화, 메소드 호출, 의존성 관리 등을 애플리케이션 코드가 직접 처리합니다. 이로 인해 애플리케이션 코드가 복잡해지고 유지보수가 어려워 질수 있습니다. 이런 문제를 해결하기 위해서 제어 흐름을 외부 엔진 또는 컨테이너에 위임하는 방식을 도입합니다. 주로 IOC 컨테이너가 제어의 중심 역할을 합니다. 대표적인 IOC 컨테이너로는 Spring Framework가 있으며, Spring은 객체의 생명주기 관리, 의존성 주입 등을 처리하여 IOC원칙을 구현합니다.

3. 관점 지향 프로그래밍(AOP: Aspect-Oriented Programming)

로깅, 보안, 트랜잭션 관리를 모듈화하고 분리하는데 사용되는 프로그래밍 패러다임 중 하나입니다.

AOP는 별도의 모듈 또는 관점(Aspect)으로 분리하고, 이러한 관점을 애플리케이션의 여러 부분에 적용할 수 있도록 도와줍니다. AOP를 사용하면 관점(Aspect)과 핵심 비지니스 로직을 분리함으로써 코드의 모듈화, 재사용성, 유지보수성을 향상시킬 수 있습니다.

MVC 디자인 패턴

"주인장" — Fri, 7 Jul 2023 21:02:44 +0900

디자인 패턴이란?

MVC는 Model, View, Controller의 약자로, 소프트웨어 설계에서 널리 사용되는 아키텍처 패턴이다.

M(Model): 애플리케이션의 데이터와 비즈니스 로직을 담당합니다.
V(View): 사용자에게 보여지는 UI를 담당합니다.
C(Controller): Model과 View 사이의 상호작용을 조정하는 역할을 합니다.

MVC 패턴에서는 사용자가 Controller를 통해 상호작용하면, Controller가 Model에서 필요한 데이터를 가져와 View를 통해 사용자에게 표시합니다.

모델1 아키텍처

JSP 기반의 모델1 아키텍처에서는 View와 Controller의 역할이 JSP 파일 내에서 함께 처리됩니다.

장점:

구조가 단순하여 소규모 프로젝트에 적합하다.
개발 속도가 빠르다.

단점:

프로젝트 규모가 커지면 코드가 복잡해져 유지보수가 어려워진다.
재사용성과 가독성이 떨어질 수 있다.

모델2 아키텍처 (MVC)

MVC 패턴을 기반으로 한 모델2 아키텍처는 Model, View, Controller를 분리하여 구현합니다.

장점:

역할 분담이 명확하여 유지보수가 용이하다.
재사용성과 확장성이 높다.
대규모 프로젝트에 적합하다.

단점:

초기 설계 단계에서 시간과 비용이 더 소요될 수 있다.
작은 프로젝트의 경우 오버엔지니어링이 될 수 있다.

hELLO 티스토리 스킨

"주인장" — Fri, 7 Jul 2023 14:29:32 +0900

안녕하세요!

개발자 블로그를 시작하게 되면서 여러가지 스킨을 찾아보았는데

그중에서 내 눈에 쏙 들어온 스킨은 hELLO 스킨입니다.

hELLO 스킨을 적용한 이유는 깔끔한 디자인과 목차를 한눈에 볼 수 있는 장점이 있기 때문입니다.

hELLO 스킨 주소

https://github.com/pronist/tistory-skin-hELLO

GitHub - pronist/tistory-skin-hELLO: 당신의 멋진 블로그에 걸맞는 최고의 티스토리 스킨

당신의 멋진 블로그에 걸맞는 최고의 티스토리 스킨. Contribute to pronist/tistory-skin-hELLO development by creating an account on GitHub.

github.com

감사합니다.

뚝딱뚝딱 개발소

[프로그래머스/코딩 테스트] 귤 고르기(JAVA)

문제설명

제한 사항

문제 풀이

전체 코드

[프로그래머스/코딩 테스트] 롤케이크 자르기(JAVA)

문제설명

제한사항

문제풀이

전체 코드

[프로그래머스/코딩테스트] 오픈채팅방(JAVA)

문제 설명

제한사항

문제풀이

전체코드

[프로그래머스/코딩테스트] 택배 상자 꺼내기(JAVA)

문제설명

제한사항

문제 풀이

전체 코드

[프로그래머스/코딩테스트] 삼총사(JAVA)

문제설명

제한사항

문제풀이

전체코드

[프로그래머스/코딩테스트] 숫자 짝궁(JAVA)

문제설명

제한사항

문제풀이

전체코드

[프로그래머스/코딩 테스트] 미로 탈출(JAVA)

문제 설명

제한 사항

문제 풀이

전체 코드

[프로그래머스/코딩테스트] 콜라 문제(JAVA)

문제설명

제한사항

문제 풀이

전체 코드

실전! 스프링 부트와 JPA 활용1 - 웹 애플리케이션 개발(후기)

JDBC (Java Database Connectivity)**를 사용한 DB 연결

MyBatis 를 사용한 DB 연결

[프로그래머스/코딩테스트] 유연근무제(JAVA)

문제 설명

제한사항

문제 풀이

전체 코드

[프로그래머스/코딩테스트] 개인정보 수집 유효기간(JAVA)

문제 설명

제한사항

문제풀이

김영한의 실전 자바 - 중급 2편 후기

[프로그래머스/코딩테스트] 둘만의 암호 (JAVA)

문제설명

제한사항

문제풀이

전체코드

[프로그래머스/코딩테스트] 카드 뭉치(JAVA)

문제 설명

제한사항

문제 풀이

[프로그래머스/ 코딩테스트] 대충 만든 자판(JAVA)

문제 설명

제한사항

문제 풀이

전체 코드

[프로그래머스/ 코딩테스트] 덧칠하기 (JAVA)

문제 설명

제한사항

문제풀이

전체코드

[프로그래머스/ 코딩테스트] 바탕화면 정리 (JAVA)

문제설명

제안사항

문제풀이

전체코드

[프로그래머스/ 코딩테스트] 공원 산책 (JAVA)

문제설명

JDBC (Java Database Connectivity)를 사용한 DB 연결**