TIL 2024-11-27

오늘부터 과제가 주어졌다.

공부하고 정리할 것들이 밀렸고 과제할 만큼 정리가 되지 않았는데 또 쌓였다.

MSA 정리하면서 Spring 정리하고 과제도 제출해야지.

부트캠프 시작하기 한 달 전에 다른 것들 공부할게 아니라

Spring을 정리했어야 했다는 후회가 든다.

할 게 많아서 좋으면서도 벌려놓고 내 것으로 만들어 회수하지 못해서 아쉬울 따름이다.

알고리즘도 있구나..

좀더 알차게 시간을 써야겠다ㅠ

 

여기에 적을 내용이 많지만 어제 막혔던 알고리즘을 해결을 해서 기록하기로 하고 

이어서 공부하러 가기로 해야겠다.

어려운 문제는 아니지만 sort를 커스텀하는 부분을 아직 정리가 안 되어서

지금 알고 있는 내용들로 해결을 해보려고 한다.

 

알고리즘 문제는 

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

프로그래머스

이고

 

해결을 못 했던 코드 2가지

import java.util.*;

class Solution {
    public String[] solution(String[] strings, int n) {
        int[] counts = new int[26];	// 각 원소는 'a' ~ 'z'에 해당하는 값의 개수 
        int arrayLength = strings.length;
        String[] answer = new String[arrayLength];
        if (arrayLength == 1){
            answer = strings;
            return answer;
        }
        
        String temp_string;
        for (int i = 0; i < arrayLength; i++){
            temp_string = strings[i] + strings[i];
            temp_string = temp_string.substring(n);
            counts[strings[i].charAt(0) - 'a']++;
            strings[i] = temp_string;
        }
        
        Arrays.sort(strings);
        
        for (int i = 0; i < arrayLength; i++){
            answer[i] = strings[i].substring((strings[i].length()+n) / 2 - n);
        }
        
        int count = 0;	// strings의 인덱스를 다룰 변수
        for (int i = 0; i < counts.length; i++){
            if ( counts[i] <= 1) {
            	count += counts[i];
                continue;
            }
            
            for( int j=count; j< count+counts[i]-1; j++){
            	for( int k=j+1; k< count+counts[i]; k++){
                    System.out.println(answer[j] + " " + answer[k]);
                    if (answer[j].compareTo(answer[k]) > 0){
                        temp_string = answer[j];
                        answer[j] = answer[k];
                        answer[k] = temp_string;
                    }
                }
            }
            count += counts[i];
        }
        
        return answer;
    }
}

import java.util.*;

class Solution {
    public String[] solution(String[] strings, int n) {
        int[] counts = new int[26];
        int arrayLength = strings.length;
        String[] answer = new String[arrayLength];
        if (arrayLength == 1){
            answer = strings;
            return answer;
        }
        
        String temp_string;
        for (int i = 0; i < arrayLength; i++){
            temp_string = strings[i] + strings[i];
            temp_string = temp_string.substring(n);
            counts[temp_string.charAt(0) - 'a']++;
            strings[i] = temp_string;
        }
        
        Arrays.sort(strings);
        
        for (int i = 0; i < arrayLength; i++){
            answer[i] = strings[i].substring((strings[i].length()+n) / 2 - n);
        }
        
        int count = 0;
        for (int i = 0; i < counts.length; i++){
            if ( counts[i] <= 1) {
                
            }else if (counts[count] == 2){
                if (answer[count].compareTo(answer[count+1]) > 0){
                    temp_string = answer[count];
                    answer[count] = answer[count+1];
                    answer[count+1] = temp_string;
                }
                
            }else{
                String[] temp_strings = new String[counts[i]];
                for(int j = 0; j < counts[i]; j++){
                    temp_strings[j] = answer[count + j];
                }

                Arrays.sort(temp_strings);

                for(int j = 0; j < counts[i]; j++){
                    answer[count + j] = temp_strings[j];
                }
            }
            
            
            
            count += counts[i];
        }

        
        return answer;
    }
}

이다.

아래는 정확성을 검사한 부분이다.

첫 코드에서 도무지 틀린 이유를 알 수가 없어서

어떻게 할까 하다가 생각한 방법이 두 번째이다.

이것을 보면서 두번째 정렬기준인 사전순으로 오름차순정렬인데

첫번째 코드에서 방향성은 맞는 것 같은데 놓치는 부분이 무엇인지 모르겠다.

첫번째 코드도 사전순 오름차순 정렬을 위한 비교였던 것 같은데 잘 모르겠다.

 

두번째 코드에서 문제는 sort를 너무 많이 하면서 런타임 에러가 난 것 같다.

이게 어제까지 했을 때 해결을 하지 못한 부분이었다.

 

그리고 오늘 첫번째 코드에서 사전순 정렬을 하는 부분을 수정하면 될 것 같아서 

고민하다가 방향을 바꿨다.

첫번째 코드에서 string을 두번 붙이고 n번째 숫자가 처음으로 오게 substring을 한 다음 

정렬을 진행하고 다시 부분만 재정렬한 것에서

 

아래 코드는 1차가 n번째 수로 정렬하고 2차가 사전순으로 정렬이어서

n번째 수만 기존 string 앞에 붙여서 정렬을 한 뒤 n번째 수만 빼는 방식으로 진행했다.

그래서 정렬을 한번에 한번만 진행하게 했다.

import java.util.*;

class Solution {
    public String[] solution(String[] strings, int n) {
        int arrayLength = strings.length;
        String[] answer = new String[arrayLength];
        if (arrayLength == 1){
            answer = strings;
            return answer;
        }
        
        for (int i = 0; i < arrayLength; i++){
            strings[i] = strings[i].charAt(n) + strings[i];
        }
        
        Arrays.sort(strings);
        
        for (int i = 0; i < arrayLength; i++){
            strings[i] = strings[i].substring(1);
        }
        
        answer = strings;
        
        return answer;
    }
}

해결은 했다. 문제는 시간이 갑자기 10배가 늘어버렸다. 왜지???

런타임에러가 sort를 지나치가 여러번 써서 문제였던 것 같다.

이렇게 생각하고 이 글을 작성을 했다. 왜냐하면 그때는 걸린 시간이 비슷하게 나왔었기 때문이다.

이러면 런타임에러가 sort를 지나치게 많이 해서 나온 문제가 아닐 수도 있다는 생각이 든다.

 

그런데 문제는 아직도 왜 첫번째 방법이 틀렸는지 모르겠다는 것이다.

왜냐하면 사전정렬을 위해 완전순환하여 도는 방법이어서 모르겠다.

다시 코드를 보면서 찾아봐야 할 것 같다.

 

그리고 아래가 sort를 람다식으로 커스텀하는 방법이다.

import java.util.*;
 
class Solution {
    public String[] solution(String[] strings, int n) {
        // 배열을 정렬하기 위해 Comparator를 정의합니다.
        Arrays.sort(strings, (a, b) -> {
            // n번째 문자를 기준으로 비교
            if (a.charAt(n) == b.charAt(n)) {
                // n번째 문자가 같으면 사전순으로 정렬
                return a.compareTo(b);
            }
            // n번째 문자를 기준으로 정렬
            return Character.compare(a.charAt(n), b.charAt(n));
        });
        return strings;
    }
}

sort를 커스텀하는 방법은 알 것 같다.

좀더 찾아봐야 할 것 같다.

과제가 급해서 일단 급한 불부터 끄러 가야 겠다.

 

아래는 Java에서 sort를 처리하는 방법을 좀더 찾아보고 정리할 링크다.

https://kimyhg.tistory.com/43

Java Arrays.sort 커스텀하기

 

 

-------------------------------------------------------------------------------------------------------------------------

ps. 수정했다. 첫번째 코드가 왜 틀렸는지 찾았다. 정리하고 다시 보니까 보인다.

첫번째 기준인 n번째 수가 몇개 중복되어 있는지 살펴봤어야 했는데 주어진 첫번째 글짜의 개수로 해버렸던 것이다.

counts[strings[i].charAt(0) - 'a']++; --> counts[temp_string.charAt(0) - 'a']++;으로 바꾸니 문제없이 해결되었다.

그렇지 도무지 사전순 정렬을 위해 쓴 부분이 틀린 이유를 찾을 수 없는 게 맞았다. 이상한데만 찾았다니ㅠ

변수명을 헷갈리게 지었더니 혼동이 있었다. 아래 비교하는 코드를 작성할 때도 문제였는데 이 부분에서도 문제가 되었던 것이다. 다시 한번 명명법의 중요성을 알고 간다.

해결은 했지만 sort에 대해서는 공부하면 좋을 것 같다. 람다식 대신에 들어가야 하는 원래 들어가야 하는 함수가 무엇인지 알아야 할 것 같다.

import java.util.*;

class Solution {
    public String[] solution(String[] strings, int n) {
        int[] counts = new int[26];	// 각 원소는 'a' ~ 'z'에 해당하는 값의 개수 
        int arrayLength = strings.length;
        String[] answer = new String[arrayLength];
        if (arrayLength == 1){
            answer = strings;
            return answer;
        }
        
        String temp_string;
        for (int i = 0; i < arrayLength; i++){
            temp_string = strings[i] + strings[i];
            temp_string = temp_string.substring(n);
            counts[temp_string.charAt(0) - 'a']++;
            strings[i] = temp_string;
        }
        
        Arrays.sort(strings);
        
        for (int i = 0; i < arrayLength; i++){
            answer[i] = strings[i].substring((strings[i].length()+n) / 2 - n);
        }
        
        int count = 0;	// strings의 인덱스를 다룰 변수
        for (int i = 0; i < counts.length; i++){
            if ( counts[i] <= 1) {
            	count += counts[i];
                continue;
            }
            
            for( int j=count; j< count+counts[i]-1; j++){
            	for( int k=j+1; k< count+counts[i]; k++){
                    if (answer[j].compareTo(answer[k]) > 0){
                        temp_string = answer[j];
                        answer[j] = answer[k];
                        answer[k] = temp_string;
                    }
                }
            }
            count += counts[i];
        }
        
        return answer;
    }
}