_{To wyzwanie jest inspirowane tym , teraz usuniętym pytaniem.}

Jako wartość wejściową weź dodatnią liczbę całkowitą N i wyślij macierz o liczbach 1 .. N ² zgodnie z poniższym wzorem:

Wypełnij pierwszy wiersz 1 .. N, a następnie wypełnij ostatni rząd (numer wiersza N ) (N + 1) .. 2N , a następnie wypełnij drugi rząd (2N + 1) .. 3N i kontynuuj, aż wypełnisz wszystkie rzędy.

Format wyjściowy jest elastyczny, dlatego listy list itp. Są akceptowane.

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

Obowiązują standardowe zasady. Najkrótsza odpowiedź w bajtach w każdym języku wygrywa. Wyjaśnienia są zachęcane jak zawsze.

05AB1E , 13 8 bajtów

Zaoszczędź 5 bajtów dzięki Rod

nLô«āÉÏ

Wypróbuj online!

Wyjaśnienie

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

Rubin , 53 bajty

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

Wyjaśnienie:

Najpierw umieść wszystkie liczby w jednej tablicy, a następnie pokrój tablicę pomijając wiersz dla każdej iteracji. Po pierwszych iteracjach (n / 2 + n% 2) nie ma już nic, co można pominąć, a następnie pobrać wszystkie pozostałe wiersze do tyłu.

Wypróbuj online!

Python 2 , 75 bajtów

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

Wypróbuj online!

JavaScript, 68 bajtów

Edytuj 3 zapisane bajty, zaostrzone przez @ user71546

Najpierw spróbuj zgodnie z oczywistą trasą: policz od 1 i wypełnij tablicę z obu stron, od zewnętrznego do wewnętrznego

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

Test

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 bajty

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

Wypróbuj online! Dane wyjściowe to lista list, np . (0#) 3Plony [[1,2,3],[7,8,9],[4,5,6]].

> <> , 51 + 3 = 54 47 bajtów

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

Wypróbuj online!

Dane wejściowe są oczekiwane na szczycie stosu na początku programu przy użyciu -vflagi. Dane wyjściowe składają się z nieprzystosowanych liczb oddzielonych pojedynczymi spacjami, a każda linia jest oddzielona pojedynczym nowym znakiem. Przykładowe dane wyjściowe dla 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

... a następnie jedna nowa linia. Program kończy się z błędem (something smells fishy... ), ale jest to na STDERR, a nie na STDOUT.

Wyjaśnienie:

Pierwszy wiersz po prostu przechowuje kopię N w rejestrze.

Druga linia tworzy przesunięcie dla każdego wiersza wyjściowego, odejmując 1 od N, mnożąc to N, obracając go do dolnej części stosu, a następnie odwracając cały stos. Gdy liczba na górze stosu osiągnie 0, stos powinien wyglądać następująco (używa przykładu N=5):

5 15 20 10 0 0

Trzecia linia odrzuca duplikat 0 z góry stosu.

Czwarty wiersz zwiększa górę stosu i wyświetla jego kopię. Jest to następnie pobierane mod Ni służy do decydowania, czy spacja lub nowa linia powinna zostać wydrukowana, a jeśli góra stosu powinna zostać odrzucona - jeśli jest wydrukowana ostatnia liczba x, x mod N == 0oznacza to , że osiągnięto koniec tego wiersza wyjściowego . Wykonanie kończy się, gdy1+ zostanie wykonane na pustym stosie, powodując błąd zakończenia.

Poprzednia wersja

To jawnie sprawdzało, czy nie ma pustego stosu do zakończenia wykonywania, a ja dołączyłem również 3 bajty na -vużycie flagi.

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

Wypróbuj online!

Perl 5 , -p 52 51 bajtów

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

Wypróbuj online!

Java (OpenJDK 9) , 101 bajtów

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

Wypróbuj online!

Kredyty

• -4 bajty dzięki Kevin Cruijssen .

JavaScript (ES6), 69 68 bajtów

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

Cóż, został rozegrany zanim mogłem go opublikować, ale i tak jest. Edycja: Zapisano 1 bajt dzięki @KevinCruijssen.

Galareta , 10 bajtów

²ss2Ṛj@/Fs

Wypróbuj online!

Jak to działa

²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 bajtów

│æ╘▐⌡r▌═∟Y

Uruchom i debuguj online

Odpowiednia reprezentacja ascii tego samego programu ma 12 znaków.

JRx/r{]+rFmJ

Oto jak to działa.

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

Galaretka , 13 ... 6 bajtów

Dzięki JonathanAllan za -1 bajt!

²sm0m2

Wypróbuj online!

Użyj identycznego algorytmu do odpowiedzi 05AB1E.

R , 70 59 47 bajtów

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

Wypróbuj online!

Dzięki Robin Ryder za 4-bajtowe golfa, które następnie grałem dalej.

Zwraca macierz; konstruuje matrixsekwencję, np. [[1 2 3] [4 5 6] [7 8 9]]następnie przestawia rzędy.

Python 2 , 72 68 63 bajtów

^{-4 bajty dzięki Neilowi}

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

Wypróbuj online!

Oktawa , 102 bajty

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

Wypróbuj online!

C (gcc) , 110 bajtów

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

Wypróbuj online!

Wypełnia tablicę, zmieniając naprzemiennie 2 indeksy dla wierszy: jeden indeks zaczynający się od góry i drugi zaczynający się od dołu. Indeks górnego wiersza zaczyna się od 0 i jest zwiększany co 2 wiersze; indeks dolnego rzędu zaczyna się od n-1 i jest zmniejszany co 2 rzędy.

Nie golfowany:

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 ++ + Zakres V3 , 159 bajtów

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

Na żywo w Wandbox

Nie licząc 2 nowych linii po using namespace range::view; są tylko po to, aby oddzielić import od lambda.

Mało interesujący fakt: to rozwiązanie nie przydziela sterty. Rozwiązuje problem w O(1)kosmosie.

Wyjaśnienie:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): każdy nelement razem, więc[1 ... n] [n+1 ... 2*n] ...
3. Nazwij to r
4. r | stride(2): weź co drugi element: [1 ... n] [2*n+1...] ...
5. połącz to z:
6. r | reverse | drop(n % 2): odwróć, a następnie usuń [1 ... n]termin jeśli njest nieparzysty (liczba wierszy będzie nieparzysta, a pierwszy termin chcemy wydrukować tylko raz). Wygląda na to, że powinienem to zrobić r | reverse | take, ale z jakiegoś powodu to nie działa.
7. stride(2)ponownie weź co drugi element. Tym razem jest odwrotnie.

Bardziej czytelne i testowalne:

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

Galaretka , 11 bajtów

s2ZU2¦Ẏị²s$

Wypróbuj online!

CJam , 22 bajty

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

Wypróbuj online!

C (gcc) 80 78

Rozumiem teraz, że to rozwiązanie jest złe

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

Wypróbuj online!

C (gcc) , 36 + 8 + 61 = 105 bajtów

Połącz z -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;}

Wypróbuj online!