๋ฌธ์ ์ค๋ช
์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ค์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๋ฐ๋ณ์ ๊ธธ์ด์ ๋์ด๊ฐ n์ธ ์ผ๊ฐํ์์ ๋งจ ์ ๊ผญ์ง์ ๋ถํฐ ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก ๋ฌํฝ์ด ์ฑ์ฐ๊ธฐ๋ฅผ ์งํํ ํ, ์ฒซ ํ๋ถํฐ ๋ง์ง๋ง ํ๊น์ง ๋ชจ๋ ์์๋๋ก ํฉ์น ์๋ก์ด ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- n์ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
n | result |
---|---|
4 | [1,2,9,3,10,8,4,5,6,7] |
5 | [1,2,12,3,13,11,4,14,15,10,5,6,7,8,9] |
6 | [1,2,15,3,16,14,4,17,21,13,5,18,19,20,12,6,7,8,9,10,11] |
๋ฌธ์ ํ์ด
๋ฌธ์ ์ ๊ทธ๋ฆผ์ ํ๊ณผ ์ด๋ก ๋ฐ๊พธ์ด ํํํด๋ณด๊ฒ ๋ค.
๋นจ๊ฐ ๊ฒ์ด ์ขํ(x,y) ๊ฐ์ด๋ค.
ํ๋ฅผ ์๋ง๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ฉด์ ํด๋น ์นธ์ ์ฐจ๋ก๋๋ก 1++ ํด์ ์ฆ๊ฐ์ํค๋ฉด ๋ฐฐ์ด๋ก ๋ฐํํ๊ธฐ ํธํ ๊ฒ์ด๋ค.
์๋ ๋ฐฉํฅ์ x๋ง ์ฆ๊ฐ, ์ค๋ฅธ์ชฝ ์ด๋์ y๋ง ์ฆ๊ฐ, ๋๊ฐ์ ์ด๋์ x,y๊ฐ ๋๋ค ๊ฐ์์ธ ๊ฒ์ ์์๊ฐ ์๋ค.
1๏ธโฃ ์ํํ๋ x์ขํ ๊ฐ์ด 3์ผ๋ก ๋๋๊ณ ๋ ๋๋จธ์ง๊ฐ 0์ผ ๋, ์๋๋ก ์ด๋ํ๋ค. ( y๊ฐ ๊ณ ์ , x๊ฐ๋ง์ฆ๊ฐ) -> ์ด๋ ๊ฒ ํ๋ ค๋ฉด y๊ฐ์ ๋ฐ๋ณตํ ๋ ์์์ ์ x์ขํ๋ถํฐ ํด์ฃผ๋ฉด ๋ ๊ฒ์ด๋ค.
2๏ธโฃ ๋๋จธ์ง๊ฐ 1์ผ ๋, y๊ฐ ์ฆ๊ฐํ๋ค. (x๊ฐ ๊ณ ์ , y๊ฐ๋ง ์ฆ๊ฐ)
3๏ธโฃ ๋๋จธ์ง๊ฐ 2์ผ๋, ๋๊ฐ์ ์ด๋์ด ๋ฐ์ํ๋ค.
** 1~n๊น์ง์ ํฉ์ n*(n+1)/2์ด๋ค.
์ ๋ต
class Solution {
public int[] solution(int n) {
// ์ธ ๋ฐฉํฅ ์กด์ฌ -> ์๋, ์ค๋ฅธ์ชฝ, ๋๊ฐ์ (x,y ๋๋ค ๊ฐ์)
int x = -1; // ์๋ ์ด๋์ x ์ขํ ๊ฐ์
int y = 0; // ์ค๋ฅธ์ชฝ ์ด๋์ y ์ขํ ์ฆ๊ฐ
int num = 1; // ์ผ๊ฐ ๋ฌํฝ์ด ์ฑ์ฐ๊ธฐ ๊ฐ
// ์ผ๊ฐํ
int[][] tri = new int[n][n];
// ์ผ๊ฐํ์ ํฌ๊ธฐ ( 1 ~ n ๊น์ง ํฉ)
int[] answer = new int[n*(n+1)/2];
for(int i = 0; i < n; i++) {
for(int j = i; j < n; j++) {
if(i % 3 == 0) { // ์๋
x++;
}
else if(i % 3 == 1) { // ์ค๋ฅธ์ชฝ
y++;
}
else if(i % 3 == 2) { // ๋๊ฐ์
x--;
y--;
}
tri[x][y] = num++;
}
}
// ๊ฒฐ๊ณผ ๋ฐฐ์ด์ ๋ด๊ธฐ
int index = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(tri[i][j] == 0) break;
answer[index++] = tri[i][j];
}
}
return answer;
}
}
์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด ์ผ๊ฐ ๋ฌํฝ์ด