
Problem ๐ป
https://school.programmers.co.kr/learn/courses/30/lessons/12954
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ฌธ์ ์ค๋ช
ํจ์ solution์ ์ ์ x์ ์์ฐ์ n์ ์ ๋ ฅ ๋ฐ์, x๋ถํฐ ์์ํด x์ฉ ์ฆ๊ฐํ๋ ์ซ์๋ฅผ n๊ฐ ์ง๋๋ ๋ฆฌ์คํธ๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค. ๋ค์ ์ ํ ์กฐ๊ฑด์ ๋ณด๊ณ , ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
์ ํ ์กฐ๊ฑด
- x๋ -10000000 ์ด์, 10000000 ์ดํ์ธ ์ ์์ ๋๋ค.
- n์ 1000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
xnanswer| 2 | 5 | [2,4,6,8,10] |
| 4 | 3 | [4,8,12] |
| -4 | 2 | [-4, -8] |
Approach 1 โ- ๋์ ์ด๊ธฐ ์ ๊ทผ๋ฒ
long[]์ ๊ฐ ์์๋ฅผ +x์ฉํ์ฌ n๊ฐ ๋ง๋ค์ด์ผ ํ๋ค.
1. array[] long = new array[n];
2. long[0] = x; long[1] = x+x; long[2] = x+x+x์ด๋ฏ๋ก
for๋ฌธ์ ์ด์ฉํด ๋ง๋ค ์ ์๋ค.
3. for (int i = 0; i <= 5; i ++) {
long[i] = x * (i+1);
}
4. long[]๋ฅผ ๋ฆฌํดํ๋ค
Approach 2 โญ - ๋์ ์ ๊ทผ๋ฒ์ ๋ํ ํ๊ฐ
๋น์ ์ ์ ๊ทผ ๋ฐฉ์๊ณผ ๋ ผ๋ฆฌ๋ ๋งค์ฐ ์ข์ต๋๋ค. for ๋ฌธ์ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์์ฑํ๊ณ ๊ฐ์ ๊ณ์ฐํ๋ ค๋ ์์ด๋์ด๋ ์ ํํ๋ฉฐ, x * (i + 1)๋ฅผ ํตํด ์ฆ๊ฐํ๋ ๊ฐ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ ๊ฒ๋ ๋ง์ต๋๋ค. ๋ค๋ง, ์ฝ๋์ ๋ช ๊ฐ์ง ์ธ๋ถ์ ์ธ ์์ ๋ฐ ๋ณด์ ์ฌํญ์ด ์์ต๋๋ค.
Solution ๐ก
class Solution {
public long[] solution(int x, int n) {
long[] result = new long[n]; // ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ฐฐ์ด ์์ฑ
for (int i = 0; i < n; i++) { // 0๋ถํฐ n-1๊น์ง ๋ฐ๋ณด
result[i] = (long) x * (i +1); // ๊ฐ ์์์ x์ ๋ฐฐ์๋ฅผ ๊ณ์ฐ
}
return result; // ๊ฒฐ๊ณผ ๋ฐฐ์ด ๋ฐํ
}
๋ ผ๋ฆฌ์ ํ์ด ๊ณผ์ :
1. long ๋ฐฐ์ด ์์ฑ
- ๋ฌธ์ ์ ์กฐ๊ฑด์์ x์ n์ ๊ฐ์ด ํด ์ ์์ผ๋ฏ๋ก, ๊ฒฐ๊ณผ ๋ฐฐ์ด์ long[] ํ์ ์ด์ด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด, x = 10,000,000์ด๊ณ n = 1,000์ธ ๊ฒฝ์ฐ, x * n์ ๊ฐ์ด int ๋ฒ์๋ฅผ ์ด๊ณผํ ์ ์๋ค. ๋ฐ๋ผ์ long ํ์ ๋ฐฐ์ด์ ์ฌ์ฉํด์ผ ํ๋ค.
2. ๋ฐฐ์ด ์ด๊ธฐํ
- new long[n]๋ฅผ ์ฌ์ฉํด ํฌ๊ธฐ๊ฐ n์ธ ๋ฐฐ์ด์ ์์ฑํ๋ค.
3. ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ฐ ๊ณ์ฐ
for ๋ฌธ์ ์ฌ์ฉํ์ฌ i = 0๋ถํฐ n - 1๊น์ง ๋ฐ๋ณตํ๋ค.
๊ฐ ๋ฐ๋ณต์์ x์ ๋ฐฐ์๋ฅผ ๊ณ์ฐํ๊ณ result[i]์ ์ ์ฅํ๋ค.
i + 1์ x์ 1๋ฐฐ, 2๋ฐฐ, …, n๋ฐฐ๋ฅผ ๋ํ๋ธ๋ค.
4. ๋ฐฐ์ด ๋ฐํ
๊ณ์ฐ์ด ์๋ฃ๋ ๋ฐฐ์ด์ ๋ฐํํ๋ค.
๋ด๊ฐ ๋ณด์ํด์ผ ํ ์ :
1. ๋ฐฐ์ด ์ ์ธ ๋ฐฉ์
array[] long = new array[n];๋ก ์์ฑํ๋๋ฐ, ์ด๋ ๋ฌธ๋ฒ์ ์ผ๋ก ํ๋ ธ๋ค.
• ์ฌ๋ฐ๋ฅธ ์ ์ธ: long[] array = new long[n];
2. ๋ฐ๋ณต๋ฌธ์ ์กฐ๊ฑด
• for (int i = 0; i <= 5; i++)์์ i <= 5๋ ํน์ ๊ฐ 5๊น์ง๋ง ๋ฐ๋ณตํ๋ฏ๋ก, ์ด๋ฅผ ์ผ๋ฐ์ ์ธ n๊น์ง ๋ฐ๋ณตํ๋๋ก ์์ ํด์ผ ํ๋ค
: i < n.
3. ์ฝ๋์ ๊ฐ๋ ์ฑ
• ๊ฐ๋ ์ฑ์ ๋์ด๊ธฐ ์ํด ๋ฐฐ์ด์ ์ด๋ฆ์ ๋ ๋ช ํํ๊ฒ ์ง์ ํ๋ ๊ฒ์ด ์ข๋ค. ์: result ๋๋ answer.
4. ์๋ฃํ ์ฒ๋ฆฌ
• x๊ฐ int ํ์ ์ด์ง๋ง x * (i + 1)์ long ๋ฒ์๋ก ํ์ฅ๋ ์ ์์ผ๋ฏ๋ก ๋ช ์์ ์ผ๋ก (long) x๋ฅผ ๋ณํํ๋ ๊ฒ์ด ์ข๋ค.
๋ณด์๋ ๋ ผ๋ฆฌ:
1. long[] ๋ฐฐ์ด์ new long[n]์ผ๋ก ์์ฑํ๋ค. (array[] long์ ๋ฌธ๋ฒ ์ค๋ฅ์.)
2. ๋ฐ๋ณต๋ฌธ์ 0๋ถํฐ n - 1๊น์ง ์ํํ๋ฉฐ, ๊ฐ ๋ฐฐ์ด ์์์ x์ ๋ฐฐ์๋ฅผ ์ ์ฅํ๋ค.
3. ๋ฐ๋ณต๋ฌธ์ ์กฐ๊ฑด์ ๋ฐฐ์ด์ ํฌ๊ธฐ n์ ๋ฐ๋ผ ๋์ ์ผ๋ก ์ค์ ํด์ผ ํ๋ค.
4. x * (i + 1) ์ฐ์ฐ์ด long ํ์ ์ผ๋ก ์์ ํ๊ฒ ์ฒ๋ฆฌ๋๋๋ก ํ๋ณํ์ ์ถ๊ฐํ๋ค.