Це нитка копа. У потоці грабіжника тут .

Напишіть код, який бере вхід 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, щоб грабіжники знали точний формат, який ви обрали.

Ви можете використовувати один із ароматів регулярного вибору , який доступний на сайті regex101.com , або аромат Ruby.

• PCRE (PHP)
• Javascript
• Пітон
• Голанг
• Рубін

Ви повинні вказати, який саме ви використовуєте.

Примітки:

• Ви повинні підтримувати будь-які досить великі 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}ˆ

Пітон 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>, #, ;та [. Я тестував це тут

Регекс

^[^ #;\[]{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, Потрісканий Аароном

Regex (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 байт ( тріщини )

Я сподіваюся, що це досить складно.

Regex (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 ( тріщинами )

Регекс

Має працювати з будь-яким ароматом регулярного вираження, але ми будемо називати його смаком 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

постійний струм , довжина Regex 12   Розтріскана seshoumara!

^[^# !]{59}$

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

Я перевірив усі чотири аромати на regex101.com (PCRE / PHP, Javascript, Python та Golang), а також версію Ruby на rubular.com. Програма 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 = 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'];

Однак є gotcha: 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)
• Виклик функцій, які містять заборонені символи, можна здійснити, скориставшись callableтипом PHP , який може бути рядком, що містить назву функції. Отже, ви можете об'єднати невизначені константи та окремі символьні рядки, створені ord()для створення назви функції та викликати її так: array_reverse()стає (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)))))?>

Ruby [тріснув]

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

EDIT: замінено \g<1>тим, (?1)що вони очевидно еквівалентні в PCRE.

Regex (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]]

(Повертає масив масивів. Це лямбда, BTW, але, можливо, це дає занадто багато?)

JavaScript (зломлений)

Перший раз робили виклик поліціям та розбійникам, сподіваємось, що це зробити правильно.

Regex (JavaScript)

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

Вихідні дані

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

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

Швидкий, регекс 25 (тріщини)

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

Регекс

Я використовував аромат 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) до ṫ(хвіст); і
€ (за кожен швидкий)

Для введення 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" "}

Приймає введення як аргумент і виводить до stdout

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

Перші поліцейські кидають виклик.

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

Röda 0,12 , довжина 19 (Cracked by @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));

Друга спроба

Regex (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 (безпечно)

Регекс

Використовує аромат 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 , регулярний вираз довжиною 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просто отримує перший елемент кожного списку. Наприклад, якщо a = 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 на " Спробуйте його онлайн"!

Регекс (будь-який аромат)

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

Я використовував один раз повний метод конструювання-і-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)