_{이 도전은 영감 이 지금 삭제 질문입니다.}

양의 정수 N 을 입력으로 취하고 아래 패턴을 따르는 숫자 1 .. N ² 의 행렬을 출력하십시오 .

첫 번째 행에 1 .. N 을 채우고 마지막 행 (행 번호 N )을 (N + 1) .. 2N 으로 채우고 두 번째 행을 (2N + 1) .. 3N으로 채우고 채워질 때까지 계속하십시오 모든 행.

출력 형식은 유연하므로 목록 목록 등이 허용됩니다.

N = 1
1

N = 2
1  2
3  4

N = 3
1  2  3
7  8  9
4  5  6

N = 4
 1  2  3  4
 9 10 11 12
13 14 15 16
 5  6  7  8

N = 5
 1  2  3  4  5
11 12 13 14 15
21 22 23 24 25
16 17 18 19 20
 6  7  8  9 10

표준 규칙이 적용됩니다. 각 언어에서 가장 짧은 바이트 단위의 답이 이깁니다. 언제나처럼 설명이 권장됩니다.

05AB1E , 13 8 바이트

Rod 덕분에 5 바이트 절약

nLô«āÉÏ

온라인으로 사용해보십시오!

설명

n           # push input^2
 L          # push range [1 ... input^2]
  ô         # split into pieces each the size of the input
   «       # append the reverse of this 2D-list
     ā      # push range [1 ... len(list)]
      É     # check each element for oddness
       Ï    # keep only the elements in the 2D list which are true in this list

루비 , 53 바이트

->n{r=*1..n*n;n.times{|x|p r.slice!(r[x*=n]?x:-n,n)}}

설명:

모든 숫자를 먼저 단일 배열에 넣은 다음 각 반복마다 한 줄씩 건너 뛰어 배열을 슬라이스하십시오. 첫 번째 (n / 2 + n % 2) 반복 후에는 건너 뛸 것이 없으며 나머지 모든 줄을 뒤로 가져옵니다.

온라인으로 사용해보십시오!

파이썬 2 , 75 바이트

def f(n):a=range(n);print[[i*n-~j for j in a]for i in a[::2]+a[~(n%2)::-2]]

온라인으로 사용해보십시오!

자바 스크립트, 68 바이트

@ user71546이 저장 한 3 바이트 저장 편집

먼저 명백한 경로를 따라 시도 하십시오 .1부터 계산하고 양쪽에서 배열을 외부에서 내부로 채우십시오.

n=>(v=0,q=[...Array(n)]).map((_,i)=>q[i&1?--n:i/2]=q.map(_=>++v))&&q

테스트

var F=
n=>(v=0,q=[...Array(n)]).map((_,i)=>q[i&1?--n:i/2]=q.map(_=>++v))&&q

function test() {
  var n=+N.value;
  O.innerHTML = '<tr><td>'
  +F(n).map(r=>r.join('</td><td>')).join('</td></tr><tr><td>')
  +'</td></tr>'
}

test()

#O { margin: 1em }
td { text-align: right }

<input id=N type=number min=1 value=5 oninput='test()'>
<table id=O>

하스켈 , 62 바이트

(0#)
m#n|m>=n^2=[]|k<-m+n=[m+1..k]:(k+n)#n++[[k+1..k+n]|k<n^2]

온라인으로 사용해보십시오! 출력은 목록의 목록입니다 (예 : (0#) 3yield) [[1,2,3],[7,8,9],[4,5,6]].

> <> , 51 + 3 = 54 47 바이트

:&v
?!\1-:&:&*}}r:
 ~\
!~>1+::n&:&%:a84*@@?$~o?

온라인으로 사용해보십시오!

-v플래그를 사용하여 프로그램 시작시 스택 맨 위에 입력이 예상됩니다 . 출력은 단일 공백으로 구분 된 정렬되지 않은 숫자로 구성되며 각 줄은 단일 줄 바꿈으로 구분됩니다. 의 출력 예 N=5:

1 2 3 4 5
11 12 13 14 15
21 22 23 24 25
16 17 18 19 20
6 7 8 9 10

... 다음에 단일 개행이옵니다. 프로그램이 오류 ( something smells fishy...) 와 함께 종료 되지만 STDOUT보다는 STDERR에 있습니다.

설명 :

첫 번째 줄은 단순히 복사본을 N레지스터에 저장합니다 .

두 번째 줄은에서 1을 빼고 N이것을 곱한 N다음 스택의 맨 아래로 회전 한 다음 전체 스택을 뒤집어 각 출력 행에 대한 오프셋을 만듭니다 . 스택 상단의 숫자가 0에 도달하면 스택은 다음과 같아야합니다 (예 :) N=5.

5 15 20 10 0 0

세 번째 줄은 0스택 상단 에서 복제본 을 버립니다 .

네 번째 줄은 스택의 상단을 증가시키고 그 복사본을 출력합니다. 그런 다음 mod를 가져 와서 N공백이나 줄 바꿈을 인쇄해야하는지, 스택의 맨 위를 버려야하는지 여부를 결정하는 데 사용됩니다-인쇄 된 마지막 숫자가 x이면 x mod N == 0해당 출력 행의 끝에 도달했음을 나타냅니다. . 1+빈 스택에서 실행될 때 실행이 종료 되고 종료 오류가 발생합니다.

이전 버전

이것은 명시 적으로 실행을 끝내기 위해 빈 스택을 확인했으며 -v플래그 사용을 위해 3 바이트도 포함 시켰습니다.

:&v
?!\1-:&:&*}}r:
 ~\
!;>1+::n&:&%:a84*@@?$~o?!~l?

온라인으로 사용해보십시오!

펄 5 , -p 52 51 바이트

#!/usr/bin/perl -p
map{$|--?$\="@0
".$\:say"@0";$_+=@0for@0}@0=1..$_}{

온라인으로 사용해보십시오!

자바 (OpenJDK 9) , 101 바이트

n->{int x[][]=new int[n][n],i=0,j;for(;i<n;i++)for(j=0;j<n;)x[i%2<1?i/2:n+~i/2][j]=++j+i*n;return x;}

온라인으로 사용해보십시오!

크레딧

• Kevin Cruijssen 덕분에 -4 바이트 .

자바 스크립트 (ES6), 69 68 바이트

n=>[...Array(n)].map((_,i,a,j=((i*=2)<n?i:n+n+~i)*n)=>a.map(_=>++j))

글을 게시하기 전에 아웃 고프되었지만 여기에 있습니다. 편집 : @KevinCruijssen 덕분에 1 바이트가 절약되었습니다.

젤리 , 10 바이트

²ss2Ṛj@/Fs

온라인으로 사용해보십시오!

작동 원리

²ss2Ṛj@/Fs  Main link. Argument: n

²           Square; yield n².
 s          Split; promote n² to [1, ..., n²] and split it into chuks of length n.
  s2        Split 2; generate all non-overlapping pairs of chunks.
            If n is odd, this leaves a singleton array at the end.
    Ṛ       Reverse the order.
     j@/    Reduce by join with reversed arguments.
            In each step, this places the first and second element of the next pair
            at the top and bottom of the accumulator.
        Fs  Flatten and split to restore the matrix shape.

Stax , 10 바이트

│æ╘▐⌡r▌═∟Y

온라인으로 실행 및 디버깅

동일한 프로그램의 해당 ASCII 표현은 12 자입니다.

JRx/r{]+rFmJ

작동 방식은 다음과 같습니다.

JR              range [1 .. x^2] where x=input
  x/            split into subarrays of size x
    r           reverse
     {   F      for each subarray, execute block
      ]+r       concat array, and reverse result
          m     for each row, output ...
           J        each subarray joined by spaces

젤리 , 13 ... 6 바이트

-1 바이트를위한 JonathanAllan 에게 감사합니다 !

²sm0m2

온라인으로 사용해보십시오!

05AB1E 답변과 동일한 알고리즘을 사용하십시오.

R , 70 59 47 바이트

function(n)matrix(1:n^2,n,,T)[c(1:n,n:1)*!0:1,]

온라인으로 사용해보십시오!

4 바이트 골프를 해준 Robin Ryder 에게 감사를 드렸습니다.

행렬을 반환합니다. matrix를 순서대로 구성한 [[1 2 3] [4 5 6] [7 8 9]]다음 행을 재정렬합니다.

파이썬 2 , 72 68 63 바이트

^{Neil 덕분에 -4 바이트}

def f(n):w=zip(*[iter(range(1,n*n+1))]*n);print(w+w[::-1])[::2]

온라인으로 사용해보십시오!

옥타브 , 102 바이트

n=input('');A=B=vec2mat(1:n*n,n);i=j=0;do
B(++i,:)=A(++j,:);if++j<n
B(n-i+1,:)=A(j,:);end;until j>=n
B

온라인으로 사용해보십시오!

C (gcc) , 110 바이트

i,c,t,b;f(a,n)int*a;{for(b=n-1;i<n*n;t++,b--){for(c=0;c<n;)a[t*n+c++]=++i;for(c=0;c<n&i<n*n;)a[b*n+c++]=++i;}}

온라인으로 사용해보십시오!

행에 대해 2 개의 인덱스 (상단에서 시작하는 인덱스와 하단에서 시작하는 인덱스)를 번갈아 가면서 배열을 채 웁니다. 맨 위 행 인덱스는 0에서 시작하여 2 행마다 증가합니다. 맨 아래 행 인덱스는 n-1에서 시작하여 2 행마다 감소합니다.

언 골프 드 :

void f(int* a, int n)
{
    //i = value to be written [1,n]; c = column index; t = top row index; b = bottom row index
    for(int i=1, c=0, t=0, b=n-1;
        i <= n*n; //when i = n*n, we have written all the values and we're done
        t++, b--) //t increments every 2 rows, b decrements every 2 rows
    {
        //write out 2 rows per loop

        //first row: fill out row at t
        for(c=0; c<n; c++, i++)
            a[t*n+c]=i;

        //second row: fill out row at b
        //this step will be skipped on the final loop for odd values of n, hence the (i<=n*n) test
        for(c=0; c<n && i<=n*n; c++, i++) 
            a[b*n+c]=i;
    }
}

C ++ + 범위 V3 , 159 바이트

#include<range/v3/all.hpp>
using namespace ranges::view;

[](int n){auto r=iota(1,n*n+1)|chunk(n);return concat(r|stride(2),r|reverse|drop(n%2)|stride(2));}

완드 박스에 라이브

이후 2 줄 바꿈을 계산하지 않음 using namespace range::view . 그들은 람다에서 수입품을 분리하기 위해 거기에 있습니다.

약간 흥미로운 사실 ​​:이 솔루션은 힙 할당을하지 않습니다. O(1)우주 의 문제를 해결합니다 .

설명:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): 모든 n요소가 함께[1 ... n] [n+1 ... 2*n] ...
3. 전화 해 r
4. r | stride(2): 다른 모든 요소를 ​​취하십시오. [1 ... n] [2*n+1...] ...
5. 그것을 다음과 연결하십시오.
6. r | reverse | drop(n % 2): 반대로, 홀수 인 [1 ... n]경우 항 을 삭제합니다 n(홀수 행이 있고 첫 번째 항만 한 번만 인쇄하려고 함). 내가 할 수 있어야하는 것처럼 보이지만 r | reverse | take어떤 이유로 든 작동하지 않습니다.
7. stride(2)다시, 다른 모든 요소를 ​​가져 가라. 이번에는 반대입니다.

더 읽기 쉽고 테스트 가능 :

#include <range/v3/all.hpp>
using namespace ranges::view;

auto f(int n)
{
    auto rows = iota(1, n * n + 1)
        | chunk(n);
    return concat(
        rows | stride(2),
        rows
            | reverse
            | drop(n % 2)
            | stride(2));
}

#include <iostream>
int main(int argc, char** argv)
{
    std::cout << "N = " << argc << '\n';
    auto res = f(argc);

    for (auto const& row : res | bounded) {
        for (auto const& elem : row | bounded) {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }
}

젤리 , 11 바이트

s2ZU2¦Ẏị²s$

온라인으로 사용해보십시오!

CJam , 22 바이트

ri__*,:)/2/z[1W].{%:p}

온라인으로 사용해보십시오!

C (gcc) 80 78

이제이 솔루션이 잘못되었다는 것을 알았습니다.

i;f(n){for(i=0;i++<n*n;printf("\n%3d"+!!(~-i%n),i>n?n+(i+n>n*n?i%n?:n:i):i));}

온라인으로 사용해보십시오!

C (gcc) , 36 + 8 + 61 = 105 바이트

와 컴파일 -Dp=printf("%d ",i),i++%n;);puts("") -Dq=i,n)

f(q{g(1,i);}g(q{for(;p;i<n*n&&h(q;}h(q{for(n+i<n*n&&g(n+q;p;}

온라인으로 사용해보십시오!