_{Ce défi est inspiré par cette question désormais supprimée.}

Prenez un entier positif N en entrée et sortez une matrice avec les nombres 1 .. N ² qui suit le modèle ci-dessous:

Remplissez la première ligne avec 1 .. N puis remplissez la dernière ligne (numéro de ligne N ) avec (N + 1) .. 2N , puis remplissez la deuxième ligne avec (2N + 1) .. 3N et continuez jusqu'à ce que vous ayez rempli toutes les lignes.

Le format de sortie est flexible, donc la liste des listes etc. est acceptée.

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

Des règles standard s'appliquent. La réponse la plus courte en octets dans chaque langue l'emporte. Les explications sont encouragées comme toujours.

05AB1E , 13 8 octets

Enregistré 5 octets grâce à Rod

nLô«āÉÏ

Essayez-le en ligne!

Explication

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

Rubis , 53 octets

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

Explication:

Mettez d'abord tous les nombres dans un seul tableau, puis coupez le tableau en sautant une ligne pour chaque itération. Après les premières (n / 2 + n% 2) itérations, il ne reste plus rien à sauter, puis récupérez toutes les lignes restantes.

Essayez-le en ligne!

Python 2 , 75 octets

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

Essayez-le en ligne!

JavaScript, 68 octets

Modifier 3 octets enregistrés, aiguisé par @ user71546

Essayez d'abord, en suivant l'itinéraire évident: comptez à partir de 1 et remplissez le tableau des deux côtés, de l'extérieur vers l'intérieur

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

Tester

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 octets

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

Essayez-le en ligne! La sortie est une liste de listes, par exemple les (0#) 3rendements [[1,2,3],[7,8,9],[4,5,6]].

> <> , 51 + 3 = 54 47 octets

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

Essayez-le en ligne!

Une entrée est attendue en haut de la pile au démarrage du programme en utilisant l' -vindicateur. La sortie se compose de nombres non alignés séparés par des espaces simples, et chaque ligne est séparée par une seule nouvelle ligne. Exemple de sortie pour 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

... suivi d'une seule nouvelle ligne. Le programme se termine avec une erreur ( something smells fishy...), mais c'est sur STDERR plutôt que sur STDOUT.

Explication:

La première ligne stocke simplement une copie de Ndans le registre.

La deuxième ligne crée le décalage pour chaque ligne de sortie en soustrayant 1 de N, en multipliant cela par N, en le tournant vers le bas de la pile, puis en inversant la pile entière. Lorsque le nombre en haut de la pile atteint 0, la pile devrait ressembler à ceci (l'exemple utilise N=5):

5 15 20 10 0 0

La troisième ligne supprime le doublon 0du haut de la pile.

La quatrième ligne incrémente le haut de la pile et sort une copie de celle-ci. Ceci est ensuite pris mod N, et il est utilisé pour décider si un espace ou un retour à la ligne doit être imprimé, et si le haut de la pile doit être jeté - si le dernier numéro imprimé est x, x mod N == 0indique alors que la fin de cette ligne de sortie a été atteinte . L'exécution se termine lorsqu'elle 1+est exécutée sur une pile vide, ce qui déclenche l'erreur de terminaison.

La version précédente

Cela a explicitement vérifié la présence d'une pile vide pour terminer l'exécution, et j'incluais également 3 octets pour l' -vutilisation de l' indicateur.

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

Essayez-le en ligne!

Perl 5 , -p 52 51 octets

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

Essayez-le en ligne!

Java (OpenJDK 9) , 101 octets

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

Essayez-le en ligne!

Crédits

• -4 octets grâce à Kevin Cruijssen .

JavaScript (ES6), 69 68 octets

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

Eh bien, il a été dépassé avant que je puisse le poster, mais le voici quand même. Edit: 1 octet enregistré grâce à @KevinCruijssen.

Gelée , 10 octets

²ss2Ṛj@/Fs

Essayez-le en ligne!

Comment ça fonctionne

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

│æ╘▐⌡r▌═∟Y

Exécutez-le et déboguez-le en ligne

La représentation ascii correspondante du même programme est de 12 caractères.

JRx/r{]+rFmJ

Voici comment ça fonctionne.

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

Gelée , 13 ... 6 octets

Merci JonathanAllan pour -1 octet!

²sm0m2

Essayez-le en ligne!

Utilisez un algorithme identique à la réponse 05AB1E.

R , 70 59 47 octets

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

Essayez-le en ligne!

Merci à Robin Ryder pour un golf de 4 octets, que j'ai ensuite approfondi.

Renvoie une matrice; construit le matrixen séquence, par exemple [[1 2 3] [4 5 6] [7 8 9]],, puis réorganise les lignes.

Python 2 , 72 68 63 octets

^{-4 octets grâce à Neil}

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

Essayez-le en ligne!

Octave , 102 octets

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

Essayez-le en ligne!

C (gcc) , 110 octets

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

Essayez-le en ligne!

Remplit un tableau en alternant entre 2 indices pour les lignes: un index commençant en haut et un commençant en bas. L'index de la ligne supérieure commence à 0 et est incrémenté toutes les 2 lignes; l'index de la ligne du bas commence à n-1 et est décrémenté toutes les 2 lignes.

Non golfé:

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 octets

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

En direct sur Wandbox

Sans compter les 2 nouvelles lignes après using namespace range::view ; ils sont juste là pour séparer les importations de la lambda.

Fait légèrement intéressant: cette solution ne fait aucune allocation de tas. Il résout le problème dansO(1) espace.

Explication:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): chaque n éléments ensemble, donc[1 ... n] [n+1 ... 2*n] ...
3. Appelez ça r
4. r | stride(2): prenez tous les autres éléments: [1 ... n] [2*n+1...] ...
5. concaténer cela avec:
6. r | reverse | drop(n % 2): inverser, puis supprimer le [1 ... n]terme si nest impair (il y aura un nombre impair de lignes et nous ne voulons imprimer le premier terme qu'une seule fois). Il semble que je devrais être capable de fairer | reverse | take , mais cela ne fonctionne pas pour une raison quelconque.
7. stride(2)encore une fois, prenez tous les autres éléments. Cette fois, c'est à l'envers.

Plus lisible et testable:

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

Gelée , 11 octets

s2ZU2¦Ẏị²s$

Essayez-le en ligne!

CJam , 22 octets

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

Essayez-le en ligne!

C (gcc) 80 78

Je vois maintenant que cette solution est fausse

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!