문제

https://programmers.co.kr/learn/courses/30/lessons/42746

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public String solution(int[] numbers) {

    List<Numbers> list = new ArrayList<Numbers>();
    for (int i = 0; i < numbers.length; i++) {
        int number = numbers[i];

        char[] str = String.valueOf(number).toCharArray();
        StringBuilder fourDigitString = new StringBuilder();

        fourDigitString.append(str);
        if (str.length < 4) {

            for (int j = 0; j < 4 - str.length; j++) {
                fourDigitString.append(str[((j) % str.length)]);
            }
        }

        list.add(new Numbers(i, Integer.parseInt(fourDigitString.toString())));
    }

    Collections.sort(list, new Comparator<Numbers>() {

        @Override
        public int compare(Numbers o1, Numbers o2) {
            return o2.value.compareTo(o1.value);
        }
    });

    StringBuilder sb = new StringBuilder();
    int sum = 0;
    for (Numbers n : list) {
        sum += n.value;
        sb.append(numbers[n.postion]);
    }

    if (sum == 0) {
        sb.setLength(0);
        sb.append(0);
    }

    return sb.toString();
}

class Numbers {
    public Integer postion;
    public Integer value;

    public Numbers(Integer postion, Integer value) {
        this.postion = postion;
        this.value = value;
    }
}

흐름

  1. 문제에서 numbers의 원소 값이 1000 이하라고 했으므로 numbers 크기 만큼 돌면서 numbers 안에 값이 4자리가 아닌 경우 자기 숫자를 뒤에 덧붙여서 4자리로 만듬
    • ex) 121 > 1212, 1 > 1111, 23 > 2323, …
  2. 현재 배열의 index와 값을 비교하기 위에 inner class를 하나 만들어서 index와 value를 저장하고 class를 list에 추가
  3. list를 class의 value 값으로 큰 수부터 나오도록 정렬
  4. list를 돌면서 value를 StringBuilder로 붙임
  5. 이 때, 0 0 0 0 일 경우 0 이 되어야 하므로 value들을 모두 더했을 때 값이 0이라면 0 만 붙임
  6. toString() 으로 String형으로 return
  7. 끝

다른 분들의 해결방법

다른분의 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public String solution(int[] numbers) {
    String answer = "";

    List<Integer> list = new ArrayList<>();
    for(int i = 0; i < numbers.length; i++) {
        list.add(numbers[i]);
    }
    Collections.sort(list, (a, b) -> {
        String as = String.valueOf(a), bs = String.valueOf(b);
        return -Integer.compare(Integer.parseInt(as + bs), Integer.parseInt(bs + as));
    });
    StringBuilder sb = new StringBuilder();
    for(Integer i : list) {
        sb.append(i);
    }
    answer = sb.toString();
    if(answer.charAt(0) == '0') {
        return "0";
    }else {
        return answer;
    }
}

위 코드의 로직

  • list에 numbers array를 그대로 저장하고 list의 저장된 element를 앞뒤로 붙여서 정수로 바꾼 후 비교해서 정렬
  • String을 다루는 부분이 많아서 속도는 살짝 떨어지는 듯

결과

1 번

번호 속도
테스트 1 통과 (139.80ms, 83.2MB)
테스트 2 통과 (88.71ms, 67MB)
테스트 3 통과 (167.96ms, 82.4MB)
테스트 4 통과 (17.95ms, 50.7MB)
테스트 5 통과 (129.09ms, 77.4MB)
테스트 6 통과 (116.84ms, 71.2MB)
테스트 7 통과 (1.44ms, 52.3MB)
테스트 8 통과 (1.38ms, 52.7MB)
테스트 9 통과 (1.20ms, 50.2MB)
테스트 10 통과 (1.46ms, 52.6MB)
테스트 11 통과 (1.65ms, 52.9MB)

2 번

번호 속도
테스트 1 통과 (340.75ms, 105MB)
테스트 2 통과 (236.67ms, 82.1MB)
테스트 3 통과 (350.56ms, 126MB)
테스트 4 통과 (80.72ms, 59.7MB)
테스트 5 통과 (300.18ms, 110MB)
테스트 6 통과 (280.61ms, 87.6MB)
테스트 7 통과 (31.26ms, 57.2MB)
테스트 8 통과 (35.88ms, 53.4MB)
테스트 9 통과 (34.27ms, 55.3MB)
테스트 10 통과 (30.44ms, 55.6MB)
테스트 11 통과 (40.16ms, 55.3MB)

테스트 케이스

1
2
3
4
5
6
7
8
9
assertEquals("6210", test.solution(new int[] {6, 10, 2}));
assertEquals("9534330", test.solution(new int[] {3, 30, 34, 5, 9}));
assertEquals("220200", test.solution(new int[] {2,200,20}));
assertEquals("2200", test.solution(new int[] {2,0,20}));
assertEquals("0", test.solution(new int[] {0,0,0}));
assertEquals("21212", test.solution(new int[] {12, 212}));
assertEquals("21221", test.solution(new int[] {212, 21}));
assertEquals("7000", test.solution(new int[] {0, 0, 70}));
assertEquals("1000000", test.solution(new int[] {0, 0, 0, 1000}));