Це нитка розбійника. В нитка поліцейського тут .

Змія матриця - це квадратна матриця, яка відповідає цьому шаблону:

3 на 3:

1  2  3
6  5  4
7  8  9

і 4 на 4:

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

Ваше завдання - написати код, який бере вхід nі створить таку матрицю, тією ж мовою, що і пост поліцейського, та з кодом, який відповідає регексу копа. Формат виводу вашого коду повинен відповідати формату виводу коду копа.

Будь ласка, залиште коментар під постом поліції, щоб вказати, що ви зламали його.

Критерій виграшу:

Переможцем стане той користувач, який зламав більшість матеріалів. У разі вирівнювання, тоді буде багато переможців.

Желе , 9 байт, тріщини відповідь @Dennis

²sµUFḤ$¦G

Спробуйте в Інтернеті!

Має бути правильним зараз; Мені довелося переосмислити те, що я роблю.

Пояснення

Найскладнішою частиною цієї проблеми є отримання переліку рівних індексів всередині ¦(що застосовує операцію за певними індексами). На відміну від більшості операцій, які використовують вхід до всієї програми в якості за замовчуванням для другого операнда, він ¦використовує найдавніше значення як за замовчуванням (оскільки воно концептуально має два лівих операнди, а не лівий і правий операнд, як і більшість речей, які прийняти два значення).

Однак ми можемо зауважити, що у нас є список чисел, включаючи всі цілі числа від 1 до половини введення, вже в поточному значенні на той момент. Таким чином, згладжування та подвоєння дає нам список парних чисел, включаючи всі парні індекси (також деякі інші парні числа, але нас це не хвилює). Можна навіть витратити його µвиключно, щоб уникнути неоднозначності розбору і все ж увійти в межах 9 символів.

²sµUFḤ$¦G
 s         Split
²          {the list of numbers from 1 to} the square of {the input}
  µ        into a number of pieces equal to {the input};
   U       then reverse
       ¦   the elements at indexes
    F      obtained by flattening the split list
      $    and
     Ḥ     doubling each element in the flattened list;
        G  finally, format it into a grid.         

05AB1E, Емінья

Це вперше я використовував 05AB1E. Зробив це з невеликою допомогою. Це було весело. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Спробуйте в Інтернеті

Пояснення:

U                       Assign input to X
 XF                     For N in range(0,X):
   XL                   Push list [1 .. X]
     NX*+               Add N*X to each element of the list
         N2BSR1k_       Super clever way to get N%2:
                            not bool(reversed(str(bin(N))).index('1')) (N%2 is odd)
                 iR}    if N%2 is odd, then reverse the list
                    ˆ   Add row to global array
                        Implicit print

Я фактично знайшов цю подібну програму самостійно, але формат виводу інший:

UXFXLNX*+N2BSR1k_iR}=

Спробуйте в Інтернеті

[1, 2, 3, 4]
[8, 7, 6, 5]
[9, 10, 11, 12]
[16, 15, 14, 13]

Перегляньте історію редагування моїх попередніх спроб.

Пітон 2, Денніс

Це весела лексема з гольфу.

while ord>eval:1;int,eval=int<1and(int,eval+1)or(-input(),1);i=int;ord=i*i;print'%*s'%(-i,(eval+~i+~-eval%-i*~1,eval)[eval/i&1])+'\nt'[:-1<eval%int],

Підтвердження регулярного вибору

Ом, Нік Кліффорд

Вперше я спробував Ома.
Дійсно приємна мова, яку я з нетерпінням чекаю знову використовувати :)

²@┼σ▓_^è?R

Пояснення

²             # square input
 @            # range [1 ... input^2]
  ┼σ          # split in input sized chunks
    ▓         # perform the following block on each element of the array
     _        # current element
      ^è?     # if index is odd
         R    # reverse

Моя перша спроба, яка не спрацювала як додавання масиву та int, неможлива:

@┼MDR┼+;W

Моя друга спроба, яка не відповідала регулярному вираженню:

²@┼σ▓_^MR

05AB1E, Емінья (2-е подання)

Вперше працюю з 05AB1E.

VYLUYFYXDˆ+RU

Спробуйте в Інтернеті! | Підтвердження регулярного вибору

Пояснення

VYLUYFYXDˆ+RU  # Implicit input
V              # Save input to Y
 YL            # Push [1 .. Y]
   U           # Save list to X
    YF         # Repeat Y times:
      YX       # Push Y, then X
        Dˆ     # Add X into the global array (could've used X here instead)
          +    # Push X + Y
           R   # Reverse top of stack
            U  # Save updated list to X
               # Implicit loop end
               # Implicit global array print if stack is empty

CJam , Лінн

esmpmpmeimtmemqmememqicelic
esmpmpmeimememqmlmtmemoc
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimeiscic
esmpmpmeimemeimfsic
esmpmpmeisciscimqmtmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeimemomqmqmemeic
esmpmpmeisciscimfsimqic
esmpmpmeimeiscic
esmpmpmeisciscimfsimqic
esmpmpmeimemomqmemqmemtmemoc
esmpmpmeiscic
esmpmpmeimemomeimqmeic
esmpmpmeimemeimqmlmtmeic
esmpmpmeimtmtmqmemtmtmeic
esmpmpmeimemomqmqmtmeic
esmpmpmeimemqmqmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeiscimqmtmtmtmqmemeic
esmpmpmeimeimemtmqmemeic
esmpmpmeimeiscimlmlmtmlmtic
esmpmpmeimemeimqmlmtmeic
~~

Усі корми для лінійки призначені для косметичних цілей і їх можна видалити, не впливаючи на програму.

Спробуйте в Інтернеті!

Пояснення

Після того, як Лінн була видалена {|}зі списку дозволених персонажів, мені довелося спробувати щось нове. Виявляється, ми все ще можемо побудувати довільні рядки та оцінити їх як код.

Спочатку нам потрібно отримати деяку цінність на стеку. Доступні тільки вбудовані модулі , які штовхають що - щось не вискакують що - то ще перший (і без читання входу) є es, eaі et. Я впевнений, що ви могли почати з усіх цих так чи інакше, але я пішов із тим, esщо підштовхує поточну мітку часу. Оскільки я не хотів робити жодних припущень щодо його фактичного значення, я перевіряю його первинність за допомогою mp(що дає 0і 1) та ще раз перевіряю первинність цього значення, щоб переконатися, що я потрапив 0у стек. 1Буде більш корисним, тому ми обчислимо exp(0)з meі перетворити його в ціле число з i. Отже всі цифри починаються з:

esmpmpmei

Зараз у нас є ціла купа операторів з одинарної математики, з якими можна працювати:

i    int(x) (floor for positive numbers, ceiling for negative)
me   exp(x)
ml   ln(x)
mq   sqrt(x)
mo   round(x)
mt   tan(x)

Ми також можемо поєднати кілька вбудованих для більш детальних функцій x:

sci     Extract first digit of x and add 48 (convert to string, convert
        to character, convert to integer).
ceui    Convert to character, convert to upper case, convert to integer.
celi    Convert to character, convert to lower case, convert to integer.
mfsi    Get a sorted list of prime factors of x and concatenate them into 
        a new number.
mfseei  Get a sorted list of prime factors, interleave it with 1,2,3,..., and
        concatenate the result into a new number.

Використовуючи ці дані, ми можемо отримати будь-яке число в 0 <= x < 128(та багатьох інших) менш ніж за 10 кроків 1. Я впевнений, що набагато менший підмножина цих команд також буде достатнім. Я написав невелику програму Mathematica, щоб визначити всі ці фрагменти (це не дуже читабельно, вибачте):

codes = SortBy[
  Select[Nest[Select[DeleteDuplicatesBy[SortBy[Join @@ (Through[{
               List,
               If[1 <= # < 50, {Exp@#, #2 <> "me"}, Nothing] &,
               If[# >= 1, {Log@#, #2 <> "ml"}, Nothing] &,
               If[# > 1, {Sqrt@#, #2 <> "mq"}, Nothing] &,
               {If[# > 0, Floor@#, Ceiling@#], #2 <> "i"} &,
               {Floor[# + 1/2], #2 <> "mo"} &,
               {Tan@#, #2 <> "mt"} &,               
               If[NumberQ@# && # >= 0, {First@
                   ToCharacterCode@ToString@#, #2 <> "sci"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToUpperCase@FromCharacterCode@#, #2 <> "ceui"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToLowerCase@FromCharacterCode@#, #2 <> "celi"}, 
                 Nothing] &,
               If[IntegerQ@# && # > 0, ## & @@ {
                   {FromDigits[
                    "" <> (ToString /@ (f = 
                    Join @@ Table @@@ FactorInteger@#))], #2 <> 
                    "mfsi"},
                   {FromDigits[
                    "" <> (ToString /@ 
                    MapIndexed[## & @@ {#2[[1]] - 1, #} &, f])], #2 <>
                     "mfeesi"}
                   }, Nothing] &
               }@##] &) @@@ #, StringLength@*Last], 
       First], #[[1]] < 1000000 &] &, {{1, "esmpmpmei"}}, 9], 
   IntegerQ@# && 0 <= # < 128 &@*First], First]

З цим ми можемо просто висунути довільний список символьних кодів, перетворивши кожен з них у символ із cнаступним. Після того, як ми висунули весь код, який ми хочемо виконати, ми натискаємо 95( ]). Ми оцінюємо ту, з якою ~обернути всі інші в рядок, а потім зрівняємо її ~.

Дійсний код, виконаний в кінці програми, знову:

ri__2#,:)/2/[1W]f.%:~<p

Дивіться моє попереднє рішення для пояснення.

Python 3, TuukkaX

Вибачте, використаний вами регулярний вираз був надто простим, щоб реально реалізувати. Ні 0, #чи ? Без проблем!

Я, можливо, неправильно інтерпретував приклад виводу, але все-таки досить легко налаштувати, оскільки у мене залишилось 45 запасних символів

n=int(input())
print(str(n)+":")
x=1-1
exec("print([*range(1+x*n,1+n*-~x)][::(1,-1)[x%2]]);x+=1;"*n)
"no-op:a_string_that_doesnt_actually_matter"

R, МікіT

lets_make_a_snake<-function(n)`for`(i,1:n,cat(i*n+1-`if`(i%%2,n:1,1:n),"\n"))

Тести:

> lets_make_a_snake(4)
1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13 
> lets_make_a_snake(7)
1 2 3 4 5 6 7 
14 13 12 11 10 9 8 
15 16 17 18 19 20 21 
28 27 26 25 24 23 22 
29 30 31 32 33 34 35 
42 41 40 39 38 37 36 
43 44 45 46 47 48 49 

І підтвердження регулярного виразу: https://regex101.com/r/OB8ZIM/1

У мене також були:

invisible(sapply(1:(n=scan()),function(i)cat(i*n+1-`if`(i%%2,n:1,1:n),"\n")))

що дає той самий вихід і збігається з тим же регулярним виразом .

Röda , fergusq

{|i|;a=1;while[a<=i]do;b=a*i-i+1;c=[];while[b<=a*i]do;c+=b;b++;done;{d=[];x=0;while[x<i]do;d+=c[i-x-1];x++;done[d]}if[a%2<1]else{[c]};a++;done;r="||||||"}

Це анонімна функція , яка відповідає цьому PCRE регулярний вираз: ^{(\|[^\/#\s]*){8}$.

Спробуйте в Інтернеті!

Bash, @Marcos M

sort -n <(seq 1 $((n * n)) | xargs -n$n | sed -n 'p;n'; seq $((n * n)) 1 | xargs -n$n | sort -n | sed -n 'n;p')

Досить:

sort -n <(               # feed the stdout of this subshell into stdin for `sort -n`
    seq 1 $((n * n)) |   #   generate 1 2 3 ... n²
        xargs -n$n |     #     add line break every n numbers
        sed -n 'p;n';    #     print only odd lines
    seq $((n * n)) 1 |   #   generate n² ... 3 2 1
        xargs -n$n |     #     add line break every n numbers
        sort -n |        #     reverse all lines (keeping each row decreasing)
        sed -n 'n;p'     #     print only even lines
)

Перша частина підкоманди буде генерувати 1 2 3 4, 9 10 11 12і друга частина буде генерувати 8 7 6 5, 16 15 14 13. Зовнішнє sort -nбуде правильно змішувати їх між собою, утворюючи зміїний візерунок.

Я використовував трюк у /superuser//a/101760 для друку непарних і парних рядків. Дякую, Маркос, справді весело.

Javascript, Томе

f=(a,i=1,j=0)=>Array(a).fill(0).map(b=>Array(a).fill(0).map(a=>i++)).map(a=>j++%2?a.reverse():a).map(a=>a)

console.log(f(4))

Python 3, @TuukkaX

n=int(input());j=0;exec("print([(j-+i%n-n++2*n-0,j+i%n+1)[1&int(i/n)//1^(0x1)//1]*(2*(i%n)*0+2222222//2222222)for i in range(j,j+n)]);j+=n;"*n)

• Перевірте: https://regex101.com/r/GI1Zvh/1

Трохи проаналізувавши регекс копа, видно фіксований шаблон:

________________________"___________i%n____2*n-____i%n__________i/n)//1_____)//1___2*(i%n)____^^^^^^^^^^^^^^^^for i in range(j,____])______"*n)

де _є будь-який символ, окрім [ '"#]і ^є будь-який [int()2/].

В "*n)кінці чітко видно eval("..."*n)або exec("..."*n)триває, тому нам просто потрібно переконатися, що "..."друкує j-й ряд.

for i in range(j,Занадто близько до кінця рядка, натякаючи список розуміння без яких - або if. Тому нам потрібно побудувати i-й стовпчик, використовуючи ті i%n, 2*nречі.

n = int(input())
j=0
exec("""print([
    (
        j - +i%n - n ++ 2*n - 0,    # equivalent to (n + j - i%n) for the decreasing rows
        j + i%n + 1                 # equivalent to (j + i%n + 1 == i + 1) for the increasing rows
    )[1 & int(i/n)//1 ^ (0x1)//1]   # int(i/n)   ->    get row number 0, 1, 2, 3, ...; 
                                    # 1 & int(i/n)//1    ->    0 for increasing rows, 1 for decreasing rows, 
                                    # 1 & int(i/n)//1 ^ (0x1)//1    ->   flip 0 and 1
    * (2*(i%n)*0+2222222//2222222)  # multiply by the constant 1.
    for i in range(j,j+n)
]); j+=n; "*n)

DC , Мітчелл Спектор

Це був мій перший вступ до виклику копів та грабіжників, і мені було дуже весело. Регекс, необхідний для узгодження, був простим, ^[^# !]{59}$що в основному перетворив мою роботу на гольф, не використовуючи цих 3 символів. Спочатку у мене були труднощі потрапляти нижче 60 байт, але я врешті-решт зламав це.

?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdlNd*>L]dsLxqqq

Спробуйте в Інтернеті!

Пояснення:

Мій код використовує один цикл з N ² ітераціями, зберігаючи нульовий лічильник (1D), і обчислює, яке число потрібно надрукувати на основі відповідних матричних рядків і координат (r, c).

Приклад того, що я маю на увазі, якщо N = 4:

 0  1  2  3            (0,0) (0,1) (0,2) (0,3)             1  2  3  4
 4  5  6  7     ->     (1,0) (1,1) (1,2) (1,3)     ->      8  7  6  5
 8  9 10 11            (2,0) (2,1) (2,2) (2,3)             9 10 11 12
12 13 14 15            (3,0) (3,1) (3,2) (3,3)            16 15 14 13

Це виглядає складно, але корисний посередницький крок. Крім того, я спробував використати 2 петлі з самого початку, але я виявився вище межі символу регулярних виразів. Генерація чисел при кожній ітерації (нульова):

• якщо r % 2 = 0(звичайний рядок),n = (r * N) + c = counter
• якщо r % 2 = 1(зворотний рядок),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Або все відразу, як одна базова нумерація: n = counter + ((N - (2 * c) - 1) * (r % 2)); n++

?sN0             # read input, save as N, initialize iteration counter
[AP]sP           # macro 'P' that prints a newline (ASCII code 10 = A)
[                # start loop
    ddlN~        # push N, calculate row and column coordinates:
                 #r = int(counter / N), c = counter % N, '~' calculates both
    _2*lN+1-     # c is on top, so this does: N - (2 * c) - 1
    r2%*+        # now r is on top, do: (r % 2) * (previous result) + counter
    1+n32P       # do: n++, print space (ASCII code 32)
    1+           # increment counter
    dlN%0=P      # call macro 'P' every Nth printed number
    dlNd*>L      # if: N * N > counter, repeat loop
]dsLx            # this saves the loop to macro 'L', then executes it
qqq              # my script was shorter, so I added a bunch of quit commands to
                 #fit the regex limit. Use of comments ('#') was prohibited.

PowerShell, ConnorLSW

Тріщина

$mySnakeIndex=1;$seq=1..$args[0];$seq|%{$rowNum=$seq|%{($mySnakeIndex++)};if(!($_%2)){[array]::Reverse($rowNum)};$rowNum-join" "}

Я почав з меншого вирішення проблеми і додав свої імена змінних, щоб зрівняти регулярний вираз. Намагаючись знайти користь для товстої кишки, я думаю, це було найважче, щоб обернути голову.

$a=1..$args[0];$i=1;$a|%{$r=$a|%{($i++)};if(!($_%2)){[array]::Reverse($r)};$r-join" "}

Пояснення

# Initialize a counter that starts at one.
$mySnakeIndex=1
# Save the integer array from 1 to the input value. 
$seq=1..$args[0]
# For each row of the output...
$seq|%{
    # Build the integer array for this row sequentially
    $rowNum=$seq|%{
        # Increase the integer index while sending it down the pipeline
        ($mySnakeIndex++)}
        # Check if this is and odd row. If so reverse the integer array.
        if(!($_%2)){[array]::Reverse($rowNum)}
        # Take this row and join all the numbers with spaces.
        $rowNum-join" "

CJam, Лінн

Щось на зразок цього:

ri
{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~c{a}seu~~|
{s}seu~~c{c}seu~~|
{t}seu~~sc{a}seu~~|
{s}seu~~c{a}seu~~|{w}seu~~z{w}seu~~sc~c
{s}seu~~sc{fb}seu~~||
{s}seu~~sc{i}seu~~|
{s}seu~~sc{fb}seu~~||
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c
{a}seu~~scs
{w}seu~~
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c
{fb}s{b}s{w}seu~~sc~
{s}seu~~sc{ee}seu~~||
{s}seu~~sc{z}seu~~|{w}seu~~{w}seu~~sc~{w}seu~~{w}seu~~sc~
{t}seu~~sc{a}seu~~|
{~}s{}s{w}seu~~sc~
{t}seu~~sc{c}seu~~|

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~
s~
p

Весь пробіл призначений для ... "читабельності" ... і може бути пропущений, щоб відповідати регексу Лінни.

Спробуйте в Інтернеті!

Пояснення

Регекс вимагає, щоб ми вирішили проблему лише за допомогою:

• Букви нижнього регістру.
• {}, які можна використовувати для створення блоків.
• |, в основному використовується для побітових АБО.
• ~, "eval" і побітовий NOT (також "dump array", але я не збираюся його використовувати).

Оскільки у нас є, ~якщо ми можемо побудувати довільні рядки, ми можемо запустити довільний код. Однак спочатку не очевидно, як це зробити.

Перший фрагмент головоломки полягає в тому, що блоки - це неоцінені біти коду, які можуть перетворитися на рядки з s. Так {abc}sдає нам "{abc}". Далі ми можемо використовувати euдля перетворення цих рядків у верхній регістр.

{abc}seu  e# gives "{ABC}"

Перевага цього полягає в тому, що великі літери є заздалегідь ініціалізованими змінними, тому ми можемо отримати безліч постійних значень, створивши такий рядок, і два рази його оцінювати (один раз повернути рядок назад у блок і один раз у виконати цей блок). Ми не можемо отримати всі букви, тому що деякі, як xі не є дійсними командами (тому CJam відмовиться розбирати блок, що містить їх). Ми не можемо використовувати так, fяк є, тому що за ним повинна слідувати інша команда, але ми можемо використовувати, fbа потім АБО два значення разом. Так само ми можемо використовувати eeзамість цього e. При тому, що ми можемо отримати число 0, -1, 3і 10до 19. Це -1зручно, тому що якщо ми перетворимо його на рядок ( "-1"), то в символ ('-), а потім оцінюємо його, ми можемо отримати віднімання або встановити різницю. Як я вже сказав, ми не можемо отримати X(для 1), але ми можемо взяти абсолютне значення -1з z.

Ми також можемо використовувати sрядок, що містить пробіл, і використовувати його cдля перетворення символу пробілу :

{s}seu~~c

Це зручно, тому що звідти ми можемо отримати безліч корисних команд у нижньому діапазоні ASCII шляхом ORI пробілу з різними числами. Щоб отримати деякі символи вище кодової точки 48, ми використовуємо символ '0як основу замість цього:

{t}seu~~si

Цього вже достатньо для побудови довільних рядків, оскільки ми можемо отримати '+(додавання та об'єднання рядків) із наступного фрагмента:

{s}seu~~c{b}seu~~|

І у нас є буквальне, 1щоб ми могли просто підштовхувати символи простору, збільшувати їх до потрібного нам значення, а потім об'єднувати їх усі разом, але це трохи нудно і код стане масовим.

Натомість я генерував [і ]оцінював їх, так що всі символи, до яких я натискаю між ними, автоматично загортаються в рядок. Ось ці два рядки:

{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

...

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~

І нарешті, нам знадобиться fі ~в рядку, який ми генеруємо. Хоча це вже дійсні символи, у нас немає строкових літералів або символів, тому нам доведеться також генерувати ці, а створення більших точок коду з простору трохи дратує. Натомість я тут використав задане віднімання, але віднімаючи два блоки (щоб позбутися {}):

{fb}s{b}s{w}seu~~sc~
...
{~}s{}s{w}seu~~sc~

Це майже все, що там є. Ми оцінюємось [. Ми висуваємо всі символи, отримані різними обчисленнями від кількох вбудованих констант |, -(, через eval) і +(via eval). Ми оцінюємось ]. Ми згладжуємо всю річ у рядок, тому що в якийсь момент я додав до списку кілька рядків чи чисел. Ми оцінюємо свою довільну рядок за допомогою ~.

Вони ri...pє частиною фактичної кінцевої програми, але я витяг їх, оскільки кодування їм не потрібно.

Нарешті, це програма, яку ми насправді виконуємо:

ri___*,:)/2/[1-1]f.%:~<p

ri      e# Read input and convert to integer.
__      e# Make two copies.
_*      e# Square the last copy.
,       e# Turn into range [0 1 ... n^2-1].
:)      e# Increment each to get [1 2 ... n^2].
/       e# Split into chunks of length n, creating a square.
2/      e# Split into pairs of lines.
[1-1]   e# Push [1 -1].
f.%     e# Use this to reverse the second line in each pair. If n was odd,
        e# this will pair a -1 with the last line.
:~      e# Flatten the pairs back into the square.
<       e# Truncate to n lines to get rid of that extraneous -1 for odd inputs.
p       e# Pretty-print.

tinylisp , @DLosc

(v(c(h(q(d)))(c(h(q(f)))(q((c(q(n))(q((g(v(h(q(n))))(s(v(h(q(n))))(v(h(q(1)))))())))))))))(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((i(l(v(h(q(x))))(v(h(q(y)))))x(mod(s(v(h(q(x))))(v(h(q(y)))))y))))))))))(v(c(h(q(d)))(c(h(q(range)))(q((c(c(h(q(x)))(c(h(q(y)))(c(h(q(z)))(q(w)))))(q((i(l(times(v(h(q(z))))(v(h(q(x))))(v(h(q(0)))))(times(v(h(q(z))))(v(h(q(y))))(v(h(q(0))))))(range(v(h(q(x))))(s(v(h(q(y))))(v(h(q(z)))))z(c(s(v(h(q(y))))(v(h(q(z)))))w))w)))))))))(v(c(h(q(d)))(c(h(q(times)))(q((c(c(h(q(x)))(c(h(q(y)))(q(acc))))(q((i(l(v(h(q(x))))(v(h(q(0)))))(times(s(v(h(q(0))))(v(h(q(x)))))(s(v(h(q(0))))(v(h(q(y)))))acc)(i(e(v(h(q(x))))(v(h(q(0)))))acc(times(s(v(h(q(x))))(v(h(q(1)))))y(a(v(h(q(y))))(v(h(q(acc))))))))))))))))(v(c(h(q(d)))(c(h(q(g)))(q((c(c(h(q(n)))(c(h(q(w)))(q(r))))(q((i(l(v(h(q(w))))(v(h(q(0)))))r(g(v(h(q(n))))(s(v(h(q(w))))(v(h(q(1)))))(c(i(e(v(h(q(0))))(mod(v(h(q(w))))(v(h(q(2))))))(range(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))(a(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))n)1())(range(a(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))n)(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))(s(v(h(q(0))))(v(h(q(1)))))()))r)))))))))))

Спробуйте в Інтернеті!

Це визначає функцію, fяка повертає відповідь. Він також друкує назви функцій, які я визначив для stdout, але я вважаю, що це не має значення, оскільки [нам дозволяється вибирати наш вихідний потік] для кодового гольфу, принаймні. Якщо це велика справа, я думаю, я можу налаштувати це, щоб не надрукувати їх. Як я це зробив? Я почав з чогось досить стандартного:

(d f (q ((n)
  (g n (s n 1) ()))))

(d mod (q((x y)
  (i (l x y) x
    (mod (s x y) y)))))

(d range (q((x y z w)
  (i (l (times z x 0) (times z y 0))
    (range x (s y z) z (c (s y z) w))
    w))))

(d times (q ((x y acc)
  (i (l x 0) (times (s 0 x) (s 0 y) acc)
  (i (e x 0) acc
    (times (s x 1) y (a y acc)))))))

(d g (q ((n w r)
  (i (l w 0) r
    (g n (s w 1)
       (c (i (e 0 (mod w 2))
             (range (a 1 (times w n 0)) (a (a 1 (times w n 0)) n) 1 ())
             (range (a (times w n 0) n) (times w n 0) (s 0 1) ()))
          r))))))

Тоді я помітив, що можна перетворити такі функції, як це:

(d mod (q ((x y) (body))))

стає

(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((body)))))))))

І функціонує як такий:

(a x y)

стає

(a(v(h(q(x))))y)

Я використовував цей рекурсивний Vim макро, збережений в регістрі q, щоб зробити другий (я jkзіставляється з <Esc>): f s(v(h(q(jkea))))jk@q.

Цих двох перетворень було достатньо для усунення всіх просторів.

Свіфт, @James Webster

{n in for j in 0..<n{print((1...n).map{j%2==0 ?$0+j*n:j*n+n+1-$0})}} as(CShort)->()

Перевірка: https://regex101.com/r/7ukrM0/1

PHP, @ JörgHülsermann

<?=(function($n,$snake){foreach(array_chunk(range(1,$n*$n),$n)as$i=>$a){if($i%2)$a=array_reverse($a);echo"\n",join('',array_map(function($e){return(sprintf("%3d",$e));},$a));}})($argv[1],'-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')?>

• Перевірте: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

221 байт занадто довгий (таким чином змія), і брак простору можна легко вирішити.

Досить:

<?=
(
    function($n, $snake) {
        foreach (array_chunk(range(1, $n*$n), $n) as $i => $a) {
            if($i % 2)
                $a = array_reverse($a);
            echo "\n", join('', array_map(function($e) {
                return (sprintf("%3d", $e));
            }, $a));
        }
    }
)($argv[1], '-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')
?>

Желе, довжина 12, @JonathanAllan

Ḷ-*m@"s@²$G

Спробуйте в Інтернеті!

Як це працює

Ḷ-*m@"s@²$G  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n-1].
 -*          Yield [(-1)**0, ..., (-1)**(n-1)].
         $   Combine the two links to the left into a chain.
        ²    Yield n².
      s@     Split [1, ..., n²] into chunks of length n.
   m@"       Take the lists to the right modulo the units to the left, 1 being
             normal order and -1 being reversed.

Желе , 12 байт, тріщини @ друга відповідь Джонатана Аллана

²sµ;@/€FḤ$¦G

Спробуйте в Інтернеті!

Пояснення

Це майже те саме, що моя інша відповідь . Я щойно вніс дві зміни:

По-перше, я змінив U("перевернути кожен елемент") на Ṛ€("перевернути" "кожен елемент"). Це не допомагає само по собі, тому щоṚ також заборонено.

Потім я змінив Ṛ("реверс") на ;@/( /"скласти на" ;"об'єднати"@ "в протилежному порядку до вихідного списку"). Це дозволяє уникнути всіх заборонених символів, даючи дійсне рішення.

Я припускаю , що наступний крок повинен був би почати заборона на масив маніпуляції Quicks , на додаток до атомам.

Желе, довжина 13, @JonathanAllan

1r-*Nm@"s@²$G

Спробуйте в Інтернеті!

Як це працює

1r-*Nm@"s@²$G  Main link. Argument: n

1r             Range 1; yield [1, ..., n].
 -*            Yield [(-1)**1, ..., (-1)**n].
   N           Negate each unit.
           $   Combine the two links to the left into a chain.
          ²    Yield n².
        s@     Split [1, ..., n²] into chunks of length n.
     m@"       Take the lists to the right modulo the units to the left, 1 being
               normal order and -1 being reversed.

Желе, довжина 14, @JonathanAllan

²sµðạ"J×2$$¦GµL.xị"ḅ1µ$

Спробуйте в Інтернеті!

Scala, @Soapy

def g(n:Int) = {
    var vec = Vector.fill(0)(Vector.fill(0)(1))
    for (p <- 1 to n) {
        var vec2 = Vector.fill(0)(1)
        for (q <- (p-1)*n+1 to p*n) {
            vec2 = vec2 ++ Vector(q)
        }
        if (p%2==1) vec = vec ++ Vector(vec2)
        else vec = vec ++ Vector(vec2.reverse)

    }
    println(vec)
}

Я не зачіпав Скалу за деякий час, було весело переглянути. На жаль, це рішення не вистачає на багатьох цікавих функціях Scala.

Спробуйте це тут

Підтвердження Regex

QBasic (QB64), @DLosc

Зауважимо, що оскільки .значення не відповідає \n(U + 000A, LF), новим рядком тут є \r(U + 000D, CR).

INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM
NEXT:PRINT:NEXT

Перевірте:

>>> re.match('^([A-Z]+.)+$', 'INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM\rNEXT:PRINT:NEXT')
<_sre.SRE_Match object; span=(0, 141), match='INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR >

Основна складність полягає в тому, як вставити слово після слова ;. На щастя, QB64 трактує CR як новий рядок, а регекс Python цього не робить, тому ми можемо пропустити REM\rтут. Із п’яти дозволених ароматів регулярного вираження,

• Perl приймає "\r" =~ /./
• JavaScript покидьки !/./.test('\r') ( \n, \r, \u2028, \u2029розділювачі рядків )
• Python приймає re.match('.', '\r')( тільки \nвважається розрив рядка )
• Голанг приймає regexp.Match(".", "\r")
• Рубі приймає /./ =~ "\r"

Тож ця тріщина чудова, доки ми не згадуємо JavaScript ... 🤐

Python 3, kennytm

def S(N,A=1,K=1,E=list,r=range):print(E(r(A,A+N)[::K]))or(A>N*N-N)or(((S(N,A+N,-K))))

Підтвердження регулярного вибору

> <>, торкадо

!v &0_!
_<>~ao1+>_v_
?______;__>:&:&=?;::2%:}+&:&*{3+0$.
?!v1+:n' 'o:&:&%_
?!v:n' 'o1-:&:&%_

C, @Yimin Rong

main(int c,char**p){int n=atoi(*++p),i=n-n,t,o=c;for(--o;i<n;++i)for(t=o;t<=n;++t)printf("%-*d%c",n-o,i%c?i*n+n+o-t:i*n+t,t%n?' ':'\n');}

Програма не може містити цифри, але ми можемо отримувати номери за допомогою:

1. c, зазвичай відомий як "argc", який завжди є 2.
2. +і -вони доступні, тому ми можемо створити 0 з n-nі створити 1 з o=c;--o.

Рубі, @ Валуе чорнило

->n{(1..n).map{|r|x=(r*n-n+1..r*n).to_a;if(r.modulo(2)==1)then(x)else(x.reverse)end}}#1-2-3-4-5-6--

[(-=Z-~]* означає "Я можу написати все, що мені подобається :)"

тинілісп @DLosc

Дуже просте рішення та абсолютно неоптимізований :)

(d p(q((m n)(s m(s(s 1 1)n)))))(d j(q((f g)(i(l f g)(c f(j(p f 1) g))()))))(d r(q((f g)(i(l f g)(c(s g 1)(r f(s g 1)))()))))(d k(q((m o f g n)(i(l n g)()(c(m f(p f n))(k o m(p f n)(p g 1) n))))))(d f(q((n)(k j r 1 1 n))))

Телефонувати як (disp (f 4)).

• (p m n)обчислює m + n, використовуючи віднімання s(m + n == m - ((1 - 1) - n))
• (j f g) породжує (f f+1 f+2 ... g-1)
• (r f g) породжує (g-1 g-2 g-3 ... f)
• (k m o f g n)створити один рядок зміїної матриці, а потім повторити себе для наступного ряду, поки не буде створено n рядків. Аргументи m, oзамінені j/ rгенерувати рядки, що збільшуються або зменшуються. Аргументи f, gце індекси, щоб знати, на якому рядку ми знаходимося.
• (f n)заклики (k j r 1 1 n)запустити покоління.

PHP, @Ionut Botizan

На даний момент я не маю кращої ідеї зламати оригінальне рішення.

Підтримує n <= 15

Це перший раз, коли я використовую getopt. Можливо, не найкраща ідея використовувати параметри як вхідні дані.

Почніть з командного рядка так

php hack.php -a=4

Оригінальний Regex

Рівень 1:

^<[^'"\d{vV;<$]+$

Дуже приємне поєднання букв. Не соромтеся голосувати за ниткою поліцейських.

Він блокує мені такі функції, як - strrev - array_reverse - get_defined_vars

https://regex101.com/r/5rGTnw/2

Рівень 2:

^<[^'"\d{v;<$_~|&A-Z]+$

https://regex101.com/r/XtVl9G/1

Рішення

 <?php
    error_reporting(~E_NOTICE)&
    define(A,a.chr(E_COMPILE_ERROR-E_NOTICE+E_WARNING))
    &define(B,getopt(A,[])[a])&print_r(array_chunk(
    array_slice(
    array_merge(
    range(E_ERROR,B)
    ,range(E_WARNING*B,E_ERROR+B)
    ,range(E_WARNING*B+E_ERROR,(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B,+E_ERROR+(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B+E_ERROR,(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B,+E_ERROR+(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B+E_ERROR,(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B,+E_ERROR+(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B+E_ERROR,(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B,E_ERROR+(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B+E_ERROR,(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B,E_ERROR+(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B+E_ERROR,(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B,E_ERROR+(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B+E_ERROR,(E_CORE_ERROR-E_ERROR)*B)
    )
    ,B-B,B*B
    ),B)
    )
    ?>

Рівень 2:

<?php
define(aa,a.chr(ord(strtoupper(a))-ord(h)+ord(a)))and
define(bb,getopt(aa,[])[a])and
define(us,chr(ord(a)-true-true))and
(prin.t.(us).r)(
(arra.y.(us).chunk)(
(arra.y.(us).slice)(
(arra.y.(us).merge)(
range((ord(b)-ord(a)),bb)
,range((ord(c)-ord(a))*bb,(ord(b)-ord(a))+bb)
,range((ord(c)-ord(a))*bb+(ord(b)-ord(a)),((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(q)-ord(a))-(ord(b)-ord(a)))*bb)
)
,bb-bb,bb*bb
),bb)
)
?>