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

Напишите код, который принимает входные данные nи создает n-by-n "матрицу змей".

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

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

Точный формат вывода не является обязательным. Вы можете, например, вывод [[1 2 3],[6 5 4],[7 8 9]]или что-то подобное.

Вы должны предоставить название языка и регулярное выражение, которое полностью соответствует вашему коду. Вы можете выбрать, насколько подробным должно быть ваше регулярное выражение. В крайнем случае вы можете написать регулярное выражение, соответствующее каждой возможной строке, и в этом случае ваш код будет очень легко взломать. Вы также должны предоставить выходные данные n=4, чтобы грабители знали точный формат, который вы выбрали.

Вы можете использовать один из вариантов regex, доступных на regex101.com , или вариант Ruby.

• PCRE (PHP)
• Javascript
• питон
• Golang
• Рубин

Вы должны указать, какой из них вы используете.

Заметки:

• Вы должны поддержать любой достаточно большой n. Вы можете предположить, что он не переполнит тип данных или память. Если тип данных по умолчанию - 8-разрядные целые числа со знаком, то можно предположить n<=11, что если это 8-разрядные целые числа без знака, то можно предположить n<=15.
• Грабители должны соответствовать выходному формату представления, за исключением начальных / конечных пробелов и новых строк, так как это могло быть удалено форматированием SE.

Критерий победы:

Победителем будет непроверенная заявка с самым коротким регулярным выражением, измеряемым количеством символов.

Если ваше сообщение оставалось без изменений в течение 7 дней, вы можете опубликовать предполагаемое решение и пометить отправку как безопасную.

05AB1E , взломан mbomb007

Надеюсь, весело взломать и не слишком очевидно.

Regex (PCRE):

^\w*[+\-*\/%]*\w*.{0,2}$

Выход n = 4:

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

Оригинальное решение

UXFXLNX*+NFR}ˆ

Python 2 , длина 62, треснувший

Regex (PCRE)

^while ((?=\S)[1di\W]|an|eval|nput|nt|or|pr){55}s(?1){45}n...$

Образец вывода

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

Желе , длина 6, треснувший

Regex (PCRE)

^.{9}$

Образец вывода

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

R, длина 14 треснул по планнапу

Надеюсь, я правильно понял это регулярное выражение. То , что я пытаюсь сказать, 77 символов за исключением <space>, #, ;и [. Я проверил это здесь

Regex

^[^ #;\[]{77}$

Пример вывода n = 4

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

05AB1E , треснувший по стоимости чернил

Давайте поднимем его на ступеньку выше :)
Надеюсь, хорошая головоломка.

Regex (PCRE)

^\w*..\w*$

Выход n = 4

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

> <> , длина 49, взломан Аароном

Регекс (Javascript)

^.{7}\n.{12}\n\?.{6};[^v^]{27}(\n.{13}:&.{2}){2}$

Пример вывода (n = 4)

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

Форматирование немного странно, но проверка длины номера сделала бы это намного длиннее. Может быть, ушли немного за борт на регулярное выражение, не уверен!

Изменить: Также я забыл упомянуть, я использую начальный стек (-v флаг) для ввода, а не обычный ввод рыбы. Сожалею!

Оригинальный код:

<v1*2&:
 >:{:}=?v:1+
?^{r0}v;>&:&[r]{&:&2*+}::&:::&*@+@(
+:}=?v>n" "o&:&{1
0~{oa<^v?)*&::&:}

Аарона намного проще! Сложность моего исходного кода основана на идее использования n[r]каждого n-го числа, чтобы перевернуть этот сегмент (строку), а затем распечатать все числа сразу в конце

Ом , треснул

Также моя первая задача «Копы и грабители», так что скажите мне, есть ли проблемы с этим шаблоном (тем более что это довольно неизвестный язык).

Regex (PCRE)

^\S{6}\W{0,3}\w$

Выход (n = 4)

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

PHP, 221 байт ( взломан )

Надеюсь, это достаточно сложно.

Регулярное выражение (PCRE): 16 байт

^[^\s/\#6]{221}$

Нет места, нет комментариев, нет использования base64_decode. Повеселись.

Выход

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

Оригинальный код

$w=$argv[1];$s="";$r=range(1,$w**2);for($i=0;$i<$w;$i++)if($i%2)array_splice($r,$i*$w,$w,array_reverse(array_slice($r,$i*$w,$w)));foreach(($r)as$v)$s.=str_pad($v,$l=strlen(max($r))+1,"\x20",0);echo(chunk_split($s,$l*$w));

C # net46 ( треснувший )

( http://ideone.com/ работает)

Regex PCRE ароматизатор длина 58 проверен на regex101

^sta((?![\d%bh\/]|==|if|(\[.*){4}|(i.*){6}).){142}urn....$

Только метод является регулярным выражением. Метод возвращает массив 2d int [,] (int [4,4]) для входа n = 4. Если напечатано выглядит так:

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

Это мое первое вступление во что-то подобное, дайте мне знать, если я сделал что-то не так. Не пытаясь выиграть с помощью длины регулярного выражения, мне просто интересно посмотреть, насколько хорошо я справился с предотвращением взлома :)

Оригинальный код:

static int[,]g(int n){int l,j,k=n-n,c,s;var _=new int[n,n];var d=n!=n;c=k;c++;s=k;for(l=k;l<n;l++){for(j=k;j<n;j++){_[l,d?n-j-c:j]=++s;}d=!d;}return _;}

QBasic, регулярное выражение длина 10 ( трещины )

Regex

Должен работать с любым регулярным выражением, но мы назовем это Python.

([A-Z]+.)+

ПРИМЕЧАНИЕ: мое решение использует неформатированный QBasic; после форматирования код не соответствует регулярному выражению из-за добавления пробелов. (Но я могу вам сказать, что это единственное изменение, которое имеет значение. По- ([A-Z]+ ?. ?)+прежнему работает на отформатированной версии.)

В целях тестирования я использовал QB64 с отключенным форматированием кода (в меню «Параметры»> «Разметка кода»). Если вы не хотите что-то скачивать, вы также можете запустить QBasic онлайн на archive.org (но там вы не можете отключить форматирование).

Образец вывода

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

Python 3, 55 байт (треснувший)

PCRE / Python / Golang.

def [triangles=(1,SNAKE)]{27}:print[]SNAKE(--:>or[]{48}

(Напоминаем, что требуется полное совпадение . Предположим ^и$ при тестировании.)

Образец вывода:

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

Оригинальное решение:

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

Надо было обрезать 4 байта: p

dc , Regex length 12   Трещины сешумара!

^[^# !]{59}$

Это регулярное выражение достаточно простое, поэтому я не думаю, что вкус регулярных выражений имеет значение - оно должно работать по всем направлениям. (Обратите внимание на пробел после # в регулярном выражении.)

Я протестировал все четыре варианта на regex101.com (PCRE / PHP, Javascript, Python и Golang), а также версию Ruby на rubular.com. Программа dc соответствует регулярному выражению во всех пяти версиях регулярных выражений.

Программа dc берет свой ввод в stdin и помещает свой вывод в stdout.

Пример вывода для ввода 4 (в конце каждой строки есть пробел):

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

Оригинальный код (добавляется после взлома)

Это было взломано @seshoumara . Вот мой предполагаемый код:

?sd[AP]s+0[dddld/2%rld%2*1+ldr-*+1+n2CP1+dld%0=+dvld>l]dslx

Объяснение:

?sd      Input number and store it in register d.
[AP]s+   Macro that prints a newline. The macro is stored in register '+'.
0        Push 0 on the stack, initializing a loop.  (The top of the stack is the index variable.  It will go up to d^2-1.)
[        Start a macro definition.  (The macro will be stored in register l.)
ddd      Push 3 copies of the loop index variable on the stack, so they'll be available later. I'll call this number i.
ld/      Divide the last copy of i by d (integer division); this computes the row of the square that we're in (starting with row 0).
2%       Replace the row number with 0 if the row number is even, with 1 if the row number is odd.
r        Swap the top two items on the stack, so the top item is now the next to last copy of i, and the second item on the stack is the row number mod 2.
ld%      Compute i mod d; this goes from 0 to d-1. It is the column in the square that the next number will be placed in.  (The leftmost column is column 0.)
2*1+     Top of the stack is replaced with 2*(column number)+1.
ldr      Inserts d as the second item on the stack.
-        Computes d-2*(column number)-1.
*        The second item on the stack is the row number mod 2, so multiplying yields 0 if the row number is even, and d-2*(column number)-1 if the row number is odd.
+        Add to the remaining copy of i. The sum is i itself in even-numbered rows, and it's i+d-2*(column number)-1 in odd-numbered rows.

Сумма наверху стека теперь является следующим числом, которое мы хотим напечатать:

• Легко видеть, что это правильно, если номер строки четный, с тех пор сумма равна просто i.

• Для нечетных строк обратите внимание, что i = d * (i / d) + (i% d) = d * (номер строки) + номер столбца. Отсюда следует, что сумма i + d-2 * (номер столбца) -1 равна d * (номер строки) + номер столбца + d - 2 * (номер столбца) - 1 = d * (номер строки + 1) - номер столбца - 1, это число, которое мы хотим поместить в указанные строку и столбец, чтобы обеспечить обратный отсчет в нечетных строках.

Возвращаясь к объяснению сейчас:

n        Print the desired number for the current row and column.
2CP      Print a space.  (2C, which is computed by dc as 20 + 12, is 32, the ASCII code for a space.)
1+       The original copy of i is at the top of the stack; add 1 to it.
dld%0=+  If (the incremented value of) i is a multiple of d, call the macro at register '+', which prints a newline.
dvld>l   If d > sqrt(i) (in other words, if i < d^2), then go back to the top of the loop by calling macro l again.
]dslx    End the macro definition, store the macro in register l, and execute it.

Bash, длина регулярного выражения 38, трещины ( @kennytm )

^sort -n <[1adegnopqrstx$\-*()|'; ]+$

Входные данные:

n=4; <command>

Выход:

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

PHP

Я надеюсь, что это будет весело! : D

Выход (n = 4)

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

Уровень 1: PCRE (длина = 17) ( взломано Йоргом Хюльсерманом )

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

• Нет одинарных или двойных кавычек, так что ... нет строк!
• Без цифр!
• Нет {так ... нет анонимных функций!
• Нет vтак ... нет eval()!
• Нет, ;так ... это должно быть одно утверждение!
• Нет <так ... нет, Heredocни несколько блоков PHP!
• Большая! Нет $ так ... удачи определения переменных! >: D

У @ JörgHülsermann был интересный подход, но это не то, что я имел в виду :). Поэтому я ввожу новый уровень сложности (обещаю, что у меня есть код, который подходит для этого, и я не просто возиться с вами):

Уровень 2: PCRE (длина = 23) ( взломано Йоргом Хюльсерманом )

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

• Все ограничения уровня 1
• Новое на этом уровне: ничего из этого _~|&A-Z! :)

Повеселись!

ОРИГИНАЛЬНОЕ РЕШЕНИЕ

Таким образом, запрещение $значащих переменных не может быть доступно обычным способом, но это не означает, что они не могут использоваться вообще! Вы все еще можете использовать extract()/compact()для импорта / экспорта переменных в текущую область. :)

$i = 1;
// can be written as
extract(['i' => 1])

echo $i;
// can be written as
echo compact('i')['i'];

Тем не менее, есть хитрость: compact('x')['x']++не будет работать, потому что переменные в PHP передаются по значению ... за одним исключением! Объекты.

$x = (object) ['i' => 1];
// is
extract(['x' => (object) ['i' => 1]]);

// and
compact('x')['x']->i++;
// works just fine!

Остальное легко.

• Числа 0и 1легко образуются путем преобразования falseи trueв int, предваряя их с +знаком
• Использование andи orс тех пор &и |запрещено
• Чтобы обойти запрещенные кавычки, просто используйте неопределенные константы, которые рассматриваются как строки
• Чтобы подавить уведомления, генерируемые с помощью неопределенных констант, просто используйте @
• Запрещенное письмо vможет быть сгенерировано с помощью chr(ord('u') + 1), что означает @chr(ord(u) + true)использование вышеупомянутых обходных путей.
• Подчеркивание аналогично приведенному выше: chr(ord('a') - 2)что означаетchr(ord(a) - true - true)
• Вызов функций, которые содержат запрещенные символы, может быть выполнен с использованием типа PHP callable, который может быть строкой, содержащей имя функции. Таким образом, вы можете объединить неопределенные константы и одиночные символьные строки, сгенерированные ord()для создания имени функции и вызова его следующим образом: array_reverse()gets (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayявляется языковой конструкцией, поэтому она разбивается на неопределенные константы aи rray)
• Воспользуйтесь тем фактом, что когда дело доходит до условных и циклических конструкций, фигурные скобки являются необязательными, если конструкция применяется только к непосредственно следующему выражению. Это означает, что вы можете делать такие вещи, как: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

Логика в читаемом человеком коде будет выглядеть так:

if (
    $x = (object) [
        'result' => [],
        'i' => 0
    ]

    and

    define('n', $argv[1])

    and

    define('un', '_')

    and

    // create the initial set which we'll loop through
    define('segments', array_chunk(range(1, pow(n, 2)), n))
) while (
    // store each odd segment as-is and increment the "pointer"
    ($x->result[] = @segments[$x->i++])

    and

    // store each even segment reversed and increment the "pointer"
    ($x->result[] = @array_reverse(segments[$x->i++]))

    and

    // check if we need to break out of the loop
    n > $x->i

    or

    // exit and output the result if the above is false
    die(json_encode(
        // if n is odd, the above would have copied a NULL entry 
        // from the segments, so it needs to be filtered out
        array_filter($x->result)
    ))
)

И недружественная версия, которая соответствует регулярному выражению:

<?php if (@extract([x=>(object)[s=>[],i=>+false]])and@define(n,compact(arg.chr(ord(u)+true))[arg.chr(ord(u)+true)][+true]?:+true)and@define(un,chr(ord(a)-true-true))and@define(s,(a.rray.un.chunk)(range(+true,pow(n,true+true)),n)))while((@compact(x)[x]->s[]=s[@compact(x)[x]->i++])and(@compact(x)[x]->s[]=(a.rray.un.re.chr(ord(u)+true).erse)(s[@compact(x)[x]->i++]))and(n>@compact(x)[x]->i)or(@die((json.un.encode)((a.rray.un.filter)(@compact(x)[x]->s)))))?>

Рубин [трещина]

Первый вызов копов и грабителей. Надеюсь, я не сделал это слишком легко.

РЕДАКТИРОВАТЬ: заменено \g<1>на, (?1)потому что они, очевидно, эквивалентны в PCRE.

Регулярное выражение (PCRE)

^(\W?\W\w){4}..(?1){2}[(-=Z-~]*(?1){5}\w*(?1)(.)\2$

Выход (n = 4)

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

(Возвращает массив массивов. Это лямбда, кстати, но может это слишком много?)

JavaScript (взломан)

В первый раз выполняя задачу «Копы и грабители», надеюсь, сделаем это правильно.

Регулярное выражение (JavaScript)

^.*(\.\w+\(.*\)){4}$

Выход

Массив, равный:

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

Свифт, регулярное выражение 25 (треснувший)

Хорошо, посмотрим, понял ли я это. Это мой первый пост о копах и грабителях, так что позвольте мне знать, если я все испортил!

Regex

Я использовал вкус javascript на regex101.com

^.{21}print[^/]{49}o.{7}$

Пример вывода

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

Оригинальный код

(0..<n).forEach{i in print((0..<n).map{i%2>0 ?(i+1)*n-$0 :i*n+$0+1},separator:",")}

C - регулярное выражение длиной 42 символа - взломано

Регулярное выражение Javascript, используемое в regex101 .

^[-h<=*c+m?{printf("\/a: %d\\',o);}]{137}$

Угадай это будет тривиально ...

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

Выходные данные разделяются табуляцией \nпосле каждой строки.

Мое решение, здесь целые числа 0 - 2 , были получены с помощью t-t, t/tи t:

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

Желе , длина 14 трещины

взломан Деннисом

[^/P-`mvḊ-ṫ€]*

Регулярное выражение Python

Добавлено mснова после того, как я позволил ему ускользнуть.

/(уменьшить быстро);
от P(продукта) до `(монада от диады быстрой);
m(по модулю индексации);
v(Eval Dyad);
от Ḋ(dequeue) до ṫ(tail); и
€(за каждый быстрый)

Для ввода 4моих выходов:

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

... потому что я отформатировал список списков в виде сетки с G.

Powershell, 23 байта

Взломанный Мэттом

^.+?%.{42}%.{11}:.{35}$

Оригинальное решение:

$n="$args";$script:r=0;$a=1..$n|%{$t=++$script:r..($script:r+=$n-1);if(!($_%2)){[Array]::Reverse($t)};,$t};$a|%{$_-join" "}

Принимает ввод в качестве аргумента и выводит на стандартный вывод

Надеюсь, с этим регулярным выражением все в порядке, я не ожидаю, что его будет слишком сложно взломать, так как я не запутал большую его часть, и регулярное выражение дает немало хороших отправных точек, чтобы заполнить пробелы, есть одна вещь в первом сегменте что очень редко встречается в кодовом гольфе, хотя, которое может кого-то поймать, я думаю, что для того, чтобы сделать это немного более жестким, требуется не жадный матч.

В любом случае, первый вызов полиции

1..4 | % { "----$_----" ; .\snake-cops.ps1 $_  }
----1----
1
----2----
1 2
4 3
----3----
1 2 3
6 5 4
7 8 9
----4----
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13

Рода 0,12 , длина 19 (взломано @KritixiLithos)

PCRE:

^{(\|[^\/#\s]*){8}$

Пример вывода (n = 4):

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

Оригинальный код:

{|n|seq(0,n-1+n%2)|push([{|i|seq(n*i+1,n*i+n)}(_)],[{|j|seq(n*j+n,n*j+1,step=-1)}(_)])|head(n)}

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

PHP 7 (безопасный)

Оригинальный код

for($z=0,$q="";$z<($x=$argv[1])**2;){$w=($d=intdiv($z,$x))%2?($d+1)*$x-$z%$x:($z+1);for($f=0;$f<(log10($x**2)^0)-(log10($w)^0);$f++)$q.="\x20";$q.=++$z%$x?"$w\x20":"$w\n";}print(rtrim($q));

Вторая попытка

Регулярное выражение (PCRE): 29 байт

^[^A-Z#\/\s\>busy_heck]{189}$

Нет места, нет комментариев, нет использования base64_decode.

Многие функции не допускаются! подчеркивать

Выход n = 11

  1   2   3   4   5   6   7   8   9  10  11
 22  21  20  19  18  17  16  15  14  13  12
 23  24  25  26  27  28  29  30  31  32  33
 44  43  42  41  40  39  38  37  36  35  34
 45  46  47  48  49  50  51  52  53  54  55
 66  65  64  63  62  61  60  59  58  57  56
 67  68  69  70  71  72  73  74  75  76  77
 88  87  86  85  84  83  82  81  80  79  78
 89  90  91  92  93  94  95  96  97  98  99
110 109 108 107 106 105 104 103 102 101 100
111 112 113 114 115 116 117 118 119 120 121

Выход n = 4

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

Выход n = 3

1 2 3
6 5 4
7 8 9

MATL , длина 12 (безопасно)

Regex

Использует вкус Python:

(\w{3}\W){5}

Пример вывода

Для n=4:

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

Решение

txU:GeG:oEq*S5M*TTx!

Чтобы увидеть, как это работает, рассмотрим ввод n=4.

tx   % Implicit input n, duplicate, delete. So this does nothing
     % STACK: 4
U    % Square
     % STACK: 16
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
Ge   % Reshape as an n-row array in column major order
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
G:   % Push range [1 2 ... n]
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
               [1 2 3 4]
o    % Modulo 2
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1  0  1  0]
Eq   % Times 2, minus 1 (element-wise)
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1 -1  1 -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1 -5  9 -13;
               2 -6 10 -14
               3 -7 11 -15
               4 -8 12 -16]
S    % Sort each column
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
5M   % Push [1 -1 1 -1] again
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
              [1 -1  1  -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1  8  9  16;
               2  7 10  15;
               3  6 11  14;
               4  5 12  13]
TTx  % Push [true true] and delete it. So this does nothing
!    % Transpose. Implicitly display
     % STACK: [ 1  2  3  4;
                8  7  6  5;
                9 10 11 12;
               16 15 14 13]

Желе , длина 17 (безопасно)

[^/P-`mvÇ-ıḃ-ṫ€]*

Регулярное выражение Python

Затягивая узел, это запрещает еще несколько полезных вещей, для вашей помощи вот запрещенные байты:

/PQRSTUVWXYZ[\]^_`mvÇÐÑ×ØÞßæçðñ÷øþĊċĖėĠġİıḃḄḅḊḋḌḍḞḟḢḣḤḥḲḳḶḷṀṁṂṃṄṅṆṇṖṗṘṙṚṛṠṡṢṣṪṫ€

чуть менее трети из них!

Для ввода 4моих выходов:

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

... потому что я отформатировал список списков в виде сетки с G.

Решение:

’:2o1
Ḃ¬aẋ@0
’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G

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

Основной трюк здесь состоит в том, чтобы индексировать в лексикографически отсортированный список перестановок натуральных чисел до n ² (используя,œ?чтобы избежать построения списка длины n ² ! ), И разбить результат на куски длины n . Вышеупомянутый индекс находится путем формирования его представления в системе факторных чисел, которая является формульной, поскольку «не нарезанная» змея создается путем перестановки элементов в заданном порядке (это может быть легко преобразовано в число сÆ¡ ).

Решение, которое я представляю, использует Ŀдля ссылки на предыдущие ссылки как на монады (замена Ñи Ç), но $вместо этого можно использовать несколько строк подряд, чтобы «встроить» эти вспомогательные функции. Он также использует rс тех пор Ḷи Rзапрещен.

’:2o1 - Link 1, periodic repetitions in the factorial base representation: n
’     - decrement n
 :2   - integer divide by 2
   o1 - or 1 (keep one period in the cases n=1 and n=2)

Ḃ¬aẋ@0 - Link 2, n zeros if n is even, else an empty list: n
Ḃ      - mod 2
 ¬     - not
   ẋ@0 - 0 repeated n times
  a    - and

’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G - Main link: n                    e.g. 6
’r0                        - inclusive range(n-1, 0)              [5,4,3,2,1,0]
    0ẋ$                    - 0 repeated n times                   [0,0,0,0,0,0]
   ;                       - concatenate (makes one "period")     [5,4,3,2,1,0,0,0,0,0,0,0]
        1Ŀ                 - call link 1 as a monad               2
       ẋ                   - repeat list                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,0]
           0¦              - apply to index 0 (rightmost index):
          ¬                -     not (make the last 0 a 1)        [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1]
              2Ŀ           - call link 2 as a monad               [0,0,0,0,0,0]
             ;             - concatenate                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0]
                Æ¡         - convert from factorial base          45461852049628918679695458739920
                      ¤    - nilad followed by link(s) as a nilad
                    ⁸      -     left argument, n                 6
                     ²     -     square                           36
                  œ?       - lexicographical permutation lookup   [1,2,3,4,5,6,12,11,10,9,8,7,13,14,15,16,17,18,24,23,22,21,20,19,25,26,27,28,29,30,36,35,34,33,32,31]
                       s⁸  - split into chunks of length n        [[1,2,3,4,5,6],[12,11,10,9,8,7],[13,14,15,16,17,18],[24,23,22,21,20,19],[25,26,27,28,29,30],[36,35,34,33,32,31]]
                         G - format as a grid

Pip , regex длина 3 (безопасно)

Решением является полная программа, которая принимает n в качестве аргумента командной строки. Он не использует никаких флагов командной строки.

Регекс (любой вкус)

\w+

Образец вывода

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

Мое решение

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

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

стратегия

Вот код, который мы хотели бы написать:

Y \,a
F i ,a
 I i%2
  P i*a+_.s M RVy
 E
  P i*a+_.s M y

То есть:

• Сохраните числа от 1 до a вy
• Цикл значений iот 0 доa-1
• Если iнечетно, переверните y, добавьте i*aк каждому элементу, объедините пробел с каждым элементом и напечатайте
• В противном случае, сделайте то же самое, но не поворачивая сначала

Сложности

Многие команды и переменные в Pip используют буквы, но некоторые важные не делают:

• Диапазон и включающий диапазон ( ,и \,)
• Большинство математических операций ( +, -, *, %, ++)
• Назначение ( :)
• У нас не может быть цикла или тела функции с более чем одним оператором (что потребуется {})
• Мы не можем использовать скобки для обеспечения приоритета

Как нам обойти эти ограничения:

• ENвместо можно использовать умерат ,; нам просто нужна строка с количеством символов, которое мы хотим, и нам нужно извлечь первый элемент каждого подсписка в структуре, как[[0 "H"] [1 "i"]] .
• Нам не нужно ничего увеличивать, если мы можем решить проблему с помощью Fциклов или.
• Мы можем присвоить yпеременную с помощью Yоператора ank.
• Мы можем сделать математику со строками: Xэто умножение строк, и PUsh (или PB«push-back») объединит строку с другой строкой на месте. Чтобы взять длину строки, мы можем ее ENисчислить и извлечь правильное число из полученного списка.
• Мы можем использовать функции при условии, что они могут быть написаны как лямбда-функции с одним выражением _.

конкретика

Строительные блоки нашей программы:

Диапазон

_MUENsXa

Это map-unpack(_, enumerate(repeat(space, a)))в псевдокоде. Распаковка карты аналогична Python itertools.starmap: учитывая список списков, она вызывает функцию для элементов каждого подсписка. _возвращает свой первый аргумент, поэтому _MUпросто получает первый элемент каждого подсписка. Например, если а = 3:

     sXa  "   "
   EN     [[0 " "] [1 " "] [2 " "]]
_MU       [0 1 2]

... который так же, как ,a.

Инклюзивный ассортимент

Я не уверен, что есть способ сделать это inclusive-range(1, a)в одном выражении, но, к счастью, он нужен нам только один раз, поэтому мы можем построить его в yпеременной за три шага.

YENsXaPBs

В псевдокоде yank(enumerate(repeat(space, a).push-back(space))):

   sXa     "   "
      PBs  "    "
 EN        [[0 " "] [1 " "] [2 " "] [3 " "]]
Y          Store that in y

Далее POyвыскакивает первый элемент yи удаляется, оставляя [[1 " "] [2 " "] [3 " "]].

В заключение,

Y_MUy

То есть yank(map-unpack(_, y)): извлечь первый элемент каждого подсписка и вернуть полученный список обратно y. yсейчас[1 2 3] .

длина

PODQENaPBs

В псевдокоде pop(dequeue(enumerate(a.push-back(space)))). Трудность здесь в том, что перечисление только дает нам числа до len(a)-1, но мы хотим len(a). Таким образом, мы сначала вставляем пробел a, удлиняя его на один символ, а затем берем len-1новую строку.

      a     "xyz"
       PBs  "xyz "
    EN      [[0 "x"] [1 "y"] [2 "z"] [3 " "]]
  DQ        [3 " "]
PO          3

математический

Теперь, когда у нас есть способ взять длину строки, мы можем использовать строки для умножения и сложения чисел:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

Первый делает sXaXbдля создания строки a*bпробелов, а затем принимает длину; вторая делает, sXaPBsXbчтобы вставить строку bпробелов в строку aпробелов, а затем принимает ее длину.

Хорошая часть , что все операторы мы используем , здесь ( PU, PO, PB, DQ, EN, X) можно использовать с_ в форме лямбда - выражения. Таким образом, мы можем сопоставить математические преобразования с инклюзивным диапазоном, который мы построили ранее.

Нам также необходимо проверить i%2внутри цикла, но это легко сделать с побитового И: iBA1.

Положить их вместе

Полный код с некоторыми добавленными пробелами:

YENsXaPBs POy Y_MUy              Get \,a into y
F i _MUENsXa                     For i in ,a
 I iBA1                           If i%2=1
  P sPUPODQENsXiXaPBsX_PBs M RVy   Print sPUi*a+_ M RVy
 EI1                              Elseif 1 (using E would cause a parsing problem)
  P sPUPODQENsXiXaPBsX_PBs M y     Print sPUi*a+_ M y

CJam, PCRE, длина 8, трещины

^[a-~]*$

Пример вывода для 4:

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

CJam, PCRE, длина 9, трещины

^[a-z~]*$

Пример вывода для 4:

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

Теперь {|}тоже забанены.

Mathematica, длина регулярного выражения 11, неконкурентоспособная , с трещинами

PCRE аромат:

^[^]@]{49}$

Правильным решением будет функция, которая принимает целое число и возвращает вывод в виде вложенного списка, например:

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

тинилисп , регулярное выражение длина 3 ( трещины )

Вы можете проверить код tinylisp на сайте Try it online!

Регекс (любой вкус)

\S+

Время идти в хардкор.

Выход

Решение определяет функцию, которая принимает один целочисленный аргумент и возвращает такой список (для n = 4):

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

Мой оригинальный код использует ту же основную идею, которую придумал Брайан МакКатчон, создавая списки и оценивая их. Вот это в одной строке:

(v(c(h(q(d)))(c(h(q(d')))(c(c(h(q(q)))(c(c()(c(q(arglist))(c(c(h(q(v)))(c(c(h(q(c)))(c(c(h(q(q)))(q(d)))(q(arglist))))()))())))()))()))))(d'(seq-args(c(h(q(start)))(c(h(q(stop)))(c(h(q(step)))())))))(d'(seq(c(c(h(q(accum)))seq-args)(q((i(e(v(h(q(start))))stop)(c(v(h(q(start))))accum)(seq(c(v(h(q(stop))))accum)start(s(v(h(q(stop))))step)step)))))))(d'(f'(c(c(h(q(index)))(c(h(q(size)))seq-args))(q((i(e(v(h(q(index))))size)()(c(seq()start(v(h(q(stop))))step)(f'(a(h(q(1)))index)size(a(v(h(q(stop))))size)(a(v(h(q(start))))size)(s(h(q(0)))step)))))))))(d'(f(q((size)(f'(h(q(0)))size(h(q(1)))size(h(q(1))))))))

Я использовал полный метод construct-and-eval один раз, чтобы определить макрос, d'который делает определения похожими d, но принимает свои аргументы в виде списка: так что вместо этого (d x 42)вы можете сделать (d'(x 42)). Тогда нужно было просто переписать любые списки в определениях, которым может понадобиться пробел: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, длина 162 (треснул!)

Regex: ^([^"' #]){24}"(?1){11}i%n(?1){4}2\*n-(?1){4}i%n(?1){10}i\/n(\)\/\/1)(?1){5}(?2)(?1){3}2\*\(i%n\)(?1){4}[int()2\/]{16}for i in range\(j,(?1){4}\]\)(?1){6}\"\*n\)$

Хорошо, я знаю, это довольно долго. К счастью, это не будет взломано в течение недели ...: D.

Думаю, я нигде не ошибся, что позволило бы получить лазейку в ответах.

Выходной формат

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

Оригинальный код:n=int(input());j=0;exec("print([int(i%n+1+(2*n-(2*(i%n)+1))*((((i/n)//1+1)/2)//1)+(2*(i%n)+1)*int(int(i/n)/2))for i in range(j,j+n)]);j+=n;"*n)