📝 문제 설명

얀에서는 매년 달리기 경주가 열립니다. 해설진들은 선수들이 자기 바로 앞의 선수를 추월할 때 추월한 선수의 이름을 부릅니다. 예를 들어 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

4등인 "kai" 선수가 2번 추월하여 2등이 되고 앞서 3등, 2등인 "poe", "soe" 선수는 4등, 3등이 됩니다. 5등인 "mine" 선수가 2번 추월하여 4등, 3등인 "poe", "soe" 선수가 5등, 4등이 되고 경주가 끝납니다. 1등부터 배열에 담으면 ["mumu", "kai", "mine", "soe", "poe"]이 됩니다.

💡 내가 쓴 풀이

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = new String[players.length];
        HashMap<String, Integer> map = new HashMap<>();

        ArrayList<String> arr = new ArrayList<>(Arrays.asList(players));
        int cnt = 0;

        for(int i=0; i<players.length; i++) {
            map.put(players[i], i);
        }

        // "mumu", "kai", "mine", "soe", "poe"

        for(int i=0; i<callings.length; i++) {
            int idx = map.get(callings[i])-1;
            int idx2 = map.get(callings[i]);

            String name = players[idx]; // 앞 선수 이름 가져옴

            map.put(name, idx2);
            map.put(callings[i], idx);

            players[idx] = callings[i];
            players[idx2] = name;
        }

        answer = players.clone();
        return answer;
    }
}

→ 처음에는 ArrayList 하나를 생성한 후 indexOf로 index를 가져왔었다. 이렇게 실행하니 제출했을 때 시간 초과가 발생했다. 그래서 해당 시간 초과는 어떻게 해결하나 싶어 문제의 질문을 둘러보았다.. 알고보니 indexOf라는 함수 시간복잡도 문제 ㅠㅠ

• 질문을 보니 시간초과 내용이 많았다. 특정 분의 답변(아래)을 보면 indexOf가 배열을 순회하면서 찾기 때문에 크기가 커지는 만큼 시간복잡도가 늘어난다는 것이다. 이걸 생각해서 arr를 add, remove를 하니 시간초과가 또 났다,,,그래서 그냥 playes를 바로 바꿔주는 방법으로 했더니 성공 😂

👀 @Hounds1 : Java 타임아웃
💡 List에 현재 등수를 저장하고 .indexOf() 메소드를 사용하여 callings 대상의 인덱스를 찾는 경우 배열을 순회하며 찾기때문에 크기가 커지는 만큼 시간복잡도가 늘어납니다.
따라서 HashMap에 저장 후 .get() 메소드를 사용하여 callings 대상의 현재 인덱스를 바로 찾아 Array에 반영하고 HashMap에도 수정된 등수를 반영하여 Array와 HashMap을 동기화하는 방식의 반복을 통해 마지막 callings 까지 처리한다면 타임아웃 없이 해결 가능합니다.

시간복잡도의 경우 참 복잡한 것 같다 😅

🔈 문제 설명

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

예를 들어, 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의 원소는 알파벳 대문자로만 이루어져 있습니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1

• "ABCD"의 경우,
• 1번 키 한 번 → A
• 2번 키 한 번 → B
• 2번 키 두 번 → C
• 1번 키 다섯 번 → D
• 따라서 총합인 9를 첫 번째 인덱스에 저장합니다.
• "AABB"의 경우,
• 1번 키 한 번 → A
• 1번 키 한 번 → A
• 2번 키 한 번 → B
• 2번 키 한 번 → B
• 따라서 총합인 4를 두 번째 인덱스에 저장합니다.
• 결과적으로 [9,4]를 return 합니다.

입출력 예 #2

• "B"의 경우, 'B'가 어디에도 존재하지 않기 때문에 -1을 첫 번째 인덱스에 저장합니다.
• 결과적으로 [-1]을 return 합니다.

입출력 예 #3

• "ASA"의 경우,
• 1번 키 한 번 → A
• 2번 키 두 번 → S
• 1번 키 한 번 → A
• 따라서 총합인 4를 첫 번째 인덱스에 저장합니다.
• "BGZ"의 경우,
• 2번 키 한 번 → B
• 1번 키 두 번 → G
• 1번 키 세 번 → Z
• 따라서 총합인 6을 두 번째 인덱스에 저장합니다.
• 결과적으로 [4, 6]을 return 합니다.

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        int[] answer = new int[targets.length];
        HashMap<Character, Integer> map = new HashMap<>();
        boolean flag = false;
        for(int i=0; i<keymap.length; i++) {
            for(int j=0; j<keymap[i].length(); j++) {
                if(map.containsKey(keymap[i].charAt(j))) {
                    int number = map.get(keymap[i].charAt(j));
                    map.put(keymap[i].charAt(j), Math.min(number, j));
                }else {
                    map.put(keymap[i].charAt(j), j);
                }
            }
        }

        for(int i=0; i<targets.length; i++) {
            int sum = 0;
            flag = false;
            for(int j=0; j<targets[i].length(); j++) {
                if(map.containsKey(targets[i].charAt(j))) {
                    sum+=map.get(targets[i].charAt(j))+1;    
                }else {
                    answer[i] = -1;
                    flag = true;
                }
            }
            System.out.println(sum);
            if(!flag) answer[i] = sum;
        }
        return answer;
    }
}

→ 처음에 테스트케이스는 다 맞았는데 제출했을 때 11번부터 많이 틀려서 뭐지 ? 하고 질문하기를 확인했다. 반례를 들어주신 분이 있어 확인해보니 아래의 반례가 있었다.

keymap = ["BC"] targets = ["AC", "BC"] 기댓값→ [-1, 3] 이였다.

나는 targets이 하나라도 없으면 answer[0] = -1 을 해서 바로 return answer 시켰는데, 이게 아니라 없는 targets[i]는 -1로 다음거는 그대로 진행 ! 이였던 것이다.

그래서 flag를 하나 세워서 answer[i] = -1을 넣었을 때는 flag = true로 하고 for문을 나왔을 때 false인 경우에만 즉, keymap에 있었던 문자의 경우만 sum 해준거를 answer에 넣어주었다.

반례가 세상 중요하다 😂

🔈 문제 설명

신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.

• 각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
  • 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
  • 한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.

• k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
  • 유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.

다음은 전체 유저 목록이 ["muzi", "frodo", "apeach", "neo"]이고, k = 2(즉, 2번 이상 신고당하면 이용 정지)인 경우의 예시입니다.

각 유저별로 신고당한 횟수는 다음과 같습니다.

위 예시에서는 2번 이상 신고당한 "frodo"와 "neo"의 게시판 이용이 정지됩니다. 이때, 각 유저별로 신고한 아이디와 정지된 아이디를 정리하면 다음과 같습니다.

따라서 "muzi"는 처리 결과 메일을 2회, "frodo"와 "apeach"는 각각 처리 결과 메일을 1회 받게 됩니다.
이용자의 ID가 담긴 문자열 배열 id_list, 각 이용자가 신고한 이용자의 ID 정보가 담긴 문자열 배열 report, 정지 기준이 되는 신고 횟수 k가 매개변수로 주어질 때, 각 유저별로 처리 결과 메일을 받은 횟수를 배열에 담아 return 하도록 solution 함수를 완성해주세요.

✅ 제한사항

• 2 ≤ id_list의 길이 ≤ 1,000
  • 1 ≤ id_list의 원소 길이 ≤ 10
  • id_list의 원소는 이용자의 id를 나타내는 문자열이며 알파벳 소문자로만 이루어져 있습니다.
  • id_list에는 같은 아이디가 중복해서 들어있지 않습니다.
• 1 ≤ report의 길이 ≤ 200,000
  • 3 ≤ report의 원소 길이 ≤ 21
  • report의 원소는 "이용자id 신고한id"형태의 문자열입니다.
  • 예를 들어 "muzi frodo"의 경우 "muzi"가 "frodo"를 신고했다는 의미입니다.
  • id는 알파벳 소문자로만 이루어져 있습니다.
  • 이용자id와 신고한id는 공백(스페이스)하나로 구분되어 있습니다.
  • 자기 자신을 신고하는 경우는 없습니다.
• 1 ≤ k ≤ 200, k는 자연수입니다.
• return 하는 배열은 id_list에 담긴 id 순서대로 각 유저가 받은 결과 메일 수를 담으면 됩니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1

문제의 예시와 같습니다.

입출력 예 #2

"ryan"이 "con"을 4번 신고했으나, 주어진 조건에 따라 한 유저가 같은 유저를 여러 번 신고한 경우는 신고 횟수 1회로 처리합니다. 따라서 "con"은 1회 신고당했습니다. 3번 이상 신고당한 이용자는 없으며, "con"과 "ryan"은 결과 메일을 받지 않습니다. 따라서 [0, 0]을 return 합니다.

제한시간 안내

• 정확성 테스트 : 10초

💛 내가 쓴 풀이

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        int[] answer = new int[id_list.length];
        HashMap<String, ArrayList<String>> map = new HashMap<>(); // 누가 누구를 신고했는지
        HashMap<String, Integer> singo = new HashMap<>(); // 신고 받은 횟수
        HashMap<String, Integer> mail = new HashMap<>();
        int cnt = 0;

        for(int i=0; i<report.length; i++) {
            String[] arr = report[i].split(" ");
            // 신고한적이 있고, 신고한 사람도 이미 신고한 사람이라면 넘김
            if(map.containsKey(arr[0]) && map.get(arr[0]).contains(arr[1])) {
                continue;
            }else if(map.containsKey(arr[0]) && !map.get(arr[0]).contains(arr[1])) {
                ArrayList<String> lst = map.get(arr[0]);
                lst.add(arr[1]);
                map.put(arr[0], lst);
                singo.put(arr[1], singo.getOrDefault(arr[1], 0)+1);
            }else if(!map.containsKey(arr[0])) {
                map.put(arr[0], new ArrayList<>(Arrays.asList(arr[1])));
                singo.put(arr[1], singo.getOrDefault(arr[1], 0)+1);
            }
        }

        for(String singo1 : singo.keySet()) {

            if(singo.get(singo1) >= k) {
                for(String str1 : map.keySet()) {
                    if(map.get(str1).contains(singo1)) {

                        mail.put(str1, mail.getOrDefault(str1, 0)+1);
                    }
                }
            }
        }

        for(int i=0; i<id_list.length; i++) {
            answer[i] = mail.getOrDefault(id_list[i], 0);
        }
        return answer;
    }
}

→ k가 주어진거를 지나치고 2라고 고정해놨어서 제출하니까 다 틀려서 놀랬다…문제를 꼼꼼하게 읽자 ^_^,,,,,

LV.1 이 맞는 난이도는 맞는데,,,쉽긴 쉬운데 뭔가 헷갈렸던 그런 문제 😂

🔈 문제 설명

사진들을 보며 추억에 젖어 있던 루는 사진별로 추억 점수를 매길려고 합니다. 사진 속에 나오는 인물의 그리움 점수를 모두 합산한 값이 해당 사진의 추억 점수가 됩니다. 예를 들어 사진 속 인물의 이름이 ["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]의 원소들은 중복된 값이 들어가지 않습니다.

📝 입출력 예

입출력 예 설명

** 입출력 예 #1**

첫 번째 사진 속 "may", "kein", "kain", "radi"의 그리움 점수를 합치면 19(5 + 10 + 1 + 3)점 입니다. 두 번째 사진 속 그리워하는 사람들인 "may"와 "kein"의 그리움 점수를 합치면 15(5 + 10)점입니다. 세 번째 사진의 경우 "kain"과 "may"만 그리워하므로 둘의 그리움 점수를 합한 6(1 + 5)점이 사진의 추억 점수입니다. 따라서 [19, 15, 6]을 반환합니다.

입출력 예 #2

첫 번째 사진 속 그리워하는 사람들인 "kali", "mari", "don"의 그리움 점수를 합치면 67(11 + 1 + 55)점입니다. 두 번째 사진 속엔 그리워하는 인물이 없으므로 0점입니다. 세 번째 사진 속 그리워하는 사람은 "don"만 있으므로 55점입니다. 따라서 [67, 0, 55]를 반환합니다.

입출력 예 #3 설명 생략

💛 내가 쓴 풀이

import java.util.ArrayList;
import java.util.Arrays;
class Solution {
    public int[] solution(String[] name, int[] yearning, String[][] photo) {
        int[] answer;
        ArrayList<String> arr = new ArrayList<>(Arrays.asList(name));
        ArrayList<Integer> ans = new ArrayList<>();
        int sum = 0, cnt = 0;
        for(int i=0; i<photo.length; i++) {
            sum = 0;
            for(int j=0; j<photo[i].length; j++) {
                if(arr.indexOf(photo[i][j]) != -1) {
                    sum += yearning[arr.indexOf(photo[i][j])];
                }
            }
            ans.add(sum);
        }
        answer = new int[ans.size()];

        for(int n : ans) {
            answer[cnt++] = n;
        }
        return answer;
    }
}

🔈 문제 설명

주차장의 요금표와 차량이 들어오고(입차) 나간(출차) 기록이 주어졌을 때, 차량별로 주차 요금을 계산하려고 합니다. 아래는 하나의 예시를 나타냅니다.

• 요금표

주차 요금을 나타내는 정수 배열 fees, 자동차의 입/출차 내역을 나타내는 문자열 배열 records가 매개변수로 주어집니다. 차량 번호가 작은 자동차부터 청구할 주차 요금을 차례대로 정수 배열에 담아서 return 하도록 solution 함수를 완성해주세요.

✅ 제한사항

• fees의 길이 = 4
  • fees[0] = 기본 시간(분)
  • 1 ≤ fees[0] ≤ 1,439
  • fees[1] = 기본 요금(원)
  • 0 ≤ fees[1] ≤ 100,000
  • fees[2] = 단위 시간(분)
  • 1 ≤ fees[2] ≤ 1,439
  • fees[3] = 단위 요금(원)
  • 1 ≤ fees[3] ≤ 10,000
• 1 ≤ records의 길이 ≤ 1,000
  • records의 각 원소는 "시각 차량번호 내역" 형식의 문자열입니다.
  • 시각, 차량번호, 내역은 하나의 공백으로 구분되어 있습니다.
  • 시각은 차량이 입차되거나 출차된 시각을 나타내며, HH:MM 형식의 길이 5인 문자열입니다.
    • HH:MM은 00:00부터 23:59까지 주어집니다.
    • 잘못된 시각("25:22", "09:65" 등)은 입력으로 주어지지 않습니다.
  • 차량번호는 자동차를 구분하기 위한, `0'~'9'로 구성된 길이 4인 문자열입니다.
  • 내역은 길이 2 또는 3인 문자열로, IN 또는 OUT입니다. IN은 입차를, OUT은 출차를 의미합니다.
  • records의 원소들은 시각을 기준으로 오름차순으로 정렬되어 주어집니다.
  • records는 하루 동안의 입/출차된 기록만 담고 있으며, 입차된 차량이 다음날 출차되는 경우는 입력으로 주어지지 않습니다.
  • 같은 시각에, 같은 차량번호의 내역이 2번 이상 나타내지 않습니다.
  • 마지막 시각(23:59)에 입차되는 경우는 입력으로 주어지지 않습니다.
  • 아래의 예를 포함하여, 잘못된 입력은 주어지지 않습니다.
    • 주차장에 없는 차량이 출차되는 경우
    • 주차장에 이미 있는 차량(차량번호가 같은 차량)이 다시 입차되는 경우

📝 입출력 예

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

• 요금표

입출력 예 #3

• 요금표

💛 내가 쓴 풀이

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
class Solution {
    public int[] solution(int[] fees, String[] records) {
        int[] answer;
        HashMap<String, String> map = new HashMap<>(); // 입출차를 위한 map
        HashMap<String, Double> ret = new HashMap<>(); // 누적 주차시간
        String[] arr;
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
        ArrayList<String> lst = new ArrayList<>();
        int cnt = 0;
        // 입차 시각
        Date date1;
        // 출차 시각
        Date date2;
        // 1. fees[0] : 기본시간 (분) 180 분
        // 2. fees[1] : 기본요금 (원) 5000원
        // 3. fees[2] : 단위시간 (분) 10분
        // 4. fees[3] : 단위요금 (원) 600원

        for(int i=0; i<records.length; i++) {
            arr = records[i].split(" ");
            // 1. 이미 주차장 기록이 존재하고 현재 들어온 값이 OUT 이라면 계산
            if(map.containsKey(arr[1]) && arr[2].equals("OUT")){ 
                try {
                    date1 = sdf.parse(map.get(arr[1]));
                    date2 = sdf.parse(arr[0]);

                    long timeMil1 = date1.getTime();
                    long timeMil2 = date2.getTime();

                    long diffMin = (timeMil2 - timeMil1) / (1000 * 60);

                    ret.put(arr[1], ret.getOrDefault(arr[1], 0.0)+diffMin);

                    // 출차 후 삭제
                    map.remove(arr[1]);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }else {
                map.put(arr[1], arr[0]);    
            }

        } // end for

        if(map.size() > 0) { // 다 지웠는데 아직 남아있는 경우는 23:59분 출차로 계산
            for(String str : map.keySet()) {

                try {
                    date1 = sdf.parse(map.get(str));
                    date2 = sdf.parse("23:59");
                    long timeMil1 = date1.getTime();
                    long timeMil2 = date2.getTime();
                    long diffMin = (timeMil2 - timeMil1) / (1000 * 60);

                    ret.put(str, ret.getOrDefault(str, 0.0)+diffMin);

                    // 출차 후 삭제 
                    //map.remove(str); map.keySet()을 사용하고 있으니 삭제하면 안됨
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        } // end : if


        for(String s : ret.keySet()) {
            int sum = 0;
            if(ret.get(s) <= fees[0]) {
                sum = fees[1]; // 기본요금
            }else{
                Double ln = ret.get(s)-fees[0];
                sum = fees[1]+(int)(Math.ceil(ln/fees[2]))*fees[3];
            }
            ret.put(s, Double.valueOf(sum));
        }

        lst = new ArrayList<>(ret.keySet());
        Collections.sort(lst);

        answer = new int[ret.size()];
        for(String l : lst) {
            answer[cnt++] = ret.get(l).intValue();
        }

        return answer;
    }
}

내 풀이가 너무 긴가 싶었는데 다른 분들 답도 긴 것도 많아보여서 안심했다.

💡 처음에 테케는 다 맞고 런타임 에러났는데 어떤 분이 map.remove(str); 이 부분이 문제라고 하셔서 아랫부분에 remove를 주석처리 했다.
이유는 for문에서 map.keySet() 을 이미 사용하고 있는데 동시에 키를 삭제해서 동시성 오류가 발생하여 런타임 오류가 발생한것 같다 라고 하셨다.
이런 부분에서 사소하게 놓치고 있는게 헛점 같다 😥

🔈 문제 설명

XX게임에는 피로도 시스템(0 이상의 정수로 표현합니다)이 있으며, 일정 피로도를 사용해서 던전을 탐험할 수 있습니다. 이때, 각 던전마다 탐험을 시작하기 위해 필요한 "최소 필요 피로도"와 던전 탐험을 마쳤을 때 소모되는 "소모 피로도"가 있습니다. "최소 필요 피로도"는 해당 던전을 탐험하기 위해 가지고 있어야 하는 최소한의 피로도를 나타내며, "소모 피로도"는 던전을 탐험한 후 소모되는 피로도를 나타냅니다. 예를 들어 "최소 필요 피로도"가 80, "소모 피로도"가 20인 던전을 탐험하기 위해서는 유저의 현재 남은 피로도는 80 이상 이어야 하며, 던전을 탐험한 후에는 피로도 20이 소모됩니다.
이 게임에는 하루에 한 번씩 탐험할 수 있는 던전이 여러개 있는데, 한 유저가 오늘 이 던전들을 최대한 많이 탐험하려 합니다.
유저의 현재 피로도 k와 각 던전별 "최소 필요 피로도", "소모 피로도"가 담긴 2차원 배열 dungeons 가 매개변수로 주어질 때, 유저가 탐험할수 있는 최대 던전 수를 return 하도록 solution 함수를 완성해주세요.

✅ 제한사항

• k는 1 이상 5,000 이하인 자연수입니다.
• dungeons의 세로(행) 길이(즉, 던전의 개수)는 1 이상 8 이하입니다.
  • dungeons의 가로(열) 길이는 2 입니다.
  • dungeons의 각 행은 각 던전의 ["최소 필요 피로도", "소모 피로도"] 입니다.
  • "최소 필요 피로도"는 항상 "소모 피로도"보다 크거나 같습니다.
  • "최소 필요 피로도"와 "소모 피로도"는 1 이상 1,000 이하인 자연수입니다.
  • 서로 다른 던전의 ["최소 필요 피로도", "소모 피로도"]가 서로 같을 수 있습니다.

📝 입출력 예

입출력 예 설명

현재 피로도는 80입니다.

만약, 첫 번째 → 두 번째 → 세 번째 던전 순서로 탐험한다면

• 현재 피로도는 80이며, 첫 번째 던전을 돌기위해 필요한 "최소 필요 피로도" 또한 80이므로, 첫 번째 던전을 탐험할 수 있습니다. 첫 번째 던전의 "소모 피로도"는 20이므로, 던전을 탐험한 후 남은 피로도는 60입니다.
• 남은 피로도는 60이며, 두 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 50이므로, 두 번째 던전을 탐험할 수 있습니다. 두 번째 던전의 "소모 피로도"는 40이므로, 던전을 탐험한 후 남은 피로도는 20입니다.
• 남은 피로도는 20이며, 세 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 30입니다. 따라서 세 번째 던전은 탐험할 수 없습니다.

만약, 첫 번째 → 세 번째 → 두 번째 던전 순서로 탐험한다면

• 현재 피로도는 80이며, 첫 번째 던전을 돌기위해 필요한 "최소 필요 피로도" 또한 80이므로, 첫 번째 던전을 탐험할 수 있습니다. 첫 번째 던전의 "소모 피로도"는 20이므로, 던전을 탐험한 후 남은 피로도는 60입니다.
• 남은 피로도는 60이며, 세 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 30이므로, 세 번째 던전을 탐험할 수 있습니다. 세 번째 던전의 "소모 피로도"는 10이므로, 던전을 탐험한 후 남은 피로도는 50입니다.
• 남은 피로도는 50이며, 두 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 50이므로, 두 번째 던전을 탐험할 수 있습니다. 두 번째 던전의 "소모 피로도"는 40이므로, 던전을 탐험한 후 남은 피로도는 10입니다.

따라서 이 경우 세 던전을 모두 탐험할 수 있으며, 유저가 탐험할 수 있는 최대 던전 수는 3입니다.

💛 내가 쓴 풀이

class Solution {
    int cnt = 0;
    boolean[] visited;
    public int solution(int k, int[][] dungeons) {
        int answer = -1;
        visited = new boolean[dungeons.length];
        dfs(0, k, dungeons);
        answer = cnt;

        return answer;
    }
    public void dfs(int depth, int k, int[][] dungeons){
        for(int i=0; i<dungeons.length; i++){
            if(!visited[i] && dungeons[i][0] <= k){
                visited[i] = true;
                dfs(depth+1, k-dungeons[i][1], dungeons);
                visited[i] = false;
            }
        }
        cnt = Math.max(cnt, depth);
    }
}

😥 완전탐색에 대한 이해나 개념이 조금 헷갈려서 이해하는데 오래걸렸다. 이 문제 풀면서 드디어 완탐에 대한 감은 잡았다. 이해하게 도움을 준 L씨에게 감사 👍

🔈 문제 설명

경화는 과수원에서 귤을 수확했습니다. 경화는 수확한 귤 중 '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

📝 입출력 예

입출력 예 설명

입출력 예 #1

• 본문에서 설명한 예시입니다.

입출력 예 #2

• 경화는 크기가 2인 귤 2개와 3인 귤 2개 또는 2인 귤 2개와 5인 귤 2개 또는 3인 귤 2개와 5인 귤 2개로 귤을 판매할 수 있습니다. 이때의 크기 종류는 2가지로 이 값이 최소가 됩니다.

입출력 예 #3

• 경화는 크기가 1인 귤 2개를 판매하거나 2인 귤 2개를 판매할 수 있습니다. 이때의 크기 종류는 1가지로, 이 값이 최소가 됩니다.

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int solution(int k, int[] tangerine) {
        int answer = 0;
        int cnt = 0;
        ArrayList<Integer> ary = new ArrayList<>();
        HashMap<Integer, Integer> map = new HashMap<>();
        List<Integer> keySet;


        for(int tang : tangerine) {
            map.put(tang, map.getOrDefault(tang, 0)+1);    
        }
        // 1. hashmap value 값으로 내림차순 정렬을 위해 keySet List 
        keySet = new ArrayList<>(map.keySet());

        // 2. value 값을 기준으로 key값을 정렬
        keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));

        // 3. value값이 높은 것을 기준으로 arraylist 만들기
        Loop1 :
        for(int num : keySet) {
            ary.add(num);

            for(int i=1; i<=map.get(num); i++) {
                if(cnt == k) break Loop1;
                cnt++;
            }
            if(cnt == k) break;
        }

        answer = ary.size();
        return answer;
    }
}

정답 이전에 썼던 풀이

import java.util.*;

class Solution {
    public int solution(int k, int[] tangerine) {
        int answer = 0;
        int cnt = 0;
                ArrayList<Integer> ary = new ArrayList<>();
                HashMap<Integer, Integer> map = new HashMap<>();
                List<Integer> keySet;

        for(int tang : tangerine) {
            map.put(tang, map.getOrDefault(tang, 0)+1);    
        }
        // 1. hashmap value 값으로 내림차순 정렬을 위해 keySet List 
        keySet = new ArrayList<>(map.keySet());

        // 2. value 값을 기준으로 key값을 정렬
        keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));

        // 3. value값이 높은 것을 기준으로 arraylist 만들기
        for(int num : keySet) {

            // 4. 개수만큼 골랐으면 끝낸다.
            if(cnt == k) break;

            // 5. 위에 조건이 아니라면 
            ary.add(num);
            cnt+=map.get(num);
        }

        answer = ary.size();
        return answer;
    }
}

😥 이 풀이는 value 값을 바로 더해줘서 틀렸었던 풀이였다. 위에 풀이처럼 value 만큼 차례차례 더해주다가 개수만큼 담으면 바로 빠져나와줘야한다.

남들이 쓴 풀이도 비슷하다. 그래도 안보고 남들과 비슷하게 잘 풀었다 😃

🔈 문제 설명

자연수 n이 주어졌을 때, n의 다음 큰 숫자는 다음과 같이 정의 합니다.

• 조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.
• 조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.
• 조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는 수 중 가장 작은 수 입니다.

예를 들어서 78(1001110)의 다음 큰 숫자는 83(1010011)입니다.
자연수 n이 매개변수로 주어질 때, n의 다음 큰 숫자를 return 하는 solution 함수를 완성해주세요.

✅ 제한 사항

• n은 1,000,000 이하의 자연수 입니다.

📝 입출력 예

입출력 예 설명

입출력 예#1

문제 예시와 같습니다.

입출력 예#2

15(1111)의 다음 큰 숫자는 23(10111)입니다.

💛 내가 쓴 풀이

class Solution {
    public int solution(int n) {
        int answer = 0;
        String bin = Integer.toBinaryString(n);
        String next_bin = "";
        // 원래 숫자의 1의 개수
        int cnt = bin.length()-bin.replace("1", "").length();
        // 다음 큰 숫자의 1의 개수
        int next_cnt = 0;

        for(int i=n+1; i<=1000000; i++) {
            next_bin = Integer.toBinaryString(i);
            // 1의 개수
            next_cnt = next_bin.length() - next_bin.replace("1", "").length();
            if(cnt == next_cnt) {
                answer = i;
                break;
            }
        }
        return answer;
    }
}

아래는 전에 썼던 풀이인데 아마 while(true)를 써서 효율성 부문에서 시간초과 나지 않았을까 싶다 🤔

class Solution {
    public int solution(int n) {
        int answer = 0;
        int num = n+1;
        String bin1=Integer.toBinaryString(n);
        String bin2=""; // 다음 큰 숫자
        int leng1 = 0, leng2 = 0;

        while(true){
            bin2=Integer.toBinaryString(num);
            leng1 = bin1.length()-bin1.replace("1","").length();
            leng2 = bin2.length()-bin2.replace("1","").length(); 
            if(leng1 == leng2) break;
            num ++;
        }

        return num;
    }
}

💬 남이 쓴 풀이

import java.lang.Integer;
class TryHelloWorld
{
    public int nextBigNumber(int n)
    {
      int a = Integer.bitCount(n);
      int compare = n+1;
      while(true) {
        if(Integer.bitCount(compare)==a)
          break;
        compare++;
      }
      return compare;
    }
    public static void main(String[] args)
    {
        TryHelloWorld test = new TryHelloWorld();
        int n = 78;
        System.out.println(test.nextBigNumber(n));
    }
}

bitCount라는게 있는지는 몰랐다. 다음에 이런 비슷한 문제가 생기면 활용해봐야지 😃

🔈 문제 설명

피보나치 수는 F(0) = 0, F(1) = 1일 때, 1 이상의 n에 대하여 F(n) = F(n-1) + F(n-2) 가 적용되는 수 입니다.

예를들어

• F(2) = F(0) + F(1) = 0 + 1 = 1
• F(3) = F(1) + F(2) = 1 + 1 = 2
• F(4) = F(2) + F(3) = 1 + 2 = 3
• F(5) = F(3) + F(4) = 2 + 3 = 5

와 같이 이어집니다.

2 이상의 n이 입력되었을 때, n번째 피보나치 수를 1234567으로 나눈 나머지를 리턴하는 함수, solution을 완성해 주세요.

✅ 제한 사항

• n은 2 이상 100,000 이하인 자연수입니다.

📝 입출력 예

입출력 예 설명

피보나치수는 0번째부터 0, 1, 1, 2, 3, 5, ... 와 같이 이어집니다.

💛 내가 쓴 풀이

import java.util.*;
class Solution {

    public static int[] arr;
    public int solution(int n) {
        int answer = 0;
        arr = new int[n+1];
        answer = fibo(n);
        return answer;
    }

    public static int fibo(int n) {
        if (n < 2)
            return n; 
        else if (arr[n] != 0)     
            return arr[n];
        else 
            return arr[n] =  (fibo(n-2) + fibo(n-1))%1234567;
    }
}

재귀 함수의 경우 호출 횟수를 고려해야한다. 제한 사항을 보면 n은 2 이상 100,000 이하인 자연수입니다. 라는 조건이 있다.

한 함수에서 두 개의 함수를 호출하여 호출이 2배씩 늘어나기 때문에 시간 복잡도가 O(2^N) 라고 한다. 메모이제이션을 사용하면 해결가능하다고 한다.

❗ 시간 초과 났던 풀이

class Solution {
    public int solution(int n) {
        int answer = 0;
        answer = fibo(n)%1234567;

        return answer;
    }
    public int fibo(int n) {
        if (n <= 1)
            return n;
        else 
            return fibo(n-2) + fibo(n-1);
    }
}

🔈 문제 설명

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 자연수 n을 연속한 자연수들로 표현 하는 방법이 여러개라는 사실을 알게 되었습니다. 예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다.

• 1 + 2 + 3 + 4 + 5 = 15
• 4 + 5 + 6 = 15
• 7 + 8 = 15
• 15 = 15

자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

✅ 제한사항

• n은 10,000 이하의 자연수 입니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1 문제의 예시와 같습니다.

💛 내가 쓴 풀이

class Solution {
    public int solution(int n) {
        int answer = 0;
        int sum = 0, i=1;

        while(i <= n) {
            for(int j=i; j<=n; j++) {
                sum+=j;
                if(sum == n) {
                    i++;
                    answer++;
                    sum = 0;
                    break;
                }else if(sum > n) break;
            }
            i++;
            sum = 0;
        }
        return answer;
    }
}

😥 else if에 sum>n에 break문을 안넣었더니 답은 맞는데 효율성에서 다 초과가 나왔었다. sum == n을 하면 sum 이 n보다 큰거는 돌지 않는다고 생각을 했는데 그거 때문인지 효율성 에러라서 sum > n 조건을 넣고 break를 걸어주었다. 그랬더니 효율성 성공이 떴다.

💬 다른 사람 풀이

class Solution {
    public int solution(int n) {
        int answer = 1;

        for (int k = 1; k <= n / 2; k++) {
            int sum = 0;
            int i = k;
            while (sum < n) {
                sum += i++;
            }
            // System.out.println(sum);
            if (sum == n)
                answer++;
        }
        return answer;
    }
}

나는 for문 전체를 다 돌렸지만, 이 분은 for문 n/2만큼 반복

💡 예시에서 7 + 8 = 15처럼, 15 절반의 수인 7은 8과 더했을 때 15를 얻을 수 있지만, 8 이상의 수의 연속된 숫자는 15의 수를 넘기에 n/2만큼만 반복했다.

📌 참고한 블로그 https://developerm.tistory.com/m/186

🔈 문제 설명

n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.

-1+1+1+1+1 = 3 +1-1+1+1+1 = 3 +1+1-1+1+1 = 3 +1+1+1-1+1 = 3 +1+1+1+1-1 = 3

사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

✅ 제한사항

• 주어지는 숫자의 개수는 2개 이상 20개 이하입니다.
• 각 숫자는 1 이상 50 이하인 자연수입니다.
• 타겟 넘버는 1 이상 1000 이하인 자연수입니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

+4+1-2+1 = 4 +4-1+2-1 = 4

• 총 2가지 방법이 있으므로, 2를 return 합니다.

💛 내가 쓴 풀이

class Solution {
    int cnt = 0;
    public int solution(int[] numbers, int target) {
        int answer = 0;
        dfs(numbers, target, 0, 0);
        answer = cnt;
        return answer;
    }

    public void dfs(int[] numbers, int target, int idx, int sum){
        if(idx == numbers.length){ // 끝까지 도달
            if(target == sum) cnt++;
            return;
        }

        dfs(numbers, target, idx+1, sum+numbers[idx]);
        dfs(numbers, target, idx+1, sum-numbers[idx]);
    }
}

DFS/BFS 문제에는 아직까지 익숙하지 못하다. 익숙해질 필요가 있다 😥

💡 참고한 블로그 https://mag1c.tistory.com/282

🔈 문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.
0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

✅ 제한 사항

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

📝 입출력 예

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        int i = 0;
        String[] str_num = new String[numbers.length];
        for(int num : numbers) {
            str_num[i++] = Integer.toString(num);
        }

        Arrays.sort(str_num, (s1, s2) -> (s2 + s1).compareTo(s1 + s2));
        if(str_num[0].equals("0")) return "0";

        for(String str : str_num) {
            answer += str+"";
        }
        return answer;
    }
}

→ if(str_num[0].equals("0")) return "0"; 이 부분에 대한 이유는 만약 {0,0,0,0} 이라는 배열이 있게 되면 “0000”이 아닌 “0”으로 리턴해야한다.

💡 *즉, 첫번째 자리가 0이 나오는 경우는 [0,0,0, ... , 0]. 0이 N개인 경우밖에 없다. *

🔈 문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

Leo는 모든 음식의 스코빌 지수가 K 이상이 될 때까지 반복하여 섞습니다. Leo가 가진 음식의 스코빌 지수를 담은 배열 scoville과 원하는 스코빌 지수 K가 주어질 때, 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 하도록 solution 함수를 작성해주세요.

✅ 제한 사항

• scoville의 길이는 2 이상 1,000,000 이하입니다.
• K는 0 이상 1,000,000,000 이하입니다.
• scoville의 원소는 각각 0 이상 1,000,000 이하입니다.
• 모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우에는 -1을 return 합니다.

📝 입출력 예

입출력 예 설명

1. 스코빌 지수가 1인 음식과 2인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.새로운 음식의 스코빌 지수 = 1 + (2 * 2) = 5가진 음식의 스코빌 지수 = [5, 3, 9, 10, 12]
2. 스코빌 지수가 3인 음식과 5인 음식을 섞으면 음식의 스코빌 지수가 아래와 같이 됩니다.새로운 음식의 스코빌 지수 = 3 + (5 * 2) = 13가진 음식의 스코빌 지수 = [13, 9, 10, 12]

모든 음식의 스코빌 지수가 7 이상이 되었고 이때 섞은 횟수는 2회입니다.

💛 내가 쓴 풀이

import java.util.*;
class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        int cnt = 0, sum = 0;

        // 섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)
        for(int sco : scoville) pq.add(sco);

        while(pq.peek() < K) {
            if( pq.size() <= 1) {
                return -1;
            }
          sum = pq.poll()+(pq.poll()*2);
            pq.add(sum);
            answer++;
        }

        for(int i : pq) {
            if(i<K) answer = -1;    
        }
        return answer;
    }
}

→ 이 문제는 거의 다 풀었었는데 틀려서 보니, while이 아닌 for문을 사용해서 틀린 경우

while 부분을 아래와 같이 풀었었다. 이렇게 하니 pq의 size만큼만 도니까 틀릴만도 했다 😂

for(int i=0; i<pq.size(); i++) {
    if( pq.size() <= 1) {
        answer = -1;
    }
    if(pq.peek() < K) {
        sum = pq.poll()+(pq.poll()*2);
        pq.add(sum);
        answer++;
    }
}

🔈 문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

✅ 제한사항

• prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.
• prices의 길이는 2 이상 100,000 이하입니다.

📝 입출력 예

입출력 예 설명

• 1초 시점의 ₩1은 끝까지 가격이 떨어지지 않았습니다.
• 2초 시점의 ₩2은 끝까지 가격이 떨어지지 않았습니다.
• 3초 시점의 ₩3은 1초뒤에 가격이 떨어집니다. 따라서 1초간 가격이 떨어지지 않은 것으로 봅니다.
• 4초 시점의 ₩2은 1초간 가격이 떨어지지 않았습니다.
• 5초 시점의 ₩3은 0초간 가격이 떨어지지 않았습니다.

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int[] solution(int[] prices) {
        int[] answer = new int[prices.length];
        Stack<Integer> stk = new Stack<>(); // 얼마나 버티고 있는지 체크하기 위해서

        for(int i=0; i<prices.length; i++){
            while(!stk.isEmpty() && prices[i] < prices[stk.peek()]){
                answer[stk.peek()] = i-stk.peek();
                stk.pop();
            }
            stk.push(i);
        }

        while(!stk.isEmpty()){
            answer[stk.peek()] = prices.length-stk.peek()-1;
            stk.pop();
        }
        return answer;
    }
}

→ 처음에는 간단하게 이중 for문으로 풀어봤으나, 이렇게 풀면 시간복잡도 선에서 좋지 않다길래 스택/큐 분야에 있으니 스택으로 어떻게 풀었나 찾아보았다.

처음에 스택으로 푼 것을 이해하는것이 어려웠다.
결론은 prices[stk.peek()] 하는 과정이 stk에 인덱스가 들어가있으니 지금 인덱스와 peek 한 인덱스 배열의 값을 확인하고 인덱스 차이를 통해 유지한 시간을 파악하는 것이였다.

많은 똑똑한 분들의 코드를 보며 배워나가는 것 같다 ❗

참고 2중 for문 풀이

class Solution {
    public int[] solution(int[] prices) {
        int len = prices.length;
        int[] answer = new int[len];
        int i, j;
        for (i = 0; i < len; i++) {
            for (j = i + 1; j < len; j++) {
                answer[i]++;
                if (prices[i] > prices[j])
                    break;
            }
        }
        return answer;
    }
}

💡 참고한 블로그 https://girawhale.tistory.com/7 https://velog.io/@geesuee/프로그래머스-주식가격자바 ( 이 분도 위에 블로그를 보셨다고 하셨다 )

🔈 문제 설명

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.
예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

따라서, 모든 트럭이 다리를 지나려면 최소 8초가 걸립니다.
solution 함수의 매개변수로 다리에 올라갈 수 있는 트럭 수 bridge_length, 다리가 견딜 수 있는 무게 weight, 트럭 별 무게 truck_weights가 주어집니다. 이때 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 return 하도록 solution 함수를 완성하세요.

✅ 제한 조건

• bridge_length는 1 이상 10,000 이하입니다.
• weight는 1 이상 10,000 이하입니다.
• truck_weights의 길이는 1 이상 10,000 이하입니다.
• 모든 트럭의 무게는 1 이상 weight 이하입니다.

📝 입출력 예

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int answer = 0;
        Queue<Integer> que = new LinkedList<>();
        int time = 0, sum = 0;

        /* 1. 다리에는 최대 bridge_length 대수만큼 올라갈 수 있다.
         * 2. 최대 올라갈 수 있는 크기는 weight 만큼이다.
         * 3. 한 대당 다리를 지나는 시간은 bridge_length(초)만큼이다.
         */

        for(int truck : truck_weights) {
            while(true) {
                if(que.isEmpty()) {
                    que.add(truck);
                    sum+=truck;
                    time++;
                    break;
                }
                else if(que.size() == bridge_length) {
                    sum-=que.poll();
                }else {
                    if(sum+truck <= weight) {
                        que.add(truck);
                        sum+=truck;
                        time++;
                        break;
                    }else {
                        time++;
                        que.add(0);    // 다른 트럭이 들어오려고 할 때 무게가 넘는다면 0을 넣어 다리를 건너가게 만들음
                    }
                }
            }
        }
        answer = time+bridge_length;
        return answer;
    }
}

💡 참고 풀이 https://minhamina.tistory.com/241

time을 더해주고, 트럭의 무게를 더해주고 이거까지는 생각했으나 뭔가 큰 그림을 쫙 그리려니 머리가 돌아가다가 멈췄던 것 같다 ^^;

항상 대충 이렇게 ~ 라는 생각은 드는데 막상 짜는 중에 중간에 헷갈리는 것 같다.

나중에 다시 한번 풀어보면 ,, 그 땐 다르지 않을까 라는 생각으로 일단 한번 더 풀어봐야겠다.

문제 설명

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다.
이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

1. 인쇄 대기목록의 가장 앞에 있는 문서(J)를 대기목록에서 꺼냅니다.
2. 나머지 인쇄 대기목록에서 J보다 중요도가 높은 문서가 한 개라도 존재하면 J를 대기목록의 가장 마지막에 넣습니다.
3. 그렇지 않으면 J를 인쇄합니다.

예를 들어, 4개의 문서(A, B, C, D)가 순서대로 인쇄 대기목록에 있고 중요도가 2 1 3 2 라면 C D A B 순으로 인쇄하게 됩니다.
내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 알고 싶습니다. 위의 예에서 C는 1번째로, A는 3번째로 인쇄됩니다.
현재 대기목록에 있는 문서의 중요도가 순서대로 담긴 배열 priorities와 내가 인쇄를 요청한 문서가 현재 대기목록의 어떤 위치에 있는지를 알려주는 location이 매개변수로 주어질 때, 내가 인쇄를 요청한 문서가 몇 번째로 인쇄되는지 return 하도록 solution 함수를 작성해주세요.

✅ 제한사항

• 현재 대기목록에는 1개 이상 100개 이하의 문서가 있습니다.
• 인쇄 작업의 중요도는 1~9로 표현하며 숫자가 클수록 중요하다는 뜻입니다.
• location은 0 이상 (현재 대기목록에 있는 작업 수 - 1) 이하의 값을 가지며 대기목록의 가장 앞에 있으면 0, 두 번째에 있으면 1로 표현합니다.

📝 입출력 예

입출력 예 설명

예제 #1 문제에 나온 예와 같습니다.

예제 #2 6개의 문서(A, B, C, D, E, F)가 인쇄 대기목록에 있고 중요도가 1 1 9 1 1 1 이므로 C D E F A B 순으로 인쇄합니다.

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        for(int num : priorities) {
            pq.add(num);
        }
        while(!pq.isEmpty()) {
            for(int i=0; i<priorities.length; i++) {
                // 값이 일치할 경우 
                if(priorities[i] == pq.peek()) {
                    pq.poll();
                    answer++;
                    // 인덱스도 동일할 경우
                    if(i == location)
                        return answer;
                }
            }
        }

        return answer;
    }
}

❗ 우선순위 큐를 써야겠다 생각은 들었으나, 내부 풀이가 헷갈린 경우.

내림차순으로 정렬한 후 배열의 값과 비교해서 값이 일치하지 않으면 뒤에까지 가고 값이 일치하면 큐에서 빼주고 +1씩 해준다.

🔈 문제 설명

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.
지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다. 캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다.아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

• 첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

• 두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.
만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요.
단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.

✅ 제한사항

• maps는 n x m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
  • n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
• maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
• 처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1 주어진 데이터는 다음과 같습니다.

캐릭터가 적 팀의 진영까지 이동하는 가장 빠른 길은 다음 그림과 같습니다.

따라서 총 11칸을 캐릭터가 지나갔으므로 11을 return 하면 됩니다.

입출력 예 #2 문제의 예시와 같으며, 상대 팀 진영에 도달할 방법이 없습니다. 따라서 -1을 return 합니다.

💛 내가 쓴 풀이

import java.util.*;
class Solution {
    public int solution(int[][] maps) {
        int answer = 0;

        // 상,좌,하,우
        int[] dx = {-1,0,1,0};
        int[] dy = {0,-1,0,1};
        // 현재 위치, 다음에 이동할 위치
        int cx = 0, cy = 0, nx = 0, ny = 0;
        int cnt = 1; // 칸 카운트
        // 갔다온 곳 체크
        boolean[][] visit = new boolean[maps.length][maps[0].length];
        Queue<Integer> que = new LinkedList<>();
        que.add(0); que.add(0);  
        visit[0][0] = true;

        while(!que.isEmpty()) {
            cx = que.poll(); 
            cy = que.poll();
            for(int i=0; i<dx.length; i++) {
                nx = cx+dx[i];
                ny = cy+dy[i];
                if(ny >= 0 && ny < maps[0].length 
                            && nx >= 0 && nx < maps.length && maps[nx][ny] == 1) {
                    que.offer(nx); que.offer(ny);
                    maps[nx][ny] = maps[cx][cy]+1;
                    visit[nx][ny] = true;
                }
            }
        }
        answer = maps[maps.length-1][maps[0].length-1];
        if(maps[maps.length-1][maps[0].length-1] == 1) answer = -1;
        return answer;
    }
}

DFS/BFS는 좀 헷갈려서 다른 블로그들을 많이 참고하면서 배웠다. 아직도 헷갈리지만 DFS/BFS 문제 많이 풀면서 알아나가야겠다 😥

💡 참고 블로그 → https://arinnh.tistory.com/50 (참고한 풀이법) → https://yummy0102.tistory.com/321

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.
또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.
먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

✅ 제한 사항

• 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

📝 입출력 예

입출력 예 설명

입출력 예 #1
첫 번째 기능은 93% 완료되어 있고 하루에 1%씩 작업이 가능하므로 7일간 작업 후 배포가 가능합니다.두 번째 기능은 30%가 완료되어 있고 하루에 30%씩 작업이 가능하므로 3일간 작업 후 배포가 가능합니다. 하지만 이전 첫 번째 기능이 아직 완성된 상태가 아니기 때문에 첫 번째 기능이 배포되는 7일째 배포됩니다.세 번째 기능은 55%가 완료되어 있고 하루에 5%씩 작업이 가능하므로 9일간 작업 후 배포가 가능합니다.

따라서 7일째에 2개의 기능, 9일째에 1개의 기능이 배포됩니다.

입출력 예 #2
모든 기능이 하루에 1%씩 작업이 가능하므로, 작업이 끝나기까지 남은 일수는 각각 5일, 10일, 1일, 1일, 20일, 1일입니다. 어떤 기능이 먼저 완성되었더라도 앞에 있는 모든 기능이 완성되지 않으면 배포가 불가능합니다.

따라서 5일째에 1개의 기능, 10일째에 3개의 기능, 20일째에 2개의 기능이 배포됩니다.

💛 내가 쓴 풀이

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        int[] answer;
        int chk = 0, count = 0, k = 0;
        ArrayList<Integer> arr = new ArrayList<>();

        while(true){
            // 값을 더해주는 부분
            for(int i=chk; i<progresses.length; i++){
                progresses[i]=progresses[i]+speeds[i];
            }
            // 값을 체크하는 부분
            count = 0;
            for(int j=chk; j<progresses.length; j++){
                if(progresses[j] < 100){
                    break;
                }else{
                    count++;
                }
            }

            // count = 0 or count 1 이상 -> 하루에 빠지는 progress의 개수
            if(count != 0) {
                arr.add(count);
                chk += count;
            }
            if(chk == progresses.length) break;
        }

        answer = new int[arr.size()];
        for(int num : arr) answer[k++] = num;

        return answer;
    }
}

💡 결론은 chk는 이미 센거는 셀 필요가 없으니까 지점 체크를 하기 위한 것이고, count는 arr에 개수를 집어넣기 위해 세는 것

👍 나중에 한 번 더 풀어본 풀이

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        int[] answer;
        Queue<Integer> que = new ArrayDeque<>();

        ArrayList<Integer> arr = new ArrayList<>();
        int cnt = 0, k = 0;
        int flag = 0;
        for(int i=0; i<progresses.length; i++) {
            que.add(i);
        }

        while(!que.isEmpty()) {
            flag = que.peek();
            for(int i=flag; i<progresses.length; i++) {
                progresses[i]+=speeds[i];
            }

            for(int i=flag; i<progresses.length; i++) {
                if(progresses[i] < 100) {
                    break;
                }
                else {
                    que.poll();
                    cnt++;
                }
            }
            if(cnt > 0) {
                arr.add(cnt);
                cnt = 0;
            }
        }

            answer = new int[arr.size()];
            for(int ar : arr) {
                answer[k++] = ar;
            }
            return answer;
      }
}

❗ 처음에 풀 때는 약간 긴가민가한 상태로 풀이 제출을 했는데, 그게 거슬려서 완벽하게 체득하려고 한 번 더 다시 풀었다. 다시 한번 푸니까 그래도 낫다.

🔈 문제 설명

배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다.

예를 들면,

• arr = [1, 1, 3, 3, 0, 1, 1] 이면 [1, 3, 0, 1] 을 return 합니다.
• arr = [4, 4, 4, 3, 3] 이면 [4, 3] 을 return 합니다.

배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

✅ 제한사항

• 배열 arr의 크기 : 1,000,000 이하의 자연수
• 배열 arr의 원소의 크기 : 0보다 크거나 같고 9보다 작거나 같은 정수

📝 입출력 예

입출력 예 설명

입출력 예 #1,2 문제의 예시와 같습니다.

💛 내가 쓴 풀이

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        int[] answer;
        int cnt = 0;
        Deque<Integer> deq = new ArrayDeque<>();

        for(int i : arr) {
            if(deq.isEmpty()) deq.add(i);

            if(deq.peekLast() == i) {
                continue;
            }else {
                deq.add(i);
            }
        }

        answer = new int[deq.size()];

        while(!deq.isEmpty()) {
            answer[cnt++] = deq.pollFirst();
        }
        return answer;
    }
}

😥 처음에는 queue를 사용했다가 deque로 돌리니까 똑같은 로직으로 해도 됐다. 스택/큐 문제는 너무 오랜만에 풀어서 헷갈렸었다. 마지막쪽에 집어넣으면서 같은게 이미 있으면 패스하고 없으면 넣는 것 ❗

🔈 문제 설명

스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다. 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.

1. 속한 노래가 많이 재생된 장르를 먼저 수록합니다.
2. 장르 내에서 많이 재생된 노래를 먼저 수록합니다.
3. 장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.

노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요.

✅ 제한사항

• genres[i]는 고유번호가 i인 노래의 장르입니다.
• plays[i]는 고유번호가 i인 노래가 재생된 횟수입니다.
• genres와 plays의 길이는 같으며, 이는 1 이상 10,000 이하입니다.
• 장르 종류는 100개 미만입니다.
• 장르에 속한 곡이 하나라면, 하나의 곡만 선택합니다.
• 모든 장르는 재생된 횟수가 다릅니다.

📝 입출력 예

입출력 예 설명

classic 장르는 1,450회 재생되었으며, classic 노래는 다음과 같습니다.

• 고유 번호 3: 800회 재생
• 고유 번호 0: 500회 재생
• 고유 번호 2: 150회 재생

pop 장르는 3,100회 재생되었으며, pop 노래는 다음과 같습니다.

• 고유 번호 4: 2,500회 재생
• 고유 번호 1: 600회 재생

따라서 pop 장르의 [4, 1]번 노래를 먼저, classic 장르의 [3, 0]번 노래를 그다음에 수록합니다.

• 장르 별로 가장 많이 재생된 노래를 최대 두 개까지 모아 베스트 앨범을 출시하므로 2번 노래는 수록되지 않습니다.
  ### 💛 내가 쓴 풀이 ```java import java.util.*;

class Solution { static HashMap<Integer, Integer> map2; // 위 hashmap value에 집어넣기 위한 hashmap public int[] solution(String[] genres, int[] plays) { int[] answer;

    ArrayList<Integer> arr = new ArrayList<>();
    List<String> genres_key; // 장르별 내림차순 키
    List<Integer> playes_key;
    int cnt = 0, c = 0;
    // 장르 (장르의 총 재생횟수)
    HashMap<String, Integer> genres_map = new HashMap<>();

    /* 
     * 장르 별 재생 수 (인덱스로 저장) 
     * 저장 예시 playes_map ("classic", (0, 500)~~~) 
     */         
    HashMap<String, HashMap<Integer, Integer>> playes_map = new HashMap<>();
    HashMap<Integer, Integer> map; // 위 hashmap value에 집어넣기 위한 hashmap

    for(int i=0; i<genres.length; i++) {
        genres_map.put(genres[i], genres_map.getOrDefault(genres[i], 0)+plays[i]);
        if(!playes_map.containsKey(genres[i])){
            map = new HashMap<>();
            map.put(i, plays[i]);
            playes_map.put(genres[i], map);
        }else {
            playes_map.get(genres[i]).put(i, plays[i]);
        }
    }

    genres_key = new ArrayList<>(genres_map.keySet());

    // 정렬 순서 
    // 1. 먼저 genres_map에서 가장 큰 값을 가진 장르를 구한다.
    genres_key.sort(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return genres_map.get(o2) - genres_map.get(o1);
        }
    });

    // 2. 그 다음 playes_map에서 그 장르의 value값인 map을 갖고온다.
    for(String one : genres_key) {
        cnt = 0;
        map2 = playes_map.get(one);    
        playes_key = new ArrayList<>(map2.keySet());
        // 1. 먼저 genres_map에서 가장 큰 값을 가진 장르를 구한다.
        playes_key.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return map2.get(o2) - map2.get(o1);
            }
        });

        for(int n : playes_key) {
            if(cnt == 2) break;
            arr.add(n);
            cnt++;
        }
    }

    answer = new int[arr.size()];

    for(int n : arr){
        answer[c++]  = n;
    }
    return answer;
}

}

>💡 이해하는데 도움을 받은 블로그
https://jisunshine.tistory.com/169
https://velog.io/@kimmjieun/프로그래머스-베스트앨범-Java-자바

이 문제 풀면서 Lv.3를 처음 풀어봤는데 너무 헷갈렸다.
그나마 해시문제가 제일 쉬웠어서 도전 해봤는데, 역시나 힘들게 풀었다 😥
그래도 이 문제 풀면서 정렬에 대해서 많이 알게되었다.

앞으로 많이 풀어봐야겠다 ❗