๐ฅDAY +9
https://programmers.co.kr/learn/courses/30/lessons/42889?language=java
์ฝ๋ฉํ ์คํธ ์ฐ์ต - ์คํจ์จ
์คํจ์จ ์ํผ ๊ฒ์ ๊ฐ๋ฐ์ ์ค๋ ๋ฆฌ๋ ํฐ ๊ณ ๋ฏผ์ ๋น ์ก๋ค. ๊ทธ๋ ๊ฐ ๋ง๋ ํ๋์ฆ ์ค์ฒ์ฑ์ด ๋์ฑ๊ณต์ ๊ฑฐ๋์ง๋ง, ์์ฆ ์ ๊ท ์ฌ์ฉ์์ ์๊ฐ ๊ธ๊ฐํ ๊ฒ์ด๋ค. ์์ธ์ ์ ๊ท ์ฌ์ฉ์์ ๊ธฐ์กด ์ฌ์ฉ์ ์ฌ์ด์ ์ค
programmers.co.kr
> ๋ฌธ์ ๋ฅผ ๋ณด๋ ค๋ฉด ๋๋ณด๊ธฐ ํด๋ฆญ
๋ฌธ์ ์ค๋ช
์คํจ์จ

์ํผ ๊ฒ์ ๊ฐ๋ฐ์ ์ค๋ ๋ฆฌ๋ ํฐ ๊ณ ๋ฏผ์ ๋น ์ก๋ค. ๊ทธ๋ ๊ฐ ๋ง๋ ํ๋์ฆ ์ค์ฒ์ฑ์ด ๋์ฑ๊ณต์ ๊ฑฐ๋์ง๋ง, ์์ฆ ์ ๊ท ์ฌ์ฉ์์ ์๊ฐ ๊ธ๊ฐํ ๊ฒ์ด๋ค. ์์ธ์ ์ ๊ท ์ฌ์ฉ์์ ๊ธฐ์กด ์ฌ์ฉ์ ์ฌ์ด์ ์คํ ์ด์ง ์ฐจ์ด๊ฐ ๋๋ฌด ํฐ ๊ฒ์ด ๋ฌธ์ ์๋ค.
์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํ ๊น ๊ณ ๋ฏผ ํ ๊ทธ๋ ๋ ๋์ ์ผ๋ก ๊ฒ์ ์๊ฐ์ ๋๋ ค์ ๋์ด๋๋ฅผ ์กฐ์ ํ๊ธฐ๋ก ํ๋ค. ์ญ์ ์ํผ ๊ฐ๋ฐ์๋ผ ๋๋ถ๋ถ์ ๋ก์ง์ ์ฝ๊ฒ ๊ตฌํํ์ง๋ง, ์คํจ์จ์ ๊ตฌํ๋ ๋ถ๋ถ์์ ์๊ธฐ์ ๋น ์ง๊ณ ๋ง์๋ค. ์ค๋ ๋ฆฌ๋ฅผ ์ํด ์คํจ์จ์ ๊ตฌํ๋ ์ฝ๋๋ฅผ ์์ฑํ๋ผ.
- ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ์ด ์ ์ํ๋ค.
- ์คํ ์ด์ง์ ๋๋ฌํ์ผ๋ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ ํ๋ ์ด์ด์ ์ / ์คํ ์ด์ง์ ๋๋ฌํ ํ๋ ์ด์ด ์
์ ์ฒด ์คํ ์ด์ง์ ๊ฐ์ N, ๊ฒ์์ ์ด์ฉํ๋ ์ฌ์ฉ์๊ฐ ํ์ฌ ๋ฉ์ถฐ์๋ ์คํ ์ด์ง์ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด stages๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์คํจ์จ์ด ๋์ ์คํ ์ด์ง๋ถํฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์คํ ์ด์ง์ ๋ฒํธ๊ฐ ๋ด๊ฒจ์๋ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ๋ผ.
์ ํ์ฌํญ- ์คํ ์ด์ง์ ๊ฐ์ N์ 1 ์ด์ 500 ์ดํ์ ์์ฐ์์ด๋ค.
- stages์ ๊ธธ์ด๋ 1 ์ด์ 200,000 ์ดํ์ด๋ค.
- stages์๋ 1 ์ด์ N + 1 ์ดํ์ ์์ฐ์๊ฐ ๋ด๊ฒจ์๋ค.
- ๊ฐ ์์ฐ์๋ ์ฌ์ฉ์๊ฐ ํ์ฌ ๋์ ์ค์ธ ์คํ ์ด์ง์ ๋ฒํธ๋ฅผ ๋ํ๋ธ๋ค.
- ๋จ, N + 1 ์ ๋ง์ง๋ง ์คํ ์ด์ง(N ๋ฒ์งธ ์คํ ์ด์ง) ๊น์ง ํด๋ฆฌ์ด ํ ์ฌ์ฉ์๋ฅผ ๋ํ๋ธ๋ค.
- ๋ง์ฝ ์คํจ์จ์ด ๊ฐ์ ์คํ ์ด์ง๊ฐ ์๋ค๋ฉด ์์ ๋ฒํธ์ ์คํ ์ด์ง๊ฐ ๋จผ์ ์ค๋๋ก ํ๋ฉด ๋๋ค.
- ์คํ ์ด์ง์ ๋๋ฌํ ์ ์ ๊ฐ ์๋ ๊ฒฝ์ฐ ํด๋น ์คํ ์ด์ง์ ์คํจ์จ์ 0 ์ผ๋ก ์ ์ํ๋ค.
5 | [2, 1, 2, 6, 2, 4, 3, 3] | [3,4,2,1,5] |
4 | [4,4,4,4,4] | [4,1,2,3] |
์
์ถ๋ ฅ ์ #1
1๋ฒ ์คํ
์ด์ง์๋ ์ด 8๋ช
์ ์ฌ์ฉ์๊ฐ ๋์ ํ์ผ๋ฉฐ, ์ด ์ค 1๋ช
์ ์ฌ์ฉ์๊ฐ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ๋ค. ๋ฐ๋ผ์ 1๋ฒ ์คํ
์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
- 1 ๋ฒ ์คํ ์ด์ง ์คํจ์จ : 1/8
2๋ฒ ์คํ ์ด์ง์๋ ์ด 7๋ช ์ ์ฌ์ฉ์๊ฐ ๋์ ํ์ผ๋ฉฐ, ์ด ์ค 3๋ช ์ ์ฌ์ฉ์๊ฐ ์์ง ํด๋ฆฌ์ดํ์ง ๋ชปํ๋ค. ๋ฐ๋ผ์ 2๋ฒ ์คํ ์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
- 2 ๋ฒ ์คํ ์ด์ง ์คํจ์จ : 3/7
๋ง์ฐฌ๊ฐ์ง๋ก ๋๋จธ์ง ์คํ ์ด์ง์ ์คํจ์จ์ ๋ค์๊ณผ ๊ฐ๋ค.
- 3 ๋ฒ ์คํ ์ด์ง ์คํจ์จ : 2/4
- 4๋ฒ ์คํ ์ด์ง ์คํจ์จ : 1/2
- 5๋ฒ ์คํ ์ด์ง ์คํจ์จ : 0/1
๊ฐ ์คํ ์ด์ง์ ๋ฒํธ๋ฅผ ์คํจ์จ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
- [3,4,2,1,5]
์ ์ถ๋ ฅ ์ #2
๋ชจ๋ ์ฌ์ฉ์๊ฐ ๋ง์ง๋ง ์คํ ์ด์ง์ ์์ผ๋ฏ๋ก 4๋ฒ ์คํ ์ด์ง์ ์คํจ์จ์ 1์ด๋ฉฐ ๋๋จธ์ง ์คํ ์ด์ง์ ์คํจ์จ์ 0์ด๋ค.
- [4,1,2,3]
๐ฅ [๋ก์ง]
1. Stage ํด๋์ค ์์ฑํด์ ๊ฐ ์คํ ์ด์ง๋ณ๋ก ๋ฒํธ์ ์คํจ์จ ๋ด๊ธฐ
(1) ๋ฒํธ : ์คํ ์ด์ง ๊ฐ์(N)๋งํผ ์ฐจ๋ก๋ก ์์ฑ
(2)์คํจ์จ : stages ๋ฐฐ์ด ๋๋ฉด์ (ํ์ฌ ์คํ ์ด์ง์ ๊ฐ์ ๊ฒฝ์ฐ / ํ์ฌ ์คํ ์ด์ง๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฐ ๊ฒฝ์ฐ)์ ์๋ฅผ ์ ์ฅ
2. sortํจ์๋ฅผ ์ฌ์ฉํด ์คํจ์จ๋ณ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
compareTo๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ(Comparable ์ธํฐํ์ด์ค๋ ๊ตฌํํด์ผ ํจ)
-> ํ์ฌ ๋ณ์์ ๊ฐ์ด ํ๋ผ๋ฏธํฐ์ ๊ฐ๋ณด๋ค ์์ผ๋ฉด 1์ ๋ฆฌํด, ํฌ๋ฉด -1์ ๋ฆฌํด, ๊ฐ์ผ๋ฉด 0์ ๋ฆฌํดํด์ค.(๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด๊ธฐ ๋๋ฌธ)
๐ฅ [์ต์ข ์ฝ๋]
import java.util.*;
class Stage implements Comparable<Stage> {
int stage;
float rate;
public Stage(int stage) {
this.stage = stage;
}
@Override
public int compareTo(Stage s) {
if(s.rate > this.rate)
return 1;
else if(s.rate < this.rate)
return -1;
return 0;
}
}
class Solution {
public int[] solution(int N, int[] stages) {
List<Stage> list = new ArrayList<Stage>();
for(int i = 0; i < N; i++) {
list.add(new Stage(i));
}
for(int i = 0; i < N; i++) {
int target = 0;
int totalNum = 0;
for(int j = 0; j < stages.length; j++) {
if(stages[j] > i+1) {
totalNum++;
} else if(stages[j] == i+1) {
totalNum++;
target++;
}
}
list.get(i).rate = (float)target/totalNum;
}
Collections.sort(list);
return list.stream().mapToInt(x -> x.stage+1).toArray();
}
}
๐ฅ [์๊ฐ]
์ฒ์์๋ fail ํ๋ฅ ์ ๋ด์์ฃผ๋ ๋ฐฐ์ด์ ์ ์ธํ๋ ๋ฐฉ์์ ๊ณ ๋ คํ๋๋ฐ, (์ค์ ๋ก ๊ทธ๋ ๊ฒ ์งฐ์ใ )
๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ๋ก ํ์๋ stage๋ฒํธ๋ฅผ ์ด๋ป๊ฒ ์ ์ฅํด์ค์ผํ ์ง๋ฅผ ๊ณ ๋ฏผํ๋ค๊ฐ ๊ฒฐ๊ตญ class๋ฅผ ์ ์ธํ๋ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํจ!
์ฝ๋ฉํ ์คํธ ๋ฌธ์ ์์ class๋ฅผ ์ ์ธํ๋๊ฑด ์ฒ์์ด๋ผ ๋ค์ ๋ฒ๋ฒ ์๋๋ฐ ์์ผ๋ฅผ ๋ํ๋ ์ข์ ๊ฒฝํ์ด ๋ ๊ฒ ๊ฐ๋น.
Java class์ ๋ํด ํฌ์คํ ํ๋ฉด ์ข์๊ฒ ๊ฐ๋ค !!
์ฝํ ์ค๋น๋ฅผ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ์ง ์ผ๋ง ๋์ง ์์ ์ฝ๋์ ๋ฏธํกํ ์ ์ด ๋ง์ ์ ์์ต๋๋ค.
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-budtree