
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/120818
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
๋จธ์ฑ์ด๋ค ์ท๊ฐ๊ฒ๋ 10๋ง ์ ์ด์ ์ฌ๋ฉด 5%, 30๋ง ์ ์ด์ ์ฌ๋ฉด 10%, 50๋ง ์ ์ด์ ์ฌ๋ฉด 20%๋ฅผ ํ ์ธํด์ค๋๋ค.
๊ตฌ๋งคํ ์ท์ ๊ฐ๊ฒฉ price๊ฐ ์ฃผ์ด์ง ๋, ์ง๋ถํด์ผ ํ ๊ธ์ก์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์.
์ ํ์ฌํญ
- 10 ≤ price ≤ 1,000,000
- price๋ 10์ ๋จ์๋ก(1์ ์๋ฆฌ๊ฐ 0) ์ฃผ์ด์ง๋๋ค.
- ์์์ ์ดํ๋ฅผ ๋ฒ๋ฆฐ ์ ์๋ฅผ returnํฉ๋๋ค.
์ ์ถ๋ ฅ ์priceresult
| 150,000 | 142,500 |
| 580,000 | 464,000 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- 150,000์์์ 5%๋ฅผ ํ ์ธํ 142,500์์ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- 580,000์์์ 20%๋ฅผ ํ ์ธํ 464,000์์ return ํฉ๋๋ค.
Approach 1 โ - ํ๋ฆฐ ๋์ ์ด๊ธฐ ์ฝ๋
class Solution {
int answer =0;
public int solution(int price) {
if (price >= 100000) {
retrun answer = price * 0.95;
} else if (price >= 300000) {
return answer = price * 0.90;
} else if (price >= 500000) {
return answer = price * 0.80;
}
}
return answer;
}
Approach 2 โญ - ๋์ ์ฝ๋ ๊ฐ์ ์
๋ฌธ์ ์ 1: ์กฐ๊ฑด๋ฌธ์ ์์
์กฐ๊ฑด๋ฌธ์ ์์์๋ถํฐ ํ๊ฐ๋ฉ๋๋ค. ๋ฐ๋ผ์ price >= 100000 ์กฐ๊ฑด์ด ๋จผ์ ์ฒ๋ฆฌ๋๋ฉด,
์ดํ์ ์กฐ๊ฑด๋ฌธ price >= 300000, price >= 500000์ ํ๊ฐ๋์ง ์๋๋ค.
์กฐ๊ฑด์ ์์๋ฅผ ํฐ ๊ฐ๋ถํฐ ์์ ๊ฐ์ผ๋ก ๋ฐ๊ฟ์ผ ํ๋ค.
๋ฌธ์ ์ 2: ์คํ
• retrun → return์ผ๋ก ์์ ํด์ผ ํ๋ค.
๋ฌธ์ ์ 3: ํ์ ๋ถ์ผ์น
• ํ ์ธ๋ ๊ฐ๊ฒฉ์ ๊ณ์ฐํ๋ ค๋ฉด price์ ํ ์ธ์จ์ ๊ณฑํด์ผ ํ์ง๋ง,
๊ณฑ์ ์ฐ์ฐ์์ ์ ์์ ์ค์๋ฅผ ํผํฉํ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค.
price * 0.95์ฒ๋ผ ๊ณ์ฐํ๋ฉด ๊ฒฐ๊ณผ๋ ์ค์(double)๊ฐ ๋๋ค.
์ ์๋ฅผ ๋ฐํํ๋ ค๋ฉด ํ ๋ณํ์ ๋ช ์์ ์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ๋ค.
๋ฌธ์ ์ 4: ๋ฆฌํด๊ฐ์ ํ ์ธ์ด ๋์ง ์์ ๊ฒฝ์ฐ๋ ๋ฐ์ํ์ฌ์ผ ํ๋ค.
return price; // ํ ์ธ ์กฐ๊ฑด์ ํด๋นํ์ง ์์ผ๋ฉด ์๋ ๊ฐ๊ฒฉ ๋ฐํ
๋ก ํ์ฌ์ if ์กฐ๊ฑด์ ํด๋นํ์ฌ ๋ด๋ถ ํจ์์์ price์ ์ด๋ค ๊ฐ์ด ๊ณฑํด์ ธ๋ return ์ผ๋ก ๋์์ค๋๋ก ์ด๋ฏธ ์ค์ ํด๋์๋ค.
๊ทธ๋์ if๋ฌธ ๋๋๊ณ ์ ์ฉ๋ ํ ์ธ ๊ฐ๊ฒฉ์ด ๋ฆฌํด๋๋๋ก ๋ณ๋๋ก ์ค์ ํ ํ์๋ ์๋ค.
๋ค๋ง ์ด ๋ชจ๋ ์กฐ๊ฑด์ด ํด๋น๋์ง ์์๋ ํ ์ธ์ด ์ ์ฉ๋์ง ์์ ๊ฐ๊ฒฉ๋ ๋ฆฌํด์ด ๋์ด์ผ ํ๋ฏ๋ก
return price;๋ ํ์์ด๋ค.
Solution ๐ก - ์ ๋ต ์ฝ๋
class Solution {
public int solution(int price) {
if (price >= 500000) {
return (int)(price * 0.80);
} else if (price >= 300000) {
return (int)(price * 0.90);
} else if (price >= 100000) {
return (int) (price * 0.95)
}
return price; // ํ ์ธ ์กฐ๊ฑด์ ํด๋นํ์ง ์์ผ๋ฉด ์๋ ๊ฐ๊ฒฉ ๋ฐํ
}
}
์ฃผ์ ์์ ์ฌํญ
1. ์กฐ๊ฑด๋ฌธ ์์๋ฅผ ํฐ ๊ฐ๋ถํฐ ์์ ๊ฐ์ผ๋ก ์ฌ์ ๋ ฌ.
2. return ์คํ ์์ .
3. ํ ์ธ๋ ๊ฐ์ ๊ณ์ฐํ ํ int๋ก ๋ณํ.
Reference ๐
'๐ฐ๐ท ํ๊ตญ์ด (Korean) > Java Algorithm Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Java] ๋ฌธ์์ด์ ์ฌ์ฉ๋ ๋ฌธ์๋ ๋ช ๊ฐ์ผ๊น? (0) | 2025.01.02 |
|---|---|
| [Java] ๋ด ์์ฐ์ผ๋ก ๋ช ์์ ์ปคํผ๋ฅผ ๋ง์ค ์ ์์๊น?_๋ฆฌํด์ ๋ฐ๋ก ๋ฐฐ์ด ๋ง๋ค๊ธฐ/ ๋จ์๋์ %๋ก ํ๋ฒ์ (0) | 2025.01.02 |
| [Java] ์ค๋ณต๋ ์ซ์ ๊ฐ์ (1) | 2025.01.02 |
| [Java] ๋ชจ์ ์ ๊ฑฐ (0) | 2024.12.30 |
| [Java] ์ผ๊ฐํ์ ์์ฑ์กฐ๊ฑด (0) | 2024.12.29 |