_{Thử thách này được lấy cảm hứng từ điều này , bây giờ đã xóa câu hỏi.}

Lấy số nguyên dương N làm đầu vào và xuất ma trận có các số 1 .. N ² theo mẫu bên dưới:

Điền vào hàng đầu tiên bằng 1 .. N sau đó điền vào hàng cuối cùng (số hàng N ) bằng (N + 1) .. 2N , sau đó điền vào hàng thứ hai bằng (2N + 1) .. 3N và tiếp tục cho đến khi bạn điền tất cả các hàng.

Định dạng đầu ra là linh hoạt, vì vậy danh sách các danh sách, vv được chấp nhận.

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

Quy tắc tiêu chuẩn áp dụng. Câu trả lời ngắn nhất tính theo byte trong mỗi ngôn ngữ sẽ thắng. Giải thích được khuyến khích như mọi khi.

05AB1E , 13 8 byte

Đã lưu 5 byte nhờ Rod

nLô«āÉÏ

Hãy thử trực tuyến!

Giải trình

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

Ruby , 53 byte

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

Giải trình:

Đặt tất cả các số vào một mảng đầu tiên, sau đó cắt mảng bỏ qua một dòng cho mỗi lần lặp. Sau các lần lặp đầu tiên (n / 2 + n% 2), không còn gì để bỏ qua, sau đó lấy tất cả các dòng còn lại về phía sau.

Hãy thử trực tuyến!

Python 2 , 75 byte

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

Hãy thử trực tuyến!

JavaScript, 68 byte

Chỉnh sửa 3 byte đã lưu, được đánh dấu bởi @ user71546

Lần thử đầu tiên, theo lộ trình rõ ràng: đếm từ 1 và điền vào mảng từ cả hai bên, từ ngoài vào trong

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

Kiểm tra

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>

Haskell , 62 byte

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

Hãy thử trực tuyến! Đầu ra là một danh sách các danh sách, ví dụ (0#) 3sản lượng [[1,2,3],[7,8,9],[4,5,6]].

> <> , 51 + 3 = 54 47 byte

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

Hãy thử trực tuyến!

Đầu vào được dự kiến ​​ở trên cùng của ngăn xếp khi chương trình bắt đầu sử dụng -vcờ. Đầu ra bao gồm các số không liên kết được phân tách bằng các khoảng trắng đơn và mỗi dòng được phân tách bằng một dòng mới. Ví dụ đầu ra cho 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

... Tiếp theo là một dòng mới. Chương trình kết thúc với một lỗi (something smells fishy... ), nhưng đó là trên STDERR chứ không phải STDOUT.

Giải thích:

Dòng đầu tiên chỉ lưu trữ một bản sao của N trong sổ đăng ký.

Dòng thứ hai xây dựng phần bù cho mỗi hàng đầu ra bằng cách trừ 1 từ N, nhân số này bằng cách Nxoay nó xuống dưới cùng của ngăn xếp và sau đó đảo ngược toàn bộ ngăn xếp. Khi số trên cùng của ngăn xếp đạt 0, ngăn xếp sẽ trông như thế này (ví dụ sử dụng N=5):

5 15 20 10 0 0

Dòng thứ ba loại bỏ trùng lặp 0 từ đầu ngăn xếp.

Dòng thứ tư tăng đỉnh của ngăn xếp và xuất ra một bản sao của nó. Sau đó, đây được lấy mod Nvà được sử dụng để quyết định xem có nên in dấu cách hoặc dòng mới hay không và nếu phần trên cùng của ngăn xếp phải được loại bỏ - nếu số cuối được in là x, thì x mod N == 0chỉ ra rằng đã kết thúc hàng đầu ra đó . Thực thi kết thúc khi 1+được thực thi trên một ngăn xếp trống, ném lỗi kết thúc.

Phiên bản trước

Điều này rõ ràng đã kiểm tra một ngăn xếp trống để kết thúc thực hiện và tôi cũng bao gồm 3 byte cho việc -vsử dụng cờ.

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

Hãy thử trực tuyến!

Perl 5 , -p 52 51 byte

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

Hãy thử trực tuyến!

Java (OpenJDK 9) , 101 byte

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;}

Hãy thử trực tuyến!

Tín dụng

• -4 byte nhờ Kevin Cruijssen .

JavaScript (ES6), 69 68 byte

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

Vâng, nó đã vượt qua trước khi tôi có thể đăng nó nhưng dù sao thì đây là. Chỉnh sửa: Đã lưu 1 byte nhờ @KevinCruijssen.

Thạch , 10 byte

²ss2Ṛj@/Fs

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

²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 byte

│æ╘▐⌡r▌═∟Y

Chạy và gỡ lỗi trực tuyến

Đại diện ascii tương ứng của cùng một chương trình là 12 ký tự.

JRx/r{]+rFmJ

Đây là cách nó hoạt động.

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

Thạch , 13 ... 6 byte

Cảm ơn Jonathan Allan cho -1 byte!

²sm0m2

Hãy thử trực tuyến!

Sử dụng một thuật toán giống hệt với câu trả lời 05AB1E.

R , 70 59 47 byte

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

Hãy thử trực tuyến!

Cảm ơn Robin Ryder cho một golf 4 byte, sau đó tôi đã chơi gôn hơn nữa.

Trả về một ma trận; xây dựng matrixchuỗi theo thứ tự, ví dụ [[1 2 3] [4 5 6] [7 8 9]], sau đó sắp xếp lại các hàng.

Python 2 , 72 68 63 byte

^{-4 byte nhờ Neil}

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

Hãy thử trực tuyến!

Octave , 102 byte

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

Hãy thử trực tuyến!

C (gcc) , 110 byte

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;}}

Hãy thử trực tuyến!

Điền vào một mảng bằng cách xen kẽ giữa 2 chỉ số cho các hàng: một chỉ mục bắt đầu ở trên cùng và một chỉ số bắt đầu ở phía dưới. Chỉ số hàng trên cùng bắt đầu từ 0 và được tăng lên cứ sau 2 hàng; chỉ số hàng dưới cùng bắt đầu từ n-1 và giảm dần sau mỗi 2 hàng.

Ung dung:

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 ++ + Phạm vi V3 , 159 byte

#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));}

Sống trên Wandbox

Không tính 2 dòng mới sau using namespace range::view; họ chỉ ở đó để tách nhập khẩu từ lambda.

Thực tế khá thú vị: giải pháp này không phân bổ heap. Nó giải quyết vấn đề trong O(1)không gian.

Giải trình:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): mọi nyếu tố với nhau, vì vậy[1 ... n] [n+1 ... 2*n] ...
3. Gọi đó r
4. r | stride(2): lấy mọi yếu tố khác: [1 ... n] [2*n+1...] ...
5. nối nó với:
6. r | reverse | drop(n % 2): đảo ngược, sau đó bỏ [1 ... n]cụm từ nếu nlà số lẻ (sẽ có một số hàng lẻ và chúng tôi chỉ muốn in thuật ngữ đầu tiên một lần). Có vẻ như tôi chỉ có thể làm được r | reverse | take, nhưng điều đó không hiệu quả vì một số lý do.
7. stride(2)một lần nữa, lấy mọi yếu tố khác. Lần này là ngược lại.

Dễ đọc hơn và có thể kiểm tra:

#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';
    }
}

Thạch , 11 byte

s2ZU2¦Ẏị²s$

Hãy thử trực tuyến!

CJam , 22 byte

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

Hãy thử trực tuyến!

C (gcc) 80 78

Tôi thấy bây giờ giải pháp này là sai

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));}

Hãy thử trực tuyến!

C (gcc) , 36 + 8 + 61 = 105 byte

biên dịch với -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;}

Hãy thử trực tuyến!