잡다한 배똥월드

class Solution {
    fun solution(arr: IntArray): Double {
        var answer = 0.0;
        
        for (i in 0..arr.size - 1){
            answer += arr[i];
        }
        return answer / arr.size;
    }
}

배열 값 중에 0이 있을려나 걱정했는데 다행히 없었고,

그냥 배열 값들 다 더해주고, 배열 길이로 나누면 되는 문제.

코틀린에서는 따로 double형으로 변수 선언하는 것이 아니라 var로 통합해버리니까

answer이 double 이라는 것을 인식(?)하기 위해서 첫 선언 때 0이 아닌 0.0으로 선언함.

class Solution {
    fun solution(x: Int): Boolean {
        var xString = x.toString().chunked(1);
        
        var num = 0;
        for (i in 0..xString.size-1) {
            num += Integer.parseInt(xString[i]);
        }
        
        return if (x % num == 0) true else false; 
    }
}

코틀린에서 문자열을 배열로 만드는 방법으론 split과 chunked 두 가지의 함수가 있다.

근데 자바와 같이 split("")은 계속 오류가 나서 코틀린에서는 구분자를 제대로 넣어야 진행할 수 있는 것 같고, 그래서 chunked(길이)를 이용하여 배열로 만들었다.

그리고 리턴할 때 역시 코틀린은 삼항 연산자가 없어서 x % num == 0 ? true : false 가 오류가 났고,

삼항 연산자를 쓸 수 없다는 것을 알게 되서 if (x % num == 0) true else false; 로 표현하였다.

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 배열에 만들어 놓은 숫자 영단어를 하나씩 비교해 가면서

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

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