https://school.programmers.co.kr/learn/courses/30/lessons/42746
๋ฌธ์
- 0 ๋๋ ์์ ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ ์๋ฅผ ์ด์ด ๋ถ์ฌ ๋ง๋ค ์ ์๋ ๊ฐ์ฅ ํฐ ์ ๊ตฌํ๊ธฐ
์ ํ ์ฌํญ
- numbers์ ๊ธธ์ด๋ 1 ์ด์ 100,000 ์ดํ
- numbers์ ์์๋ 0 ์ด์ 1,000 ์ดํ
- ์ ๋ต์ด ๋๋ฌด ํด ์ ์์ผ๋ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด return
์ ์ถ๋ ฅ ์์
numbers | return |
[6, 10, 2] | [3, 30, 34, 5, 9] |
[3, 30, 34, 5, 9] | "9534330" |
[6, 10, 2]๋ผ๋ฉด [6102, 6210, 1062, 1026, 2610, 2106]๋ฅผ ๋ง๋ค ์ ์๊ณ , ์ด์ค ๊ฐ์ฅ ํฐ ์๋ 6210
ํ์ด
์์๋ฅผ ๋ณด๊ณ ์ฒ์ ๋ ์ค๋ฅธ ํ์ด๋ ์์ด(DFS)๋ก ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์์ ๋ํด ๋ฌธ์๋ฅผ ์ด์ด๋ถ์ด ์ต๋๊ฐ์ ๊ตฌํ๋ ๊ฒ์ด์๋ค. ํ์ง๋ง ์ ํ ์ฌํญ์ ๋ณด๋ฉด ๊ธธ์ด๊ฐ ์ต๋ 100,000๋ก n!์ ํ๊ฒ ๋๋ค๋ฉด ์๊ฐ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.
- ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
๊ทธ๋์ ๋ค๋ฅธ ํ์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋ค๊ฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค์ ๋ฌธ์๋ฅผ ์ด์ด๋ถ์ด๋ฉด ๋๊ฒ ๋ค๋ ํ์ด๊ฐ ๋ ์ฌ๋๋ค. ํ์ง๋ง ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ ๊ณ ๋ คํด์ผ ๋ ๊ฒ์ด ์๋ค.
์ ๋ ฅ ์์์์์ฒ๋ผ [3, 30]์ ๊ฒฝ์ฐ, ๋ง๋ค ์ ์๋ ์ซ์๋ "330"๊ณผ "303"์ด๋ค. "330"์ด ์ต๋๊ฐ์ด ๋๋ค. ๊ทธ๋ฅ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ฉด [30, 3]์ด ๋ ๊ฒ์ด๊ณ , ๋ฌธ์์ด๋ก ๋ง๋ ์๋ "303"์ด ๋ ๊ฒ์ด๋ค. ์ต๋๊ฐ์ธ "330"์ด ์๋๋ค.
์ต๋๊ฐ์ ๊ตฌํ๊ธฐ ์ํด 3, 30์ ์ ๋ ฌํด์ ๋ถ์ธ ๊ฐ์ด 303์ด ์๋๋ผ 330์ด ๋๊ฒ ํ๊ธฐ ์ํด์๋ ๋ถ์ธ ๋ฌธ์ ๊ฐ์ ๋น๊ตํด ์ ๋ ฌํด์ผ ํ๋ค.
.sorted((o1, o2) -> (o2 + o1).compareTo(o1 + o2));
๋๋ค์์ compareTo ๋ฉ์๋๋ฅผ์ฌ์ฉํด์ ์ ๋ ฌํ๋ค.
*A.compareTo(B) ๋ฉ์๋ : A์ B๋ฅผ ๋น๊ตํ์ ๋, A๊ฐ ํฌ๋ค๋ฉด ์์, ๊ฐ์ผ๋ฉด 0, B๊ฐ ํฌ๋ฉด ์์๋ฅผ ๋ฐํํ๋ค. ๋ฐ๋ผ์ ์ ๋ ฌ์ ํ๊ฒ ๋์์ ๋, ์์๋ผ๋ฉด ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํ๊ณ , ์์๋ผ๋ฉด ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํ๋ค.
- Stream API ์ฌ์ฉ
์ ํ ์ฌํญ์ ๋ณด๋ฉด ์ ๋ต์ด ๋๋ฌด ํด ์ ์์ผ๋ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด ๋ฆฌํดํ๋ผ๊ณ ํ๊ณ , ์ ๋ ฌ๋ ํด์ผํ๋ Stream API๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ํธํ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค.
Stream ๊ณผ์ ์ ํฌ๊ฒ 3๊ฐ์ง๋ก ๋๋๋ค.
1. Stream ์์ฑ
Arrays.stream(numbers)
2. ๊ฐ๊ณตํ๊ธฐ
- map์ผ๋ก ๋ฐ์ดํฐ ๋ณํ
.mapToObj(String::valueOf)
int ํํ์ ๋ฐฐ์ด์ String ๋ฐฐ์ด์ผ๋ก ๋ณํํด์ค๋ค.
- ์ ๋ ฌ
.sorted((o1, o2) -> (o2 + o1).compareTo(o1 + o2))
๋ถ์ธ ๋ฌธ์๊ฐ์ ๋น๊ตํด ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ํ๋ค.
3. ๊ฒฐ๊ณผ ๋ง๋ค๊ธฐ
- ๋ฐ์ดํฐ ์์ง(collect)
.collect(Collectors.joining());
์ ๋ ฌ๋ ๋ฐฐ์ด์ ์์๋ค์ 1๊ฐ์ String์ผ๋ก ์ด์ด๋ถ์ธ๋ค.
- ๋ฐ๋ก
์ ํ ์ฌํญ์ ๋ณด๋ฉด "numbers์ ์์๋ 0 ์ด์ 1,000 ์ดํ"๋ค. [0, 0, 0]์ผ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ๊ฐ์ 000์ด ๋๋ค. ํ์ง๋ง ์ด๋ฅผ ์๋ก ๋ง๋ค์์ ๋๋ 0์ด๋ฏ๋ก, 000์ธ ๊ฒฝ์ฐ์๋ 0์ผ๋ก ๋ฐํ๋๊ฒ ํด์ผ ํ๋ค.
์ฝ๋
import java.util.*;
import java.util.stream.*;
class Solution {
public String solution(int[] numbers) {
String answer = Arrays.stream(numbers) //stream ์์ฑ
.mapToObj(String::valueOf) //String์ผ๋ก ๋ณํ
.sorted((o1, o2) -> (o2 + o1).compareTo(o1 + o2)) //๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ : 3 30 34 -> 34 3 30
.collect(Collectors.joining()); //๋ฌธ์๋ฅผ ์ด์ด๋ถ์
return answer.startsWith("0") ? "0" : answer; //000์ธ ๊ฒฝ์ฐ๋ 0์ผ๋ก ๋ฐํ
}
}
๊ฒฐ๊ณผ
๋ฐฐ์ด์
- Stream API
- ์คํธ๋ฆผ ์์ฑํ๊ธฐ
- ๊ฐ๊ณตํ๊ธฐ
- ํํฐ๋ง(filter)
- ๋ฐ์ดํฐ ๋ณํ(map)
- ์ ๋ ฌ(sorted)
- ๊ฒฐ๊ณผ ๋ง๋ค๊ธฐ
- ์ง๊ณ(max, min, sum, count..)
- ์์ง(collect) : list๋ก ๋ฐํ๋ฐ๊ธฐ, 1๊ฐ์ String์ผ๋ก ์ด์ด๋ถ์ด๊ธฐ..
์ฐธ๊ณ
- Stream ํ์ฉํ ํ์ด : https://school.programmers.co.kr/questions/52623
- stream ๊ธฐ์ด1 : https://mangkyu.tistory.com/112
- stream ๊ธฐ์ด2 : https://mangkyu.tistory.com/114
'Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค - ์กฐ์ด์คํฑ (0) | 2023.10.24 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค - ๋ ํ ํฉ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ (0) | 2023.10.19 |
ํ๋ก๊ทธ๋๋จธ์ค - ์ด์ง ๋ณํ ๋ฐ๋ณตํ๊ธฐ (0) | 2023.08.30 |
ํ๋ก๊ทธ๋๋จธ์ค - ์์ดํ ์ค๊ธฐ (0) | 2023.08.21 |
ํ๋ก๊ทธ๋๋จธ์ค - ์คํฌํธ๋ฆฌ (0) | 2023.08.17 |