오랜만에 코딩테스트를 풀어보았다

오랜만에 자바를 써서 그런지 코틀린의 간결함을 더욱 느낄 수 있었던 시간이었다.

1번
핸드폰 번호가 3 종류 있고, 010-xxxx-xxxx, 010xxxxxxxx, +82-10-xxxxxxxx의 3가지 형식 중 어느 형식에 속하는지를 판별하는 간단한 문제였다.

class Solution {
    public int solution(String phone_number) {
        if(isType1(phone_number)){
            return 1;
        }

        if(isType2(phone_number)){
            return 2;
        }

        if(isType3(phone_number)){
            return 3;
        }

        return -1;
    }

    private boolean isType1(String input){
        if(input.length()!=13){
            return false;
        }
        if(!input.startsWith("010-")){
            return false;
        }
        for(int index = 4;index<input.length();index++){
            char value = input.charAt(index);
            if(index==8){
                if(!isMinus(value)){
                    return false;
                }
            }
            else{
                if(!isNumber(value)){
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isType2(String input){
        if(input.length()!=11){
            return false;
        }
        if(!input.startsWith("010")){
            return false;
        }
        for(int index = 3;index<input.length();index++){
            char value = input.charAt(index);
            if(!isNumber(value)){
                return false;
            }
        }
        return true;
    }

    private boolean isType3(String input){
        if(input.length()!=16){
            return false;
        }
        if(!input.startsWith("+82-10-")){
            return false;
        }
        for(int index = 7;index<input.length();index++){
            char value = input.charAt(index);
            if(index==11){
                if(!isMinus(value)){
                    return false;
                }
            }
            else{
                if(!isNumber(value)){
                    return false;
                }
            }
        }
        return true;
    }

    private boolean isNumber(char input){
        if(input>='0' && input<='9'){
            return true;
        }
        return false;
    }

    private boolean isPlus(char input){
        return input=='+';
    }

    private boolean isMinus(char input){
        return input=='-';
    }

}

2번
숫자가 자신을 이루는 자리수 중 몇개로 나누어지는지를 구하는 문제였다. 1234의 경우 자리수는 1,2,3,4이고 이때 1234는 1,2 두 개의 수로 나누어떨어지기 때문에 2를 반환하면 되는 문제였다.

class Solution {

    private int[] validNumbers = new int[10];

    public int solution(long n) {
        int answer = 0;

        markValidNumbers(n);

        for(int number = 1;number<10;number++){
            if(validNumbers[number]==0){
                continue;
            }
            if(n%number==0){
                answer++;
            }
        }

        return answer;
    }

    private void markValidNumbers(long n){
        while(n>0){
            int modValue = (int)(n%10);
            validNumbers[modValue] = 1;
            n = n/10;
        }
    }
}

3번
주어진 년도 다음으로 년도의 자리수중 중복이 없는 년도를 구하는 문제였다. 1887이 주어진다면 1890을 반환하면 되는 문제였다.

public class Solution {
    public int solution(int p) {
        while(true){
            p++;
            if(isBeautiful(p)){
                return p;
            }
        }
    }

    private boolean isBeautiful(int n){
        int[] modNumbers = new int[10];
        for(int i = 0;i<10;i++){
            modNumbers[i] = 0;
        }
        while(n>0){
            int modNumber = n%10;
            if(modNumbers[modNumber]==1){
                return false;
            }
            n/=10;
            modNumbers[modNumber]=1;
        }
        return true;
    }
}

4번
암호를 해독한 문자열을 반환하는 문제였다. 문제 자체는 간단했지만 구현이 조금 귀찮았다.

class Solution {
    public String solution(String encrypted_text, String key, int rotation) {
        String inverseRotated = inverseRotate(encrypted_text, rotation);
        return decryptedString(inverseRotated, key);
    }

    private String inverseRotate(String text, int rotation){
        if(rotation>=0){
            return headToTailRotate(text, rotation);
        }
        else{
            return tailToHeadRotate(text, -rotation);
        }
    }

    private String headToTailRotate(String text, int rotation){
        for(int count = 0;count<rotation;count++){
            String head = text.charAt(0)+"";
            text = text.concat(head);
            text = text.substring(1, text.length());
        }
        return text;
    }

    private String tailToHeadRotate(String text, int rotation){
        text = reversedString(text);
        for(int count = 0;count<rotation;count++){
            String tail = text.charAt(0)+"";
            text = text.concat(tail);
            text = text.substring(1, text.length());
        }
        text = reversedString(text);
        return text;
    }

    private String reversedString(String text){
        StringBuffer sb = new StringBuffer(text);
        return sb.reverse().toString();
    }

    private String decryptedString(String encrypted, String key){
        String decrypted = "";
        for(int index = 0;index<encrypted.length();index++){
            String decryptedChar = decryptedChar(encrypted.charAt(index), key.charAt(index));
            decrypted = decrypted.concat(decryptedChar);
        }
        return decrypted;
    }

    private String decryptedChar(char encrypted, char key){
        int moved = (int)(encrypted-key+'a'-1);
        if(moved<(int)('a')){
            moved+=26;
        }
        return (char)moved+"";
    }
}

5번
중복으로 등장하는 숫자의 최소 거리를 구하는 문제였다. 그냥 막무가내로 구하면 시간제한을 맞추지 못하거나 구현이 귀찮아질 것이므로 약간의 메모이제이션을 사용했다.

import java.util.*;

class Solution {
    public int solution(int[] arr) {
        int minDistance = arr.length;
        HashMap<Integer, Integer> distanceMap = new HashMap<Integer, Integer>();

        for(int index = 0;index<arr.length;index++){
            int value = arr[index];
            if(distanceMap.containsKey(value)){
                minDistance = Math.min(minDistance, index-distanceMap.get(value));
            }
            distanceMap.put(value, index);
        }

        if(minDistance == arr.length){
            return -1;
        }
        return minDistance;
    }
}