흰색기린

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/178871

Think🤔

1등부터 3등

mumu soe poe

soe 를 불렀으면 soe가 mumu를 추월

soe mumu poe

callings의 배열만큼 돈다.

그럼 추월이 끝난거니깐 .. 

일단 규칙을 찾기 위해 테스트 케이스를 하나 더 생각해보면서 패턴을 파악한다.

무무 , 소 , 포 , 카이 , 마인 이런식으로 있음

카이

무무 소 카이 포 마인

카이

무무 카이 소 포 마인

마인 

무무 카이 소 마인 포

마인

무무 카이 마인 소 포

무무 소 포 카이 마인

무무 카이 마인 소 포 

그럼 만약에 무무 소 포 카이 마인 이였을 경우

카이 마인 포 소 무무 이런식으로 한번 불렀을 때

무무 소 포 카이 마인

카이

무무 소 카이 포 마인

마인

무무 소 카이 마인 포

포

무무 소 카이 포 마인

소

소 무무 카이 포 마인

무무

무무 소 카이 포 마인

마인 포 소 무무 카이 이면?

무무 소 포 카이 마인

마인

무무 소 포 마인 카이

포

무무 포 소 마인 카이

소

무무 소 포 마인 카이

무무 ? 가 나올수 없음

흠 규칙이 잘 안보이는데

불러진 횟수를 만약 HashMap으로 카운트해서 받는다고 치자

처음 등수를 먼저 가지고있고,

1등 무무 2등 소 3등 포 4등 카이 5등 마인

                                           -2         -2

카이 2번 , 마인 2번 나왔으면?

카이가 올라옴? ... 이러면 이쪽에서는 규칙 찾기가 쉽지 않다..

그럼 다른 방법으로 해보자

일단 반복문은 callings을 돌린다.

HashMap으로 처음 등수를 저장한다.

그리고 "mumu" , "1" 이런식 1등인데 만약 2등이 찍히면 -1 값에는 mumu에서 +를 해주고 , 해당 값은 -를 해준다.

import java.util.HashMap;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = players;
        
        HashMap<String, Integer> map = new HashMap();
        for(int i=0; i<players.length; i++){
            map.put(players[i],i+1); 
        }
        
        for(int i=0; i<callings.length; i++){
            
            String nP = callings[i]; // [kai]
            int nPRank = map.get(nP) - 1; // 현재 nP의 위치
            String hP = players[nPRank-1]; // [kai 앞인 poe]
            
            players[nPRank-1] = nP;
            players[nPRank] = hP;
            map.put(nP, nPRank);
            map.put(hP, nPRank+1);
        }
        
        return answer;
    }
}

Solution✍

import java.util.HashMap;

class Solution {
    public String[] solution(String[] players, String[] callings) {
        String[] answer = players;
        
        HashMap<String, Integer> map = new HashMap();
        for(int i=0; i<players.length; i++){
            map.put(players[i],i+1); 
        }
        
        for(int i=0; i<callings.length; i++){
            
            String nP = callings[i]; // [kai]
            int nPRank = map.get(nP) - 1; // 현재 nP의 위치
            String hP = players[nPRank-1]; // [kai 앞인 poe]
            
            players[nPRank-1] = nP;
            players[nPRank] = hP;
            map.put(nP, nPRank);
            map.put(hP, nPRank+1);
        }
        
        return answer;
    }
}

Review🤩

HashMap을 이용해서 푸니깐 바로 풀어졌다. 

players의 등수도 계속 바꿔줘야함 !

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/250125

Think🤔

문제 파악 30분 동안 먼저

하나를 2차원 배열해서 정한 후 그 주변을 검사 하는 것

처음에 일단 인덱스 값들을 나열해 보았음

00 01 02 03

10 11 12 13

20 21 22 23

30 31 32 33

그럼 이 인덱스값들 중

이 가운데 부분들은 상 하 좌 우 4군데의 색깔을 검사해주면 되고 

이 뒤가 0인 부분들은 왼쪽을 빼서 검사 하면 된다.

뒤에가 마지막인 경우 , 앞에가 마지막인 경우 , 처음이 0인 경우 각각 

오른쪽 검사 X , 아래쪽 검사 X , 위쪽 검사 X

이렇게 IF문으로 걸러주면 된다 기본값은 4방향 다 검사하는 것

class Solution {
    public int solution(String[][] board, int h, int w) {
            int answer = 0;

            String pick = board[h][w]; // 선택한 색
            int bF = 0; // 처음 무조건 0 
            int bL = board.length; // 마지막은 길이
            System.out.println("pick :" + pick + ", bF = " + bF + ", bL : " + bL);
                    
            if(h == bF){ // 위에 검사 x
                
                if(pick.equals(board[h+1][w])){
                    answer++;
                }
                if(pick.equals(board[h][w-1])){
                    answer++;
                }
                if(pick.equals(board[h][w+1])){
                    answer++;
                }
            }
        
            if(h == bL){ // 아래 검사 x
                if(pick.equals(board[h-1][w])){
                    answer++;
                }
                if(pick.equals(board[h][w-1])){
                    answer++;
                }
                if(pick.equals(board[h][w+1])){
                    answer++;
                }
            }
        
            if(w == bF){ // 왼쪽 검사 x
                if(pick.equals(board[h-1][w])){
                    answer++;
                }
                if(pick.equals(board[h+1][w])){
                    answer++;
                }
                if(pick.equals(board[h][w+1])){
                    answer++;
                }
            }
        
            if(w == bL){ // 오른쪽 검사 x
                if(pick.equals(board[h-1][w])){
                    answer++;
                }
                if(pick.equals(board[h+1][w])){
                    answer++;
                }
                if(pick.equals(board[h][w-1])){
                    answer++;
                }
            }
        
            if(h != bF && h != bL && w != bF && w != bL){
                if(pick.equals(board[h-1][w])){
                    answer++;
                }
                if(pick.equals(board[h+1][w])){
                    answer++;
                }
                if(pick.equals(board[h][w-1])){
                    answer++;
                }
                if(pick.equals(board[h][w+1])){
                    answer++;
                }
            }
                    
        return answer;
    }
}

효율적으로 반복문을 돌려서 IF로 넘어가주고 PLUS 해주는 느낌인데 생각이 안나서 그냥 막 적었다.

이렇게 하니 몇몇 테스트 에서 실패(런타임 에러)가 뜸

h,w가 0일수도 있음 조건에 0 <= h,w < board 이렇게 되어 있음

이렇게 모든 경우를 검사하는 방법 말고 문제에 나와 있는대로 코드를 작성해보자

class Solution {
    public int solution(String[][] board, int h, int w) {
        int answer = 0;
        int n = board.length; // 1번
        // 정수 리스트 h와 w의 변화량을 저장할 정수 리스트
        
        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])){
                    answer++;
                }
            }
        }
        
        return answer;
    }
}

의사 코드대로 작성하니 바로 풀 수 있었다..

Solution✍

class Solution {
    public int solution(String[][] board, int h, int w) {
        int answer = 0;
        int n = board.length; // 1번
        // 정수 리스트 h와 w의 변화량을 저장할 정수 리스트
        
        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])){
                    answer++;
                }
            }
        }
        
        return answer;
    }
}

Review🤩

어떻게 이런 생각을 ... 흠흠

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/155652

Think🤔

class Solution {
    public String solution(String s, String skip, int index) {
        String answer = "";
        return answer;
    }
}

s에 있는 값 "aukks" 이고

skip에 있는 값 "wbqd"

index는 5

result happy가 나와야 한다.

s에 있는 값을 각 글자에 더해주는데 skip에 있는 값이 나오면 그 값은 바로 무시해주고 다음 문자로 넘어간다.

a -> b -> c -> d -> e -> f 이렇게 하면 5번인데 

a -> b -> c -> d -> e -> f -> g -> h , skip에 단어 b와 d가 있으므로 그 값은 건너뛰어준다.

u -> v -> w -> x -> y - > z -> a , 다시 a로

이런식으로 바꿔주면 됨.

class Solution {
    public String solution(String s, String skip, int index) {
        String answer = "";
        
        for(int i=0; i<s.length(); i++){
            char ch = s.charAt(i);
            int cnt = index; // cnt에 5 들어감
            while(cnt > 0){
                if(skip.contains(String.valueOf(ch)) == true){
                    ch++;
                } else{
                    ch++;
                    cnt--;
                }
                
                if(ch == '{'){
                    ch-=26;
                } 
            }
            answer += ch;
        }
                
        return answer;
    }
}

한 2~3개 밖에 통과를 안함.

반복문 돌려서 'z'가 될 경우 ASCII 코드로는 123이니깐 그럴 경우 소문자 a로 다시가게 26을 빼줬는데 안됨.

질문하기에 반례를 참고해서 테스트 케이스에 추가

입력값 〉 "bcdefghijklmnopqrstuvwxyz", "a", 1
기댓값 〉 "cdefghijklmnopqrstuvwxyzb"

입력값 〉 "klmnopqrstuvwxyz", "abcdefghij", 20
기댓값 〉 "opqrstuvwxyzklmn"

마지막 경계값에서 z -> a로 변환하는 순간 z는 skip에 안걸려서 a로 변환시키고 끝나는데

skip을 해서 [ K ] 값이 나와야 함 [ A] 가 아닌

klmnopqrstuv[w]xyz
opqrstuvwxyz[a]lmn
opqrstuvwxyz[k]lmn

class Solution {
    public String solution(String s, String skip, int index) {
        String answer = "";
        
        for(int i=0; i<s.length(); i++){
            char ch = s.charAt(i);
            
            for(int j=0; j<index; j++){
                ch++;
                
                if(ch == '{'){
                    ch -= 26;
                }
                
                if(skip.contains(String.valueOf(ch))){
                    j--;
                }
            }
            
            answer += ch;
        }
                
        return answer;
    }
}

처음에 하려던 j--방법을 이용해서 한다 통과

Solution✍

class Solution {
    public String solution(String s, String skip, int index) {
        String answer = "";
        
        for(int i=0; i<s.length(); i++){
            char ch = s.charAt(i);
            
            for(int j=0; j<index; j++){
                ch++;
                
                if(ch == '{'){
                    ch -= 26;
                }
                
                if(skip.contains(String.valueOf(ch))){
                    j--;
                }
            }
            
            answer += ch;
        }
                
        return answer;
    }
}

Review🤩

경계값 테스트의 중요성을 깨달음

최소값 , 최대값 , 중간값 등의 특별한 경우 주로 테스트 

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/160586

Think🤔

LV0을 푸는데 너무 쉬워서 LV1로 넘어왔습니다.

주어지는 인자값은 

String [] keymap 여기서 인자값이 "ABACD" 인 경우 한번 누르면 맨 처음 A , 두번은 B 이런식

String [] targets 이 요소는 "AABB" 이런식으로 들어가 있는데 , 

keymap에 있는 키를 가지고 targets의 문자를 최소로 눌러서 작성 하는 것

그러면 "ABACD" , "BCEFD" 라는 키가 있으면 "ABCD"는

A는 1번키에서 한번 누르면 되니깐 여기서 1

B는 2번키에서 한번 누르면 되니깐 여기서 1

C는 2번키에서는 두번 누르면 되니깐 여기서 2(1번키에서는 C를 누르려면 총 4번을 눌러야 하기때문에 2번)

D는 둘다 5번씩 눌러야 되니깐 여기서 누르면 됨

이거를 이제 생각해보면

targets에 있는 요소들을 하나씩 처리해야 되니깐 일단 첫번째 요소를 가져와서

keymap에 매칭해보면서 더 가까이에 있는 keymap을 이용해서 정답에 +를 해준 후 반환하면 된다.

3중 for문으로 하려했으나 너무 비효율적이고 keymap의 크기와 targets의 길이가 각각 100개인 점

100의 제곱인 10000번을 돌 수 있기 떄문에 이 방법말고 다른 방법을 참조해서 해보기로 한다.

HashMap을 사용해서 푸신 분들을 참조하여 적용해보기로 했다.

HashMap을 이용해서 하면 Character형과 int형을 이용해서 해당 문자열의 값이 작은 키 패드를 먼저 만들 수 있기 떄문

반복문을 이용해서 대충 만든 자판을 조합하여 새로운 자판을 만든다.

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

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        int[] answer = new int[2];
        
        HashMap<Character,Integer> hs = new HashMap();
        
        for(String s : keymap){
            for(int i=0; i<s.length(); i++){
                hs.put(s.charAt(i) , Math.min(hs.get(s.charAt(i)) , hs.getOrDefault(s.charAt(i) , i)));
            }
        }
        
        return answer;
    }
}

여기까지 작성했는데 npe가 발생한다.. 뭐가 문젠지?

가독성을 위해 s.charAt(i) 는 일단 변수처리하는게 좋아보인다.

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

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        int[] answer = new int[2];
        
        HashMap<Character,Integer> hs = new HashMap();
        
        for(String s : keymap){
            for(int i=0; i < s.length(); i++){
                char key = s.charAt(i);
                
                hs.put(key , Math.min(hs.getOrDefault(key , Integer.MAX_VALUE) , i+1));
            }
        }

        System.out.print(hs);
        
        return answer;
    }
}

npe가 발생하는 이유는 hs.get으로 가져올려고 하나 그 값이 존재하지 않아서 못가져오기 때문이다.

그럼 해당 코드를 수정해서 만약에 값이 없어서 가지고 오지 못하면 지금의 값을 넣어주고

못가져오면 제일 큰 값 Integer.MAX_VALUE값을 넣어 현재의 숫자를 넣어주게 Math.min을 이용한다.

여기 까지 하면 일단 hs는 새로운 자판이 되었다.

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

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        int[] answer = new int[targets.length];
        
        HashMap<Character,Integer> hs = new HashMap();
        
        for(String s : keymap){
            for(int i=0; i < s.length(); i++){
                char key = s.charAt(i);
                
                hs.put(key , Math.min(hs.getOrDefault(key , Integer.MAX_VALUE) , i+1));
            }
        }
        
        for(int i=0; i<targets.length; i++){
            int cnt = 0;
            for(int j=0; j<targets[i].length(); j++){
                char key = targets[i].charAt(j);
                if(hs.containsKey(key)){
                    cnt += hs.get(key);
                }
            }
            
            if(cnt == 0){
                answer[i] = -1;
            }else{
                answer[i] = cnt;
            }
            
        }
        
        return answer;
    }
}

이렇게 하니 테스트 14~23번은 전부 실패한다...

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

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        int[] answer = new int[targets.length];
        
        HashMap<Character,Integer> hs = new HashMap();
        
        for(String s : keymap){
            for(int i=0; i < s.length(); i++){
                char key = s.charAt(i);
                
                hs.put(key , Math.min(hs.getOrDefault(key , Integer.MAX_VALUE) , i+1));
            }
        }
        
        for(int i=0; i<targets.length; i++){
            int cnt = 0;
            for(int j=0; j<targets[i].length(); j++){
                char key = targets[i].charAt(j);
                if(hs.containsKey(key)){
                    cnt += hs.get(key);
                }else{
                    cnt = 0;
                    break;
                }
            }
            
            if(cnt == 0){
                answer[i] = -1;
            }else{
                answer[i] = cnt;
            }
            
        }
        
        return answer;
    }
}

입력값 〉 ["BC"], ["AC", "BC"]
기댓값 〉 [-1, 3]

테스트 케이스를 추가하고 , 다른 반례를 이용해서 예외를 추가 하였다.

단어중에 누르는거만 생각했지 없는 값이 있으면 바로 끝내줘야 한다.

Solution✍

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

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        int[] answer = new int[targets.length];
        
        HashMap<Character,Integer> hs = new HashMap();
        
        for(String s : keymap){
            for(int i=0; i < s.length(); i++){
                char key = s.charAt(i);
                
                hs.put(key , Math.min(hs.getOrDefault(key , Integer.MAX_VALUE) , i+1));
            }
        }
        
        for(int i=0; i<targets.length; i++){
            int cnt = 0;
            for(int j=0; j<targets[i].length(); j++){
                char key = targets[i].charAt(j);
                if(hs.containsKey(key)){
                    cnt += hs.get(key);
                }else{
                    cnt = 0;
                    break;
                }
            }
            
            if(cnt == 0){
                answer[i] = -1;
            }else{
                answer[i] = cnt;
            }
            
        }
        
        return answer;
    }
}

Review🤩

굳뜨

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/120819

Think🤔

쉬운 문제

Solution✍

class Solution {
    public int[] solution(int money) {
        int[] answer = new int[2];
        
        answer[0] = money / 5500;
        answer[1] = money % 5500;
        
        return answer;
    }
}

class Solution {
    public int[] solution(int money) {
        return new int[] { money / 5500 , money % 5500};
    }
}

Review🤩

쉽게 풀었음..

알고리즘 풀이 방법입니다.
문제(Problem) -> 생각(Think) -> 해결책(Solution) -> 리뷰(Review) 를 통해서 정리해서 작성합니다.

Problem📄

https://school.programmers.co.kr/learn/courses/30/lessons/120809

Think🤔

이번엔 스트림으로 풀었다.. map을 이용해서 두배만 하면 되기 때문에

Solution✍

import java.util.Arrays;

class Solution {
    public int[] solution(int[] numbers) {
        return Arrays.stream(numbers).map(answer -> answer * 2).toArray();
    }
}

Review🤩

첫 스트림 사용 성공 !!