[프로그래머스][Java][Lv.0] 글자 지우기

 

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

프로그래머스

 

내가 푼 풀이 - deleteCharAt()함수 사용

1. int배열을 오름차순으로 정렬해준다.

2. StringBuilder의 deleteCharAt()함수를 사용할 것이다.

3. 해당 함수를 사용하면 특정 인덱스 문자가 지워지면서 글자가 앞으로 밀리는 현상이 발생한다

4. 삭제할때마다 글자 위치가 변하는 걸 따라가기 위해 offset변수를 사용한다.

 

import java.util.Arrays;

public class Solution {
    public String solution(String my_string, int[] indices) {
        Arrays.sort(indices);
        StringBuilder sb = new StringBuilder(my_string);
        int offset = 0; // 삭제된 문자로 인한 인덱스 오차 보정
        for (int i = 0; i < indices.length; i++) {
            int adjustedIndex = indices[i] - offset;
                sb.deleteCharAt(adjustedIndex);
                offset++; // 삭제로 인한 인덱스 오차 업데이트

        }
        return sb.toString();
    }


    public static void main(String[] args) {

        Solution s = new Solution();
        String my_string = "apporoograpemmemprs";
        int[] indices = {1, 16, 6, 15, 0, 10, 11, 3};
        s.solution(my_string, indices);
    }
}

테스트 1 〉	통과 (0.40ms, 73.8MB)
테스트 2 〉	통과 (0.66ms, 72.2MB)
테스트 3 〉	통과 (0.54ms, 76.7MB)
테스트 4 〉	통과 (1.11ms, 77.5MB)
테스트 5 〉	통과 (0.51ms, 78.6MB)
테스트 6 〉	통과 (0.53ms, 74.9MB)
테스트 7 〉	통과 (0.61ms, 79MB)
테스트 8 〉	통과 (0.59ms, 74.6MB)
테스트 9 〉	통과 (0.35ms, 76.1MB)
테스트 10 〉	통과 (0.38ms, 67.9MB)
테스트 11 〉	통과 (0.46ms, 73.7MB)
테스트 12 〉	통과 (0.60ms, 86.8MB)
테스트 13 〉	통과 (0.44ms, 67.1MB)
테스트 14 〉	통과 (0.41ms, 76.8MB)
테스트 15 〉	통과 (0.42ms, 76.8MB)
테스트 16 〉	통과 (0.38ms, 75MB)
테스트 17 〉	통과 (0.54ms, 70.5MB)
테스트 18 〉	통과 (0.45ms, 73.9MB)

 

 

다른 사람 풀이 1 ( 배열의 인덱스값 교체 )

1. 입력 문자열을 배열로 쪼갠다

2. 쪼갠 배열의 인덱스에 정수배열의 인덱스값을 넣어서 ""로 대체 한다

3. 배열을 다시 문자여롤 만든다

class Solution {

    public String solution(String my_string, int[] indices) {
        String answer = "";
        String[] tmp = my_string.split("");

        for (int i = 0; i < indices.length; i++) {
            tmp[indices[i]] = "";
        }

        for (String x : tmp) {
            answer += x;
        }
        return answer;
    }
}

테스트 1 〉	통과 (1.99ms, 75.2MB)
테스트 2 〉	통과 (1.97ms, 74.3MB)
테스트 3 〉	통과 (2.06ms, 75.2MB)
테스트 4 〉	통과 (2.17ms, 73.4MB)
테스트 5 〉	통과 (1.87ms, 75.8MB)
테스트 6 〉	통과 (1.57ms, 76.7MB)
테스트 7 〉	통과 (1.84ms, 80MB)
테스트 8 〉	통과 (2.15ms, 85.4MB)
테스트 9 〉	통과 (2.19ms, 82.4MB)
테스트 10 〉	통과 (1.69ms, 80MB)
테스트 11 〉	통과 (1.97ms, 75.8MB)
테스트 12 〉	통과 (1.76ms, 74.3MB)
테스트 13 〉	통과 (2.25ms, 71.6MB)
테스트 14 〉	통과 (1.49ms, 73.2MB)
테스트 15 〉	통과 (2.76ms, 73.6MB)
테스트 16 〉	통과 (1.72ms, 73.7MB)
테스트 17 〉	통과 (3.05ms, 67.8MB)
테스트 18 〉	통과 (1.85ms, 70.8MB)

 

다른 사람 풀이 2 ( 배열의 인덱스값 교체 )

1. 입력 문자열을 문자 배열로 쪼갠다

2. 해당 배열에서 indices의 인덱스값에 해당하는 위치에 공백으로 대체 한다

3. 공백이 아닌 경우에만 Stringbuilder로 저장한다.

class Solution {
    public String solution(String my_string, int[] indices) {
        char[] arr = my_string.toCharArray();
        for(int i : indices) {
            arr[i] = ' ';
        }
        StringBuilder sb=  new StringBuilder();
        for(int i=0; i<arr.length; i++) {
            if(arr[i] != ' ') {
                sb.append(arr[i]);
            }
        }
        return sb.toString();
    }
}

테스트 1 〉	통과 (0.03ms, 77.8MB)
테스트 2 〉	통과 (0.04ms, 70.6MB)
테스트 3 〉	통과 (0.03ms, 72.2MB)
테스트 4 〉	통과 (0.04ms, 74.6MB)
테스트 5 〉	통과 (0.03ms, 74.2MB)
테스트 6 〉	통과 (0.04ms, 91.1MB)
테스트 7 〉	통과 (0.05ms, 75MB)
테스트 8 〉	통과 (0.05ms, 86MB)
테스트 9 〉	통과 (0.05ms, 75.2MB)
테스트 10 〉	통과 (0.05ms, 62.2MB)
테스트 11 〉	통과 (0.04ms, 74.5MB)
테스트 12 〉	통과 (0.03ms, 74.3MB)
테스트 13 〉	통과 (0.05ms, 71.4MB)
테스트 14 〉	통과 (0.06ms, 73MB)
테스트 15 〉	통과 (0.04ms, 75.9MB)
테스트 16 〉	통과 (0.03ms, 74.1MB)
테스트 17 〉	통과 (0.03ms, 79.2MB)
테스트 18 〉	통과 (0.03ms, 77.9MB)

 

다른 사람 풀이 3 (stack 사용)

1. int배열을 오름차순한다.

2. my_string의 각 문자를 stack으로 저장한다

3. Stack의 remove()함수로 해당 인덱스 값만 제거 한다.

import java.util.Arrays;
import java.util.Stack;

public class Solution {
    public String solution(String my_string, int[] indices) {
        String answer = "";
        Arrays.sort(indices);
        Stack<Character> stack = new Stack<>();

        for (Character c : my_string.toCharArray()) {
            stack.push(c);
        }
        //System.out.println(stack);

        for (int i = indices.length - 1; i >= 0; i--) {
            stack.remove(indices[i]);
        }

        //System.out.println(stack);

        Character[] result = stack.toArray(new Character[stack.size()]);
        StringBuilder sb = new StringBuilder(result.length);
        for (Character c : result) {
            sb.append(c);
        }
        answer = sb.toString();

        return answer;
    }
}

테스트 1 〉	통과 (0.59ms, 74MB)
테스트 2 〉	통과 (0.82ms, 76.5MB)
테스트 3 〉	통과 (0.58ms, 72.5MB)
테스트 4 〉	통과 (0.59ms, 74.7MB)
테스트 5 〉	통과 (0.50ms, 78.8MB)
테스트 6 〉	통과 (0.69ms, 76.9MB)
테스트 7 〉	통과 (0.65ms, 76.8MB)
테스트 8 〉	통과 (0.89ms, 80.6MB)
테스트 9 〉	통과 (0.93ms, 82.2MB)
테스트 10 〉	통과 (0.75ms, 77.5MB)
테스트 11 〉	통과 (0.64ms, 74.2MB)
테스트 12 〉	통과 (0.63ms, 77MB)
테스트 13 〉	통과 (0.68ms, 73.2MB)
테스트 14 〉	통과 (0.63ms, 74.3MB)
테스트 15 〉	통과 (0.86ms, 80.4MB)
테스트 16 〉	통과 (0.83ms, 72.9MB)
테스트 17 〉	통과 (0.91ms, 81.4MB)
테스트 18 〉	통과 (0.63ms, 73.9MB)