Это нить грабителя. В нитка полицейского здесь .

Матрица змей - это квадратная матрица, которая следует этому шаблону:

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]

Смотрите историю изменений для моих предыдущих двух попыток.

Python 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, MickyT

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}$.

Попробуйте онлайн!

Баш, @ Маркос М

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')

Prettified:

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%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)

постоянный ток , Mitchell Spector

Это было моей первой записью в полицию и грабителей, и мне было очень весело. Регулярное выражение, которое нужно было подобрать, было простым, ^[^# !]{59}$что в основном превратило мою работу в игру в гольф, без использования этих трех символов. Первоначально у меня были трудности с получением меньше 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 цикла с самого начала, но в итоге я превысил ограничение на количество символов в регулярном выражении. Генерация чисел на каждой итерации (от нуля):

• if 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" и побитовое НЕ (также "массив массивов", но я не собираюсь его использовать).

Поскольку у нас есть, ~если мы можем построить произвольные строки, мы можем запустить произвольный код. Однако поначалу не очевидно, как это сделать.

Первая часть головоломки состоит в том, что блоки представляют собой биты кода, которые не могут быть оценены и могут превращаться в строки 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, ИЛИ пространство с различными числами. Чтобы получить некоторые символы выше кодовой точки 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) и +(через 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, но я предполагаю, что это не имеет значения, поскольку, по крайней мере, [нам разрешено выбирать наш выходной поток] для кода golf. Если это большое дело, я думаю, что я могу настроить его, чтобы не печатать их. Как я это сделал? Я начал с чего-то довольно стандартного:

(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.

Этих двух преобразований было достаточно, чтобы устранить все пробелы.

Свифт, @ Джеймс Вебстер

{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 байт слишком длинен (таким образом, змея), и отсутствие пробела можно легко обойти.

Prettified:

<?=
(
    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(«перевернуть каждый элемент») на Ṛ€(«перевернуть» «каждый элемент»). Это не помогает само по себе, потому что Ṛтакже запрещено.

Затем я изменил Ṛ(«реверс») на ;@/( /«сворачивание» ;«конкатенация» @«в порядке, обратном исходному списку»). Это позволяет избежать всех запрещенных персонажей, давая правильное решение.

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

Желе, длина 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 ... 🤐

Питон 3, кеннитм

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.

Рубин, @Value Ink

->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-~]* означает "я могу написать все, что мне нравится :)"

tinylisp, @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

На данный момент у меня нет лучшей идеи взломать оригинальное решение.

Поддерживает п <= 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)
)
?>