1. ๋ฌธ์ ์ ๋ํ์ฌ ๐ฆ
(1) ์กฐ๊ฑด ๋ถ์ ๐
๋ฐฐ์ด์ ์ฃผ์ด์ง ์ซ์๋ค์ ์ผ๋ ฌ๋ก ๋์ดํด์ ์ต๋๊ฐ์ ๋ง๋ค์ด์ผ ํ๋ค.[6, 10, 2]
-> 6210
2. ์ฝ๋๊ฐ ๋์ค๊ธฐ๊น์ง ๐ ๏ธ
KEY WORD
: ์ ๋ ฌ
, Comparator
๋ฐฐ์ด ์งํ์ ๋ค์๊ณผ ๊ฐ์ด ํ๋ค. a
, b
๊ฐ ์๋ค๊ณ ํ์ ๋,
ab
,ba
๊ตฌ์กฐ์ ์ซ์๋ฅผ ๋ง๋ ๋ค .- ์ด ๋์ ๋์๊ด๊ณ๋ฅผ ๋น๊ตํด์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ฆฌํ๋ค.
์ด๋ฅผ ์ํด์ Arrays.sort()
๋ฅผ ์ฌ์ฉํ๊ณ , int
๋ฅผ Integer
Wrapper Class๋ก ๊ตํํ๋ค.
์ด๋ ๊ฒ ํ ์ด์ ๋ Arrays.sort()
์ ๋๋ฒ์งธ ์ธ์์ธ Comparator๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ๊ฐ์ฒด ๋ฐฐ์ด์ด์ฌ์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. ํ์ง๋ง, ์ฒ์์ ์ฃผ์ด์ง, numbers์ ๊ฒฝ์ฐ int ๋ฐฐ์ด์ด๋ผ, ์ด๋ฌํ ์ฌ์ ์ ๋ฐฉ์์ ์ธ ์๊ฐ ์๋ค.
(1) ์๊ฐ๋ณต์ก๋ ๋ถ์ โณ
sorting ์์ ์ O(nlogn)์ด๋ค. ์ฌ๊ธฐ์ n์ด ๋๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ต๋ 100,000๊ฐ ์ด๋ฏ๋ก, ์ถฉ๋ถํ ๊ฐ๋ฅํ๋ค.
3. ์ฝ๋ ๐
import java.util.*;
class Solution {
public String solution(int[] numbers) {
Integer [] nums = new Integer [numbers.length];
for(int i = 0; i < nums.length; i++){
nums[i] = numbers[i];
}
Arrays.sort(nums,
(a,b) -> {
StringBuilder candi1 = new StringBuilder();
StringBuilder candi2 = new StringBuilder();
candi1.append(a).append(b);
candi2.append(b).append(a);
return Integer.parseInt(candi2.toString()) - Integer.parseInt(candi1.toString());
});
StringBuilder answer = new StringBuilder();
for(int temp : nums){
answer.append(temp);
}
if(answer.charAt(0) == '0') {
answer.setLength(0);
answer.append(0);
}
return answer.toString();
}
}
4. ํธ๋ฌ๋ธ ์ํ or ๋ฐฐ์ด ์ ๐
(1) Arrays.sort()
์์ Comparator๋ฅผ Overriding ํ ์ ์ฃผ์์
Arrays.sort()์์ Comparator๋ฅผ Overridingํ์ฌ ์ฌ์ฉํ๋ ค๋ฉด, ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ๊ฐ์ฒด ๋ฐฐ์ด์ด์ด์ผ ํ๋ค.
(2) PriorityQueue
์ ๋ด๋ถ๋ ์ ์ฒด ์ ๋ ฌ ์ํ๊ฐ ์๋๋ค.
PriorityQueue๋ ๋ฐฐ์ด์ ์ด์ฉํด, ์ต์ํ, ์ต๋ํ ์ด์ง ํธ๋ฆฌ๋ฅผ ๊ตฌํํ ์๋ฃ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์, peek()
์ ๊ฐ์ด, ์ ๋ ฌ ์์์ ์ฒซ ๋ฒ์งธ ๊ฐ์ธ ๊ฒ์ ๋ณด์ฅํ์ง๋ง, ๊ทธ ์ดํ์ ๊ฐ๋ค์ด ์์ฐจ์ ์ผ๋ก ์ ๋ ฌ๋์ด ์์ง๋ ์๋ค. (ํ์ ๋
ธ๋๋ผ์ง๋ ๋ญ๊ฐ ํฐ ์ง ๋ชจ๋ฅด๋ ๊ฒ์ฒ๋ผ)
์ด๊ฒ์ ๋ชจ๋ฅด๊ณ ํ์๋ค๊ฐ ํ๋ ธ์๋ค.