잡다한 배똥월드

https://programmers.co.kr/learn/courses/30/lessons/12948?language=kotlin 

class Solution {
    fun solution(phone_number: String): String {
        var answer = "";
        
        var size = phone_number.length;
        for (num in 1..size-4) {
            answer += "*";
        }
        
        answer += phone_number.substring(size-4, size);
        
        return answer;
    }
}

split으로 한 칸씩 잘라서 배열 만든 후에 for문으로 번호 길이 - 4까지 *으로 바꾼 후에 joinToString으로 배열을 String으로 합친 후에 리턴하면 될 것 같다.

import java.util.*;

class Solution {
    public int solution(int[][] board, int[] moves) {
        int answer = 0;
        
        ArrayList<Queue<Integer>> map = new ArrayList<>();
        
        for (int i = 0; i < board.length; i++) {
            Queue<Integer> q = new LinkedList<>();
            
            for (int j = 0; j < board[i].length; j++) {
                if (board[j][i] == 0) continue;
                
                q.add(board[j][i]);                
            }
            
            map.add(q);
        }
        
        Stack<Integer> s = new Stack<>();
        
        for (int i = 0; i < moves.length; i++) {
            Queue<Integer> q = map.get(moves[i]-1);
            if (!q.isEmpty()) {
                int num = q.poll();
                int sNum = (!s.empty()) ? s.peek() : -1;
                
                if (sNum != -1 && num == sNum) {
                    s.pop();
                    answer += 2;
                } else {
                    s.push(num);
                }
            }
        }
        
        return answer;
    }
}

board에 들어 있는 블록을 세로 한 줄씩 정리할건데, 위에서부터 정의되어 있어서 제일 먼저 들어간 것을 꺼내는 Queue를 이용하여 정리했음.

정리한 Queue들은 ArrayList로 묶어서 map을 만들었고, moves 배열에서 하나씩 꺼내오면서 제일 마지막에 넣는 것을 꺼내는 스택으로 블록을 하나씩 넣는데, 만약 제일 위에 있는 것이 넣을 것과 같으면 스택 맨 마지막에 넣은 값을 없애고 answer에 +2를 하는 것으로 코드를 짰다.

import java.util.*;

class Solution {
    public int solution(int[][] board, int[] moves) {
        
        Stack stack = new Stack();
        
        int answer = 0;
        
        for (int i = 0; i < moves.length; i++){
            int num = moves[i] - 1;
            for (int j = 0; j < board.length; j++){
                if (board[j][num] != 0){
                    if (stack.size() != 0 && (int)stack.peek() == board[j][num]){
                        stack.pop();
                        answer += 2;
                    } else {
                        stack.push(board[j][num]);
                    }
                    
                    board[j][num] = 0;
                    break;
                    
                }
            }
        }
        
        return answer;
    }
}

class Solution {
    fun solution(arr1: Array<IntArray>, arr2: Array<IntArray>): Array<IntArray> {
        var answer = Array(arr1.size, {IntArray(arr1[0].size)});
        
        for (x in 0..arr1.size-1) {
            for (y in 0..arr1[x].size-1) {
                answer[x][y] = arr1[x][y] + arr2[x][y];
            }
        }
        return answer;
    }
}

Array 진짜 복잡하네..

2차원 배열을 선언하는 것도 자바와 달라서 어려웠다..

1차원 배열 선언은 Array(길이, {내용}) 이런 식으로 선언하는데,

2차원 배열 역시 이 모양을 그대로 사용한다.

그래서 Array(길이, {Array(길이, {내용})})으로 모양을 만들고,

자바는 길이 구할 때 length를 쓰지만 코틀린에서는 size를 쓴다.

그 외에는 비슷하고...

행렬의 덧셈은 똑같은 위치의 값들을 다 더하는 것이기 때문에 for문으로 구하면 된다.

class Solution {
    public String solution(int[] numbers, String hand) {
        StringBuilder answer = new StringBuilder();
        String[] keypad = {"l", "m", "r", "l", "m", "r", "l", "m", "r", "l", "m", "r"};
        
        int left = 9;
        int right = 11;
        
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == 0) {
                numbers[i] = 10;
            } else {
                numbers[i]--;
            }
        }
                           
        for (int i = 0; i < numbers.length; i++) {
            int num = numbers[i];
            if (keypad[num].equals("l")) {
                left = num;
                answer.append("L");
            } else if (keypad[num].equals("r")) {
                right = num;
                answer.append("R");
            } else {
                int temp = func(num, left, right);
                if (temp == 1) {
                    left = num;
                    answer.append("L");
                } else if (temp == -1) {
                    right = num;
                    answer.append("R");
                } else {
                    if (hand.equals("left")) {
                        left = num;
                        answer.append("L");
                    } else {
                        right = num;
                        answer.append("R");
                    }
                }
            }
        }
        
        return answer.toString();
    }
    
    public int func(int number, int left, int right) {
        int num = number;
        
        int l1 = (left) / 3;
        int m1 = (num) / 3;
        int r1 = (right) / 3;
        
        int l2 = (left) % 3;
        int m2 = (num) % 3;
        int r2 = (right) % 3;
        
        double lFar = Math.abs(l1 - m1) + Math.abs(l2 - m2);
        double rFar = Math.abs(r1 - m1) + Math.abs(r2 - m2);
        
        if (lFar < rFar) {
            return 1;
        } else if (lFar > rFar) {
            return -1;
        } else {
            return 0;
        }
    }
}

도움을 받은 부분은 키패드의 거리 구할 때 유클리드 거리로 구했는데, 맨하탄 거리로 구해야 한다는 것을 알게 되었다..

좌표를 만들기 위해서 키패드 숫자에서 1씩 빼고, *은 9, 0은 10, #은 11로 만들어서 아래와 같은 표로 표현할 수 있다.

그래서 각각의 위치에 좌표를 구한다면 아래의 표와 같이 표현할 수 있는데,

x 좌표는 해당 위치의 숫자를 3으로 나눈 몫이고, y 좌표는 해당 위치의 숫자를 3으로 나눈 나머지이다.

그래서 좌표 (x1, y1), (x2, y2)의 맨하탄 거리를 구한다면 |x1 - x2| + |y1 - y2|이다.

처음엔 유클리드 거리로 해서 (x1-x2)^2 + (y1-y2)^2 로 했는데,

이렇게 하니까 테스트 13부터는 계속 오답이라고 떴다.

import java.util.*;

class Solution {
    public String solution(int[] numbers, String hand) {
        boolean value = true;
        int l = 10;
        int r = 12;
        
        if (hand.equals("right")){
            value = false;
        }
        
        ArrayList<String> data = new ArrayList<>();
        
        for (int i = 0; i < numbers.length; i++){
            int a = numbers[i];
            
            if (a == 0) a = 11;
            
            boolean value2 = true;
            
            if (a == 1 || a == 4 || a == 7){
                value2 = true;
            } else if (a == 3 || a == 6 || a == 9){
                value2 = false;
            } else {
                int ll = 0;
                int rr = 0;
                int l2 = l;
                int r2 = r;
                
                while (l2 != a){
                    if (l2 - a == -1 || l2 - a == 1){
                        ll++;
                        break;
                    }
                    
                    if (l2 > a){
                        l2 -= 3;
                        ll++;
                    } else {
                        l2 += 3;
                        ll++;
                    }
                }
                
                while (r2 != a){
                    if (r2 - a == -1 || r2 - a == 1){
                        rr++;
                        break;
                    }
                    
                    if (r2 > a){
                        r2 -= 3;
                        rr++;
                    } else {
                        r2 += 3;
                        rr++;
                    } 
                }
                
                if (ll > rr) {
                    value2 = false;
                } else if (ll < rr){
                    value2 = true;
                } else {
                    value2 = value;
                }
            }
            
            if (value2){
                data.add("L");
                l = a;
            } else {
                data.add("R");
                r = a;
            }
            
        }
        
        return String.join("", data);
    }
}

class Solution {
    fun solution(x: Int, n: Int): LongArray {
        var answer = LongArray(n)

        for (num in 1..n) {
            answer[num-1] = num.toLong() * x;
        }
        return answer
    }
}

이거 하나 푸는데 array에 관한 것도 엄청 찾아봤네...

x씩 점점 커진 숫자 배열이 n 길이까지 있으니까 for문으로 이용하여 문제를 풀었는데

Array인 answer에 값을 넣는 것이 어려웠다.

longArrayOf()는 그냥 정말 말 그대로 텅 빈 long형의 Array를 뜻하는거라서 내가 계속 n으로 사이즈를 지정하려고 해도 틀렸다고 나왔고,

계속 검색해보다가 LongArray()로 만드는 것인 것을 깨닳고 코드를 짰다.

그리고 long으로 계산을 해서 넣어야하기 때문에 for문 속에서 num이나 x를 long으로 형 변환을 한 후에 계산을 했다.

(계산 후에 long으로 변환하면 틀렸나고 나오기 때문에 미리 변환 후에 하는 것이 낫다)

class Solution {
    public int solution(String s) {
        String[] word = {"zero", "one", "two", "three", "four", "five",
                        "six", "seven", "eight", "nine"};
        int answer = 0;
        String q = s;
        
        while (q.length() > 0) {
            String t = q.substring(0, 1);
            char temp = t.charAt(0);
            
            if (temp >= '0' && temp <= '9') {
                answer = answer * 10 + Integer.parseInt(t);
                q = q.substring(1, q.length());
                continue;
            }
            
            for (int j = 0; j < word.length; j++) {
                if (q.indexOf(word[j]) == 0) {
                    answer = answer * 10 + j;
                    q = q.substring(word[j].length(), q.length());
                    break;
                }
            }
            
        }
        return answer;
    }
}

음.. 일단 글자가 숫자인지를 먼저 파악하기 위해서 제일 앞 글자를 char로 바꿔서 숫자인지 파악한다.

answer에 숫자를 더하는 것은 한 번 할 때마다 자리수가 바뀌기 때문에 10을 곱한 후에 더해주는 식으로 진행하며

만약에 숫자가 아닐 경우에는 이제 String 배열에 만들어 놓은 숫자 영단어를 하나씩 비교해 가면서

해당하는 영단어가 제일 앞에서 시작되는지 안되는지를 파악하여 만들었다.

뭔가 설명이 이상하지만... 설명할 수 있는 방법이 없눼...

fun main(args: Array<String>) {
    val (a, b) = readLine()!!.split(' ').map(String::toInt)
    
    for (x in 1..b) {
        for (y in 1..a) {
            print("*");
        }
        println();
    }
}

코틀린 공부 시작..

for문 기본형 : for (요소 변수 in 컬렉션 또는 범위) { 반복할 본문 }

범위 지정은 숫자..숫자 이런 식으로 ..으로 하는 듯하고, 기본적으로 1씩 증가한다.

만약 2씩 증가하게 하고 싶다면 step 2를 뒤에 추가로 적으면 된다.

ex) for (i in 1..5 step 2) { }

그래서 a개씩 b줄로 출력하니까

바깥 for문의 범위는 b, 안쪽 for문의 범위는 a로 지정하여

안쪽 for문에서 print("*")로 별을 입력하고,

안쪽 for문이 끝나면 println()으로 줄 바꿈을 표시하여 출력하였다.

print()는 줄 바꿈 x

println()은 줄 바꿈 o

import java.util.*;

class Solution {
    public String[] solution(String[] record) {
        ArrayList<String> answer = new ArrayList<>();
        
        String[][] list = new String[record.length][2];
        HashMap<String, String> name = new HashMap<>();
        
        for (int i = 0; i < record.length; i++) {
            String[] re = record[i].split(" ");
            
            list[i][0] = re[0];
            list[i][1] = re[1];
            
            if (re[0].equals("Enter") || re[0].equals("Change")) {
                name.put(re[1], re[2]);
            } 
        }
        
        for (int i = 0; i < list.length; i++) {
            if (list[i][0].equals("Enter")) {
                answer.add(name.get(list[i][1]) + "님이 들어왔습니다.");
            } else if (list[i][0].equals("Leave")){
                answer.add(name.get(list[i][1]) + "님이 나갔습니다.");
            }
        }
        
        return answer.toArray(new String[answer.size()]);
    }
}

유저 ID는 그대로인데 이름은 변경할 수 있다.

그래서 for문으로 record를 순회할건데, 이 때 record[i]의 내용이 Enter이나 Change이면 이름을 변경될 수 있다.

그래서 유저ID에 맞게 이름을 넣기 위해서 해시맵을 사용하였고,

Enter이나 Change면 이름이 같든 다르든 그냥 변경하도록 했다.

그리고 나서 할 것이 들어왔다 나갔다 하는 문구를 적을 차례인데,

Enter면 들어왔다고, Leave면 나갔다고 문구를 적고 Change는 그냥 넘어가는 식으로 작성하였다.

import java.util.*;

class Solution {
    public String[] solution(String[] record) {
        
        HashMap<String, String> name = new HashMap<>();
        ArrayList<String> data = new ArrayList<>();
        
        for (int i = 0; i < record.length; i++){
            String[] temp = record[i].split(" ");
            
            if (temp[0].equals("Leave")){
                data.add(record[i]);
                continue;
            }
            
            if (temp[0].equals("Enter")){
                data.add(record[i]);
                name.put(temp[1], temp[2]);
                continue;
            }
            
            if (temp[0].equals("Change")){
                name.put(temp[1], temp[2]);
            }
        }
        
        String[] answer = new String[data.size()];
        
        for (int i = 0; i < data.size(); i++){
            String[] temp = data.get(i).split(" ");
            
            String st = name.get(temp[1]);
            
            StringBuilder sb = new StringBuilder(st);
            
            if (temp[0].equals("Enter")){
                sb.append("님이 들어왔습니다.");
            } else if (temp[0].equals("Leave")){
                sb.append("님이 나갔습니다.");
            }
            
            answer[i] = sb.toString();
        }
        
        return answer;
    }
}