1. ๋ฌธ์ ์ค๋ช ๐
๋ฌธ์ ์ค๋ช ์ด ์ง๊ด์ ์ด๋ผ ์ค๋ช ์๋ต
2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธ
KEY WORD
: custom Sorting
์ ๋ ฌ ๋ฌธ์ ์์ง๋ง, ์ง์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํ๋ ๋ฌธ์ ๋ ์๋์๊ณ , ์ ๋ ฌ์ ๊ธฐ์ค์ ์ง์ ์ ์ํ๋ ๊ฒ์ด ์ค์ํ ๋ฌธ์ ์๋ค. ํ์๋ ๋ฌธ์ ๋ฅผ ์ฒ์๋ถํฐ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ง์ ๊ตฌํ์ผ๋ก ๊ฐ๋ฅ์ ์๋ชป ์ก๊ณ ๋ค์ด๊ฐ์ ์์ฒญ ํค๋ฉจ๋ค. ํด๋น ๋ด์ฉ์ ๋ฐฐ์ด ๊ฒ๋ค
์ ๋ ์์ธํ ๊ธฐ์ ํ๊ณ ์ฌ๊ธฐ์๋ ์ด๋ป๊ฒ ์ ๊ทผํด์ผ ํ๋์ง์ ์ด์ ์ ๋ง์ถ๊ฒ ๋ค.
(1) ์ ๋ ฌ ๊ธฐ์ค
Numbers ๋ฐฐ์ด์ ์์ ์ค ์์์ ํ๋๋ฅผ A
, A์ ๋ค์ ์์๋ฅผ B
๋ผ๊ณ ํ์. ์ด ์ซ์๋ค์ ๋ฌธ์์ด์ด๋ผ ๊ฐ์ ํ์ ๋, ๋ค์๊ณผ ๊ฐ์ด ์ด์ด ๋ถ์ผ ์ ์์ ๊ฒ์ด๋ค.
AB
ํํBA
ํํ
์ด ๋ ํํ ์ค ๋ฌด์์ด ํฐ์ง๋ฅผ ๋์ ๊ด๊ณ ๋น๊ตํ๋ฉด ๋๋ค.
AB
>BA
, A๊ฐ ์์ ์์ ๋ ๊ฐ์ด ์ปค์ง๋ค๋ ๊ฒ์์ผ๋ก, A๊ฐ ์๋ ๊ทธ๋๋ก ์์ ์กด์ฌํ๋ค.AB
<BA
, B๊ฐ ์์ ์์ ๋ ๊ฐ์ด ์ปค์ง๋ค๋ ๊ฒ์์ผ๋ก, B์ A์ ์๋ฆฌ๋ฅผ ๊ต์ฒดํ์ฌ A๊ฐ ์์ผ๋ก ์จ๋ค.AB
==BA
, ๋์ด ๊ฐ์ด ๊ฐ์ผ๋ฏ๋ก, ๊ตณ์ด ์๋ฆฌ ๊ต์ฒด๋ฅผ ํ ํ์๊ฐ ์๋ค.
(2) ์ ๋ ฌ ์์
์
๋ ฅ๊ฐ: [3, 30, 34, 5, 9]
9
์ ๊ฒฝ์ฐ
๋ต์ด ๋์ค๋ ค๋ฉด ์ ๋ ฌ ํ 9๊ฐ ๋งจ ์์ผ๋ก ์์ผ ํ๋ค. ์ฐ๋ฆฌ๊ฐ ์ ํ ์ ๋ ฌ๊ธฐ์ค์ ์งํค๋ฉฐ ์ ๋ ฌํด ๋๊ฐ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์น๋ค.
- (1)
59
<95
, 9์ 5 ์๋ฆฌ ๊ต์ฒด - (2)
349
<934
, 9์ 34 ์๋ฆฌ ๊ต์ฒด - (3)
309
<930
, 9์ 30 ์๋ฆฌ ๊ต์ฒด - (4)
39
<93
, 9์ 3 ์๋ฆฌ ๊ต์ฒด
30
๊ณผ 3
์ ๊ฒฝ์ฐ
์ ๋ ฌ์ ์งํํ๋ค๋ณด๋ฉด ๋งจ ๋ง์ง๋ง์ ์งํํด์ผํ ๋น๊ต๋ 3๊ณผ 30์ ๋น๊ต์ผ ๊ฒ์ด๋ค. 303
๋ณด๋ค 330
์ด ๋ ํผ์ผ๋ก, 3์ด 30๋ณด๋ค ์์ ์ ๋ค.
(3) ์ ์ฒด ์ฝ๋ ํ๋ฆ
(1) ์
๋ ฅ์ผ๋ก ๋ฐ์ int๋ ์์ ์๋ฃํ์ผ๋ก, Arrays.sort()
์ฌ์ฉ ์ Custom์ด ๋ถ๊ฐํ๊ธฐ ๋๋ฌธ์, Integer
ํ์ผ๋ก ๊ต์ฒด
(2) ์์ ์์๋๋ก, Arrays.sort()์ ์ ๋ ฌ ๊ธฐ์ค ์ธ์ฐ๊ธฐ
(3) ์ ๋ ฌ ํ String์ผ๋ก ์ด์ด ๋ถ์ด๊ธฐ
3. ์ฝ๋ ์๊ฐ ๐
import java.util.*;
class Solution {
public String solution(int[] numbers) {
Integer [] arr = new Integer [numbers.length];
for(int i = 0; i < numbers.length; i++){
arr[i] = numbers[i];
}
Arrays.sort(arr, (a, b) -> {
String sA = Integer.toString(a);
String sB = Integer.toString(b);
String temp1 = sA+sB;
String temp2 = sB+sA;
int ab = Integer.parseInt(temp1);
int ba = Integer.parseInt(temp2);
if(ab > ba) return -1;
else if (ab == ba) return 0;
else return 1;
});
return join(arr);
}
public String join (Integer [] arr) {
StringBuilder sb = new StringBuilder();
int zero_cnt = 0;
for(Integer i : arr){
if(i == 0) zero_cnt++;
sb.append(i);
}
if(zero_cnt == arr.length) {
sb.setLength(0);
sb.append("0");
}
return sb.toString();
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
(1) ์ ๊ทผ ๋ฐฉ์์ ๋ํ ์๊ฐ์ ๋ํ
์ด๋ฐ์ ๋ฌธ์ ๋ฅผ ๋๋ฌด ์ด๋ ต๊ฒ ์๊ฐํ๋ค.
๋๋ ์๋ฆฟ์๋ก ๊ฐ์ ๋น๊ตํ๋ Radix-sort
๋ฅผ ๋ณํํ์ฌ, ๋งจ ์ ์๋ฆฌ์ ๊ธฐ์ค ๋ด๋ฆผ์ฐจ์์ผ๋ก ๊ฐ์ ์ ๋ ฌํ๋ค. ๋ง์ฝ ๋งจ ์ ์๋ฆฟ์๊ฐ ๋๋ฑํ๋ค๋ฉด ๊ทธ ๋ค์ ์๋ฆฟ์๋ก ๋น๊ตํ์๋ค.
3๊ณผ 30์ ๊ฒฝ์ฐ์, 3์ด ์ด๋ฏธ 1์ ์๋ฆฌ๋ผ ๋ค์ ์๋ฆฟ์๊ฐ ์์์ผ๋ก, ๊ทธ๋๋ก ํ ์์น์ ์๋ฆฟ์๋ฅผ 30์ 0๊ณผ ๋น๊ตํ๋ฉด ๋๋ค๊ณ ์๊ฐํ๋ค. (์ด๋ ๊ฒ ๊ตฌํํ๋๋ฐ ์ ํ๋ ธ์ผ๋ ๋ฐ๋ก๊ฐ ์กด์ฌํ๋ ๋ฏ ํ๋ค.)
์๋ฅผ ๋ค์ด 3๊ณผ 30์ ๋งจ ์ ์๋ฆฟ์๊ฐ ๋๋ฑํ๋ฏ๋ก ๋ค์ ์๋ฆฟ์๋ฅผ ๋น๊ตํ๋๋ฐ, 3์ ๋ค์ ์๋ฆฟ์๊ฐ ์์์ผ๋ก ๊ทธ๋๋ก 3๊ณผ 30์ 0์ ๋น๊ตํ์ฌ ๋์๊ด๊ณ๋ฅผ ๊ฐ๋ฆฐ๋ค.
์ด๋ฒ ๋ฌธ์ ์ ๋ต์ง๋ฅผ ๋ณด๋ฉด์ ๋ง์ด ํํํ๋ค. ์ ๋ ฌ ๋ฌธ์ ๋ค์ ๊ฒฝํํ๋ฉฐ ๋๋ ๊ฒ์ '์ด๋ฏธ ์ธ์ด ๋ด๋ถ์ ์ต์ ํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์กด์ฌํ๋ฏ๋ก, ์ง์ ๊ตฌํ ํ๋ ๋ฌธ์ ๋ ์ ๋์ค์ง ์๋๋ค.' ๋ ๊ฒ์ด๋ค.
์ ๋ ฌ์ ์ง์ ํด์ผํ๋ ๊ฒฝ์ฐ๋ ์ ๋ ฌํ๋ ๊ณผ์ ์ ํ์๋ก ํ๋ ๋ฌธ์ ์ ๊ฒฝ์ฐ ๋ฐ์ ์๋ ๊ฒ ๊ฐ๋ค.
2. Comparator ๊ตฌํ ๋ถ๋ถ ์ ์ง์
์ฒ์ ์ฝ๋๋ฅผ ์งค ๋, ๋ค์๊ณผ ๊ฐ์ด return 0
๊ฐ ๋์ค๋ ๊ฒฝ์ฐ์ ์ ์์ด Comparator๋ฅผ ๊ตฌํํ์๋ค. ๊ทธ๋ฌ์ ๋ฐํ์ ์๋ฌ๊ฐ ๋ฌ๋ค.
Arrays.sort(arr, (a, b) -> {
String sA = Integer.toString(a);
String sB = Integer.toString(b);
String temp1 = sA+sB;
String temp2 = sB+sA;
long ab = Long.parseLong(temp1);
long ba = Long.parseLong(temp2);
if(ab >= ba) return -1;
else return 1;
});
์ด์ ๋ฅผ ์ฐพ์๋ณด๋, Comparator๋ 3๊ฐ์ง ์กฐ๊ฑด(1,-1,0)์ ํ์๋ก ํ๋ค. ์ ๋ ฅ๊ฐ์ด (A,B)์ผ ๋, ๊ฐ๊ฐ A๊ฐ B๋ณด๋ค ํฌ๋ค, A๊ฐ B๋ณด๋ค ์๋ค, ๋์ ๋๋ฑํ๋ค์ ๋ป์ด๋ผ๊ณ ํ๋ค. ๋ด ๊ฒฝ์ฐ ์๋ก ์ด๋จ ๋ ๋๋ฑํ์ง 0์ ๋ฐํํ๋ ๊ฒฝ์ฐ๋ฅผ ์ ์ง ์์์ ๋ฐํ์ ์๋ฌ๊ฐ ๋ ๊ฒ์ด์๋ค.
์ฅ? -1 == (์๋ฆฌ ๊ต์ฒด ํ์ง ์๋๋ค.), 1 == (์๋ฆฌ ๊ต์ฒด ํ๋ค) ๋ง ๋๋ฉด ๋๋ ๊ฑฐ ์๋๊ฐ? ๐ค
Comparator๋ ๋์นญ์ฑ์ ์๊ตฌํ๋ค.
๋์นญ์ฑ์ด๋?
a๊ฐ b๋ณด๋ค ํฌ๋ค๋ฉด, b๋ a๋ณด๋ค ์์์ผ ํ๋ค. ์ด๋ฅผ Comparator ๋ฐํ๊ฐ์ ๋น์ถ์ด ๋ณด๋ฉด, Comparator์์๋ ์ ๋ ฅ๊ฐ (A,B)์ ๋ํ์ฌ A>B์ด๋ฉด ๋ฐํ๊ฐ์ด ์์๊ฐ ๋์์ผ ํ๋ค. ๋ฐ๋๋ก (B,A)๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฃ์๋ค๋ฉด ๋ฐํ๊ฐ์ ์์๋ก ๋์์ผ ํ๋ค.
Compare(A,B)์ Compare(B,A)๋ ๋ถํธ๊ฐ ๋ฐ๋์ฌ์ผ ํ๋ค.
์ด ๊ท์น์ ๋ณผ ๋, ๋์ ์ฒซ ์ฝ๋๋ ๋์นญ์ฑ์ ๊ท์น์ ์งํค์ง ์์๋ค. ๊ทธ๋์ ๋ฐํ์ ์๋ฌ๊ฐ ๋ ๊ฒ์ด๋ค.