๐ ๋ฌธ์ ์ค๋ช
์ ์ ๋ฐฐ์ด arr๊ณผ ์์ฐ์ k๊ฐ ์ฃผ์ด์ง๋๋ค.
- k๊ฐ ํ์๋ผ๋ฉด arr์ ๋ชจ๋ ์์์ k๋ฅผ ๊ณฑํฉ๋๋ค.
- k๊ฐ ์ง์๋ผ๋ฉด arr์ ๋ชจ๋ ์์์ k๋ฅผ ๋ํฉ๋๋ค.
์ดํ ๋ณํ๋ ๋ฐฐ์ด์ ๋ฐํํ๋ solution ํจ์๋ฅผ ์์ฑํ์ธ์.
โจ ์ด๊ธฐ ํ์ด
์ฒ์์๋ ์๋์ ๊ฐ์ด for-each ๋ฐ๋ณต๋ฌธ ์์์ ์กฐ๊ฑด๋ฌธ์ ๋๋ฆฌ๋ฉฐ ๊ตฌํํ์ต๋๋ค:
class Solution {
public int[] solution(int[] arr, int k) {
int i = 0;
int[] answer = new int[arr.length];
for (int n : arr) {
if (k % 2 == 0) {
answer[i] = n + k;
} else {
answer[i] = n * k;
}
i++;
}
return answer;
}
}
์ฒ์์๋ ๋ฌธ์ ๋ฅผ ๋น ๋ฅด๊ฒ ํธ๋ ๋ฐ ์ง์คํด์ ์์ฑํ์ต๋๋ค.
ํ์ง๋ง k๋ ๋ฐ๋ณต๋ฌธ๋ง๋ค ๋ฐ๋๋ ๊ฐ์ด ์๋๋ฏ๋ก, ๋งค๋ฒ if ์กฐ๊ฑด์ ๊ฒ์ฌํ ํ์๊ฐ ์๋ค๋ ์ ์ด ์์ฌ์ ์ต๋๋ค.
๐ง ๊ฐ์ ๋ ํ์ด
k์ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ฝ๋๋ฅผ ๋ ๊ฐ๋๋ก ๋ถ๋ฆฌํด์, ๋ถํ์ํ ์กฐ๊ฑด๋ฌธ ๋ฐ๋ณต์ ์ ๊ฑฐํด๋ณด์์ต๋๋ค:
import java.util.stream.IntStream;
class Solution {
public int[] solution(int[] arr, int k) {
return k % 2 == 0 ?
IntStream.of(arr).map(n -> n + k).toArray() :
IntStream.of(arr).map(n -> n * k).toArray();
}
}
์ด๋ ๊ฒ ํ๋ฉด k๊ฐ ํ์์ธ์ง ์ง์์ธ์ง๋ฅผ ํ ๋ฒ๋ง ๊ฒ์ฌํ๊ณ , ์ดํ ๋ฐ๋ณต๋ฌธ์์๋ ๊ณ์ฐ๋ง ์ํํ๊ฒ ๋ฉ๋๋ค.
๐ง ๋๋ ์
- if๋ฌธ ํ๋์ง๋ง, ๋ฐ๋ณต๋ฌธ ์์ ๋งค๋ฒ ๋ฑ์ฅํ๋ฉด ์ฑ๋ฅ ์ ํ๋ก ์ด์ด์ง ์ ์์ต๋๋ค.
- ํนํ ์ ๋ ฅ ๋ฐ์ดํฐ๊ฐ ์ปค์ง์๋ก ์ด๋ฐ ์์ ์ต์ ํ๊ฐ ์ค์ํ ์ต๊ด์ด ๋ฉ๋๋ค.
- ๋ฌธ์ ํ์ด์์๋ ์กฐ๊ฑด์ด ๊ณ ์ ๊ฐ์ด๋ผ๋ฉด ๋ฐ๋ณต ์ ์ ๋ถ๊ธฐ ์ฒ๋ฆฌํ๋ ์ต๊ด์ ๋ค์ด๋ ๊ฒ์ด ์ข์ต๋๋ค.
๐ก ๋ณด๋์ค: Java ์คํธ๋ฆผ์ผ๋ก ๊ตฌํํ๊ธฐ
Java์ Stream API๋ฅผ ์ฌ์ฉํ๋ฉด ๋ ๊ฐ๊ฒฐํ๊ฒ ์์ฑํ ์๋ ์์ต๋๋ค:
import java.util.stream.IntStream;
class Solution {
public int[] solution(int[] arr, int k) {
return k % 2 == 0 ?
IntStream.of(arr).map(n -> n + k).toArray() :
IntStream.of(arr).map(n -> n * k).toArray();
}
}
๋ค๋ง ์คํธ๋ฆผ์ ๊ฐ๋ ์ฑ์ ์ข์ง๋ง ์ฑ๋ฅ ์ธก๋ฉด์์๋ ๋จ์ ๋ฐ๋ณต๋ณด๋ค ์ฝ๊ฐ ๋๋ฆด ์ ์์ผ๋, ์ํฉ์ ๋ง๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
โ ์ ๋ฆฌ
- ์กฐ๊ฑด์ด ๋ฐ๋ณต๋ฌธ ๋ด๋ถ์์ ๋ถํ์ํ๊ฒ ๋ฐ๋ณต๋์ง ์๋๋ก ์ฒ๋ฆฌํ๋ ๊ฒ์ด ์ค์.
- Java์ ๊ธฐ์ด ๋ฌธ๋ฒ์ ํ์ฉํ๋ฉด์๋, ์ฑ๋ฅ ์ต์ ํ ์ต๊ด์ ๊ธฐ๋ฅผ ์ ์๋ ์ข์ ๋ฌธ์ ์๋ค.
'๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| ์ ์ฌ๊ฐํ์ผ๋ก ๋ง๋ค๊ธฐ - Programmers (0) | 2025.06.16 |
|---|---|
| ์ ์๋ฅผ ๋์ ํ์ผ๋ก ๋ฐฐ์นํ๊ธฐ - Programmers (1) | 2025.06.13 |
| ํ๋ก๊ทธ๋๋จธ์ค ๋ฐฐ์ด๋ง๋ค๊ธฐ 2 (0) | 2024.11.13 |