
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/120889
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
์ ๋ถ ์ธ ๊ฐ๋ก ์ผ๊ฐํ์ ๋ง๋ค๊ธฐ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํฉ๋๋ค.
- ๊ฐ์ฅ ๊ธด ๋ณ์ ๊ธธ์ด๋ ๋ค๋ฅธ ๋ ๋ณ์ ๊ธธ์ด์ ํฉ๋ณด๋ค ์์์ผ ํฉ๋๋ค.
์ผ๊ฐํ์ ์ธ ๋ณ์ ๊ธธ์ด๊ฐ ๋ด๊ธด ๋ฐฐ์ด sides์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ธ ๋ณ์ผ๋ก ์ผ๊ฐํ์ ๋ง๋ค ์ ์๋ค๋ฉด 1, ๋ง๋ค ์ ์๋ค๋ฉด 2๋ฅผ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- sides์ ์์๋ ์์ฐ์์ ๋๋ค.
- sides์ ๊ธธ์ด๋ 3์ ๋๋ค.
- 1 ≤ sides์ ์์ ≤ 1,000
์ ์ถ๋ ฅ ์sidesresult
| [1, 2, 3] | 2 |
| [3, 6, 2] | 2 |
| [199, 72, 222] | 1 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๊ฐ์ฅ ํฐ ๋ณ์ธ 3์ด ๋๋จธ์ง ๋ ๋ณ์ ํฉ 3๊ณผ ๊ฐ์ผ๋ฏ๋ก ์ผ๊ฐํ์ ์์ฑํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ 2๋ฅผ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๊ฐ์ฅ ํฐ ๋ณ์ธ 6์ด ๋๋จธ์ง ๋ ๋ณ์ ํฉ 5๋ณด๋ค ํฌ๋ฏ๋ก ์ผ๊ฐํ์ ์์ฑํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ 2๋ฅผ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- ๊ฐ์ฅ ํฐ ๋ณ์ธ 222๊ฐ ๋๋จธ์ง ๋ ๋ณ์ ํฉ 271๋ณด๋ค ์์ผ๋ฏ๋ก ์ผ๊ฐํ์ ์์ฑํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ 1์ returnํฉ๋๋ค.
Approach 1 โ - ๋์ ํ๋ฆฐ ์ฝ๋
class Solution {
public int solution(int[] sides) {
int [] an = sides.ArraySort;
if (an[0] > an[1]+an[2]) {
return 1;
}else {return 2}
}
}
Approach 2 โญ - ๋์ ํ์ด ๋ณด์์
๋ฌธ์ 1: ๋ฐฐ์ด ์ ๋ ฌ ๋ฉ์๋ ํธ์ถ ๋ฌธ์
• ์ค๋ฅ:
sides.ArraySort๋ ์๋ชป๋ ํธ์ถ์ด๋ค.
Java์๋ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ ๋ฉ์๋๋ก Arrays.sort()๊ฐ ์กด์ฌํ๋ฉฐ,
์ ๋ ฌ ๋์์ sides ๋ฐฐ์ด ์์ฒด์ด๋ค.
• ํด๊ฒฐ ๋ฐฉ๋ฒ:
Arrays.sort(sides)๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
๋ฌธ์ 2: ๊ฐ์ฅ ๊ธด ๋ณ๊ณผ ๋๋จธ์ง ๋ ๋ณ์ ํฉ ๋น๊ต ๋ ผ๋ฆฌ ์ค๋ฅ
• ์ค๋ฅ:
an[0] > an[1] + an[2]๋ ์๋ชป๋ ๋ ผ๋ฆฌ์ด๋ค.
๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฝ์ฐ, ๊ฐ์ฅ ๊ธด ๋ณ์ ํญ์ ๋ง์ง๋ง ์์ (an[2])์ด๋ค.
๋ฐ๋ผ์ ์กฐ๊ฑด์ an[2] < an[0] + an[1]์ด์ด์ผ ํ๋ค.
• ํด๊ฒฐ ๋ฐฉ๋ฒ:
๋ฐฐ์ด์ ๋ง์ง๋ง ์์์ ๋๋จธ์ง ๋ ์์์ ํฉ์ ์ฌ๋ฐ๋ฅด๊ฒ ๋น๊ตํด์ผ ํ๋ค.
๋ฌธ์ 3: ๋ฌธ๋ฒ์ ์ค๋ฅ
• ์ค๋ฅ:
1. return 1๊ณผ return 2 ๋ค์ ์ธ๋ฏธ์ฝ๋ก (;)์ด ๋น ์ ธ ์๋ค.
2. ๋ณ์ ์ด๋ฆ an๊ณผ ๋ฉ์๋ ์ด๋ฆ์ ์๋ชป๋ ์กฐํฉ์ด ์ฝ๋ ๊ฐ๋ ์ฑ์ ๋จ์ด๋จ๋ฆฐ๋ค.
• ํด๊ฒฐ ๋ฐฉ๋ฒ: ๋ฌธ๋ฒ์ ์ค๋ฅ๋ฅผ ์์ ํ๊ณ ๋ณ์ ์ด๋ฆ์ ๋ช ํํ๊ฒ ์ ๋ฆฌํด์ผ ํ๋ค.
Solution ๐ก
import java.util.Arrays;
class Solution {
public int solution(int[] sides) {
// ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
Arrays.sort(sides);
//๊ฐ์ฅ ๊ธด ๋ณ์ด ๋๋จธ์ง ๋ ๋ณ์ ํฉ๋ณด๋ค ์์์ง ํ์ธ
if (sides[2] < sides[0] + sides[1]) {
return 1; // ์ผ๊ฐํ์ ๋ง๋ค ์ ์์
} else {
return 2; //์ผ๊ฐํ์ ๋ง๋ค ์ ์์.
}
}
}
๋ ผ๋ฆฌ์ ํ์ด ๊ณผ์
1. ๋ฐฐ์ด sides์ ์ธ ๋ณ์ ์ ๋ ฌํ๋ค. ์ด๋ฅผ ํตํด ๊ฐ์ฅ ๊ธด ๋ณ์ด ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๊ฐ ๋๋๋ก ํ๋ค.
2. ์ผ๊ฐํ์ ์ฑ๋ฆฝ ์กฐ๊ฑด์ ํ์ธํ๋ค:
• ๊ฐ์ฅ ๊ธด ๋ณ์ ๊ธธ์ด sides[2]๊ฐ ๋๋จธ์ง ๋ ๋ณ์ ํฉ sides[0] + sides[1]๋ณด๋ค ์์์ผ ์ผ๊ฐํ์ด ์ฑ๋ฆฝํ๋ค.
3. ์กฐ๊ฑด์ด ์ฐธ์ด๋ผ๋ฉด 1์ ๋ฐํํ๊ณ , ๊ฑฐ์ง์ด๋ผ๋ฉด 2๋ฅผ ๋ฐํํ๋ค.
Reference ๐
'๐ฐ๐ท ํ๊ตญ์ด (Korean) > Java Algorithm Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Java] ์ค๋ณต๋ ์ซ์ ๊ฐ์ (1) | 2025.01.02 |
|---|---|
| [Java] ๋ชจ์ ์ ๊ฑฐ (0) | 2024.12.30 |
| [Java] ์ ๊ณฑ์ ํ๋ณํ๊ธฐ (2) | 2024.12.29 |
| [Java] ํน์ ๋ฌธ์ ์ ๊ฑฐํ๊ธฐ (0) | 2024.12.29 |
| [Java] 10์ ๋ฐฐ์์ ์์ผ ๋ ๋ง๋ค ์ผ์ ์๊ฐ ๊น์ด๋ ๋ฌธ์ . (1) | 2024.12.26 |