_{Diese Herausforderung ist inspiriert von dieser nun gelöschten Frage.}

Nehmen Sie eine positive ganze Zahl N als Eingabe und geben Sie eine Matrix mit den Zahlen 1 .. N ^{2 aus} , die dem folgenden Muster folgt:

Füllen Sie die erste Zeile mit 1 .. N, dann füllen Sie die letzte Zeile (Zeilennummer N ) mit (N + 1) .. 2N , dann füllen Sie die zweite Zeile mit (2N + 1) .. 3N und fahren Sie fort, bis Sie gefüllt haben alle reihen.

Das Ausgabeformat ist flexibel, daher werden Listen usw. akzeptiert.

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

Es gelten Standardregeln. Die kürzeste Antwort in Bytes in jeder Sprache gewinnt. Erklärungen sind wie immer erwünscht.

05AB1E , 13 8 Bytes

5 Bytes gespart dank Rod

nLô«āÉÏ

Probieren Sie es online!

Erläuterung

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 Bytes

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

Erläuterung:

Fügen Sie zuerst alle Zahlen in ein einzelnes Array ein und schneiden Sie dann das Array, wobei Sie bei jeder Iteration eine Zeile überspringen. Nach den ersten (n / 2 + n% 2) Iterationen ist nichts mehr zu überspringen, und alle verbleibenden Zeilen werden rückwärts abgerufen.

Probieren Sie es online!

Python 2 , 75 Bytes

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

Probieren Sie es online!

JavaScript, 68 Bytes

Bearbeiten Sie 3 Bytes, die von @ user71546 gespeichert wurden

Versuchen Sie zunächst den offensichtlichen Weg zu gehen: Zählen Sie von 1 und füllen Sie das Array von beiden Seiten, von außen nach innen

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

Prüfung

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 Bytes

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

Probieren Sie es online! Ausgabe ist eine Liste von Listen, zB (0#) 3Erträge [[1,2,3],[7,8,9],[4,5,6]].

> <> , 51 + 3 = 54 47 Bytes

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

Probieren Sie es online!

Die Eingabe wird beim Programmstart über das -vFlag auf dem Stack erwartet . Die Ausgabe besteht aus nicht ausgerichteten Zahlen, die durch einzelne Leerzeichen voneinander getrennt sind. Jede Zeile wird durch eine neue Zeile voneinander getrennt. Beispielausgabe für 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

... gefolgt von einer einzelnen Zeile. Das Programm wird mit einem Fehler ( something smells fishy...) beendet, aber das steht auf STDERR und nicht auf STDOUT.

Erklärung:

In der ersten Zeile wird einfach eine Kopie von Nim Register gespeichert.

In der zweiten Zeile wird der Versatz für jede Ausgabezeile durch Subtrahieren von 1 N, Multiplizieren mit N, Drehen auf den Boden des Stapels und anschließendes Umkehren des gesamten Stapels gebildet. Wenn die Zahl oben auf dem Stapel 0 erreicht, sollte der Stapel folgendermaßen aussehen (Beispiel verwendet N=5):

5 15 20 10 0 0

In der dritten Zeile wird das Duplikat 0oben im Stapel verworfen.

Die vierte Zeile erhöht den oberen Bereich des Stapels und gibt eine Kopie davon aus. Dies wird dann mod genommen N, und dies wird verwendet, um zu entscheiden, ob ein Leerzeichen oder eine neue Zeile gedruckt werden soll und ob die Oberseite des Stapels verworfen werden soll - wenn die letzte gedruckte Zahl ist x, x mod N == 0zeigt dies an, dass das Ende dieser Ausgabezeile erreicht wurde . Die Ausführung endet, wenn 1+sie auf einem leeren Stapel ausgeführt wird, wodurch der Beendigungsfehler ausgelöst wird.

Vorherige Version

Dies prüfte explizit, ob ein leerer Stapel vorhanden war, um die Ausführung zu beenden, und ich bezog auch 3 Bytes für die -vFlag-Verwendung ein.

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

Probieren Sie es online!

Perl 5 , -p 52 51 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

Credits

• -4 Bytes dank Kevin Cruijssen .

JavaScript (ES6), 69 bis 68 Byte

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

Nun, es hat sich herausgerissen, bevor ich es posten konnte, aber hier ist es trotzdem. Bearbeiten: 1 Byte dank @KevinCruijssen gespeichert.

Gelee , 10 Bytes

²ss2Ṛj@/Fs

Probieren Sie es online!

Wie es funktioniert

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

│æ╘▐⌡r▌═∟Y

Führen Sie es online aus und debuggen Sie es

Die entsprechende ASCII-Darstellung desselben Programms umfasst 12 Zeichen.

JRx/r{]+rFmJ

So funktioniert das.

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

Jelly , 13 ... 6 Bytes

Danke JonathanAllan für -1 Byte!

²sm0m2

Probieren Sie es online!

Verwenden Sie einen identischen Algorithmus wie die 05AB1E-Antwort.

R , 70 59 47 Byte

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

Probieren Sie es online!

Vielen Dank an Robin Ryder für ein 4-Byte-Golf, das ich dann weiter ausbaute.

Gibt eine Matrix zurück; erstellt die matrixin-Sequenz, [[1 2 3] [4 5 6] [7 8 9]]ordnet dann z. B. die Zeilen neu an.

Python 2 , 72 68 63 Bytes

^{-4 Bytes dank Neil}

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

Probieren Sie es online!

Oktave , 102 Bytes

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

Probieren Sie es online!

C (gcc) , 110 Bytes

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

Probieren Sie es online!

Füllt ein Array aus, indem zwischen zwei Indizes für Zeilen gewechselt wird: Ein Index beginnt oben und einer beginnt unten. Der Index der obersten Zeile beginnt bei 0 und wird alle 2 Zeilen erhöht. Der untere Zeilenindex beginnt bei n-1 und wird alle 2 Zeilen dekrementiert.

Ungolfed:

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 ++ + Range V3 , 159 Bytes

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

Live auf Wandbox

Ohne die 2 Zeilen nach using namespace range::view; Sie sind nur dazu da, Importe vom Lambda zu trennen.

Leicht interessante Tatsache: Diese Lösung nimmt keine Heap-Zuweisungen vor. Es löst das Problem im O(1)Weltraum.

Erläuterung:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): alle nElemente zusammen, so[1 ... n] [n+1 ... 2*n] ...
3. Nennen Sie das r
4. r | stride(2): nimm jedes andere Element: [1 ... n] [2*n+1...] ...
5. verketten das mit:
6. r | reverse | drop(n % 2): umkehren, dann den [1 ... n]Begriff fallen lassen, wenn nungerade ist (es wird eine ungerade Anzahl von Zeilen geben und wir möchten den ersten Begriff nur einmal drucken). Es scheint, als könnte ich das einfach tun r | reverse | take, aber das funktioniert aus irgendeinem Grund nicht.
7. stride(2)nimm wieder jedes andere Element. Diesmal ist es umgekehrt.

Mehr lesbar und testbar:

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

Jelly , 11 Bytes

s2ZU2¦Ẏị²s$

Probieren Sie es online!

CJam , 22 Bytes

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

Probieren Sie es online!

C (gcc) 80 78

Ich sehe jetzt, dass diese Lösung falsch ist

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

Probieren Sie es online!

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

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

Probieren Sie es online!