To jest wątek gliny. W gwint rabuś jest tutaj .

Napisz kod, który pobiera dane wejściowe ni tworzy „macierz węża” n-po-n.

Matryca węża to matryca zgodna z tym wzorem:

3 na 3:

1  2  3
6  5  4
7  8  9

i 4 na 4:

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

Dokładny format wyjściowy jest opcjonalny. Możesz na przykład uzyskać wynik [[1 2 3],[6 5 4],[7 8 9]]lub coś podobnego.

Musisz podać nazwę języka i wyrażenie, które w pełni odpowiada Twojemu kodowi. Możesz wybrać stopień szczegółowości wyrażenia regularnego. W skrajności możesz napisać wyrażenie pasujące do każdego możliwego ciągu, w którym to przypadku bardzo łatwo będzie złamać kod. Musisz także podać dane wyjściowe n=4, aby złodzieje znali dokładnie ten format, który wybrałeś.

Możesz użyć jednego ze smaków wyrażeń regularnych , które są dostępne na regex101.com , lub smaku Ruby.

• PCRE (PHP)
• JavaScript
• Pyton
• Golang
• Rubin

Musisz określić, którego używasz.

Uwagi:

• Musisz wesprzeć każdą dość dużą n. Możesz założyć, że nie przepełni typu danych lub pamięci. Jeśli domyślnym typem danych są 8-bitowe liczby całkowite ze znakiem, możesz założyć n<=11, jeśli jest to 8-bitowe liczby całkowite bez znaku, możesz założyć n<=15.
• Rabusie muszą pasować do formatu wyjściowego przesłania, z wyjątkiem spacji wiodących / końcowych i znaków nowej linii, ponieważ formatowanie SE mogło zostać usunięte.

Kryterium wygranej:

Zwycięzcą zostanie zgłoszenie bez udziału dowodu z najkrótszym wyrażeniem regularnym, mierzonym liczbą znaków.

Jeśli Twój post pozostawał nieprzerobiony przez 7 dni, możesz opublikować zamierzone rozwiązanie i oznaczyć zgłoszenie jako bezpieczne.

05AB1E , Cracked by mbomb007

Mam nadzieję, że fajnie będzie je złamać i nie będzie to zbyt oczywiste.

Regex (PCRE):

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

Wyjście n = 4:

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

Oryginalne rozwiązanie

UXFXLNX*+NFR}ˆ

Python 2 , długość 62, pęknięty

Regex (PCRE)

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

Próbka wyjściowa

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

Galaretka , długość 6, popękana

Regex (PCRE)

^.{9}$

Próbka wyjściowa

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

R, długość 14 Pęknięty przez plannapa

Mam nadzieję, że mam poprawne wyrażenie regularne. Co ja próbuje powiedzieć to 77 znaków z wyjątkiem <space>, #, ;i [. Testowałem to tutaj

Regex

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

Wyjściowa próbka n = 4

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

05AB1E , Cracked by Value Ink

Podnieśmy poprzeczkę :)
Mam nadzieję, że fajna łamigłówka.

Regex (PCRE)

^\w*..\w*$

Wyjście n = 4

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

> <> , długość 49, Pęknięty przez Aarona

Regex (JavaScript)

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

Wyjściowa próbka (n = 4)

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

Formatowanie jest trochę dziwne, ale sprawdzanie długości liczb znacznie by ją wydłużyło. Być może poszedł trochę za burtę w wyrażeniu regularnym, nie jestem pewien!

Edycja: Również zapomniałem wspomnieć, używam początkowego stosu (flaga -v) do wprowadzania danych, a nie zwykłego wprowadzania ryb. Przepraszam!

Kod oryginalny:

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

Aaron's jest o wiele prostszy! Złożoność mojego oryginalnego kodu opiera się na pomyśle używania n[r]co n-tej liczby do odwracania tego segmentu (wiersza), a następnie drukowania wszystkich liczb jednocześnie na końcu

Och , pęknięty

Również moje pierwsze wyzwanie dla gliniarzy i złodziei, więc powiedz mi, czy występują problemy z tym wzorem (zwłaszcza, że ​​jest to dość nieznany język).

Regex (PCRE)

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

Wyjście (n = 4)

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

PHP, 221 bajtów ( pęknięty )

Mam nadzieję, że to wystarczająco trudne.

Regex (PCRE): 16 bajtów

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

Bez spacji, bez komentarzy, bez użycia base64_decode. Baw się dobrze.

Wydajność

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

Kod oryginalny

$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 (Cracked)

( http://ideone.com/ działa)

Regex PCRE o smaku długości 58 testowany przy regex101

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

Tylko metoda jest regexowana. Metoda zwraca tablicę 2d int [,] (int [4,4]) dla wejścia n = 4. Jeśli wydrukowane wygląda tak:

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

To mój pierwszy wpis w coś takiego. Daj mi znać, jeśli zrobiłem coś złego. Na pewno nie próbuję wygrać wyrażeniem regularnym, po prostu jestem ciekawy, jak dobrze poradziłem sobie w zapobieganiu pękaniu :)

Oryginalny kod:

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, długość wyrażenia regularnego 10 ( pęknięty )

Regex

Powinien działać w dowolnym smaku regex, ale nazwiemy go smakiem Python.

([A-Z]+.)+

UWAGA: Moje rozwiązanie używa niesformatowanego QBasic; po sformatowaniu kod nie pasuje do wyrażenia regularnego z powodu dodanych spacji. (Ale można powiedzieć, że jest to jedyna zmiana, która czyni różnicę. ([A-Z]+ ?. ?)+Nadal działa na wersji sformatowany).

Do celów testowych użyłem QB64 z wyłączonym formatowaniem kodu (w Opcje> Układ kodu). Jeśli nie chcesz czegoś pobierać, możesz także uruchomić QBasic online na archive.org (ale tam nie możesz wyłączyć formatowania).

Próbka wyjściowa

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

Python 3, 55 bajtów (pęknięty)

Smak PCRE / Python / Golang.

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

(Przypominamy, że wymagane jest pełne dopasowanie . Załóż ^i $podczas testowania.)

Przykładowe dane wyjściowe:

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

Oryginalne rozwiązanie:

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

Powinny zostać przycięte 4 bajty: s

dc , Regex length 12   Cracked by seshoumara!

^[^# !]{59}$

To wyrażenie regularne jest na tyle proste, że nie sądzę, że smak wyrażeń regularnych ma znaczenie - powinien działać ogólnie. (Zwróć uwagę na spację po # w wyrażeniu regularnym.)

Przetestowałem wszystkie cztery smaki na stronie regex101.com (PCRE / PHP, JavaScript, Python i Golang), a także wersję Ruby na rubular.com. Program dc pasuje do wyrażenia regularnego we wszystkich pięciu wersjach wyrażenia regularnego.

Program dc pobiera dane wejściowe na standardowe wejście, a dane wyjściowe na standardowe wyjścia.

Przykładowe dane wyjściowe dla wejścia 4 (na końcu każdego wiersza znajduje się spacja):

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

Oryginalny kod (dodany po pęknięciu)

To zostało złamane przez @seshoumara . Oto mój zamierzony kod:

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

Wyjaśnienie:

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

Suma u góry stosu jest teraz kolejną liczbą, którą chcemy wydrukować:

• Łatwo zauważyć, że jest to poprawne, jeśli numer wiersza jest parzysty, ponieważ wtedy suma to tylko ja.

• W przypadku wierszy nieparzystych zwróć uwagę, że i = d * (i / d) + (i% d) = d * (numer wiersza) + numer kolumny. Wynika z tego, że suma i + d-2 * (numer kolumny) -1 to d * (numer wiersza) + numer kolumny + d - 2 * (numer kolumny) - 1 = d * (numer wiersza + 1) - numer kolumny - 1, czyli liczbę, którą chcemy wstawić we wskazanym wierszu i kolumnie, aby mieć pewność, że liczymy wstecz w wierszach nieparzystych.

Wracając do wyjaśnienia teraz:

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, długość wyrażenia regularnego 38, pęknięty ( @kennytm )

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

Wejście:

n=4; <command>

Wynik:

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

PHP

Mam nadzieję, że to będzie zabawne! :RE

Wyjście (n = 4)

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

Poziom 1: PCRE (długość = 17) ( pęknięty przez Jörga Hülsermanna )

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

• Bez pojedynczych lub podwójnych cudzysłowów, więc ... żadnych zobowiązań!
• Bez cyfr!
• Nie, {więc ... żadnych anonimowych funkcji!
• Nie, vwięc ... nie eval()!
• Nie, ;więc ... to musi być jedno stwierdzenie!
• Nie, <więc ... nie ma Heredocwielu bloków PHP!
• Duży! No $ więc ... powodzenia w definiowaniu zmiennych! >: D

@ JörgHülsermann miał ciekawe podejście, ale nie o to mi chodziło :). Dlatego wprowadzam nowy poziom trudności (obiecuję, że mam kod, który to pasuje i nie tylko się z tobą bawię):

Poziom 2: PCRE (długość = 23) ( pęknięty przez Jörga Hülsermanna )

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

• Wszystkie ograniczenia poziomu 1
• Nowość na tym poziomie: żaden z nich _~|&A-Z! :)

Baw się dobrze!

ORYGINALNE ROZWIĄZANIE

Zatem zakazanie $oznaczania oznaczało, że zmienne nie były dostępne w zwykły sposób, ale to nie znaczy, że nie można ich w ogóle użyć! Nadal możesz używać extract()/compact()do importowania / eksportowania zmiennych do bieżącego zakresu. :)

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

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

Jest jednak gotcha: compact('x')['x']++nie działałby, ponieważ zmienne w PHP są przekazywane przez wartość ... z jednym wyjątkiem! Obiekty

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

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

Reszta jest łatwa.

• Liczby 0i 1są łatwo generowane przez konwersję falsei trueaby intprzez poprzedzenie ich ze +znakiem
• Użyj anda orponieważ &i |są zabronione
• Aby obejść niedozwolone cytaty, użyj po prostu niezdefiniowanych stałych, które są traktowane jak łańcuchy
• Aby ukryć powiadomienia generowane przy użyciu niezdefiniowanych stałych, wystarczy użyć @
• Niedozwoloną literę vmożna wygenerować za pomocą chr(ord('u') + 1), co przekłada się na @chr(ord(u) + true)użycie powyższych obejść
• Podkreślenie jest podobne do powyższego: chr(ord('a') - 2)co przekłada się nachr(ord(a) - true - true)
• Wywoływanie funkcji zawierających niedozwolone znaki można wykonać, wykorzystując callabletyp PHP , który może być ciągiem zawierającym nazwę funkcji. Możesz więc połączyć niezdefiniowane stałe i ciągi pojedynczych znaków wygenerowane przez, ord()aby zbudować nazwę funkcji i wywołać ją w następujący sposób: array_reverse()staje się (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayjest konstrukcją języka, dlatego dzieli się na niezdefiniowane stałe ai rray)
• Skorzystaj z faktu, że jeśli chodzi o konstrukcje warunkowe i pętle, nawiasy klamrowe są opcjonalne, jeśli konstrukcja dotyczy tylko następującej po niej instrukcji. Oznacza to, że możesz robić takie rzeczy jak: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

Logika w czytelnym dla człowieka kodzie byłaby następująca:

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

I nieprzyjazna wersja, która pasuje do wyrażenia regularnego:

<?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 [pęknięty]

Pierwsze wyzwanie gliniarzy i złodziei. Mam nadzieję, że nie uczyniłem tego zbyt łatwym.

EDYCJA: zastąpiona \g<1>przez, (?1)ponieważ są one ewidentnie równoważne w PCRE.

Regex (PCRE)

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

Wyjście (n = 4)

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

(Zwraca tablicę tablic. To lambda, BTW, ale może to rozdaje za dużo?)

JavaScript (pęknięty)

Po raz pierwszy wykonuję wyzwanie dla gliniarzy i rabusiów, mając nadzieję, że zrobi to dobrze.

Regex (JavaScript)

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

Wydajność

Tablica równa:

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

Swift, regex 25 (Cracked)

Racja, zobaczmy, czy mam to na uwadze. To jest mój pierwszy post z gliniarzy i rabusiów, więc daj mi znać, czy się popsułem!

Regex

Użyłem smaku javascript na regex101.com

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

Przykładowe dane wyjściowe

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

Kod oryginalny

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

C - regex długości 42 znaków - pęknięty

Wyrażenia regularne JavaScript używane w regex101 .

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

Zgadywanie będzie trywialne ...

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

Dane wyjściowe są rozdzielane tabulatorami \npo każdym wierszu.

Moje rozwiązanie, tutaj liczby całkowite 0 - 2 uzyskano za pośrednictwem t-t, t/toraz 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');}

Galaretka , długość 14 spękana

pęknięty przez Dennisa

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

Wyrażenie regularne Pythona.

Dodano mponownie po tym, jak pozwoliłem mu się ześlizgnąć.

/(zmniejsz szybko);
od P(produktu) do `(monada z diada szybko);
m(indeksowanie modulo);
v(eval diada);
od Ḋ(dequeue) do ṫ(tail); i
€(dla każdego szybkiego)

Dla danych wyjściowych z 4kopalni:

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

... ponieważ sformatowałem listę list jako siatkę za pomocą G.

PowerShell, 23 bajty

Cracked By Matt

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

Oryginalne rozwiązanie:

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

Pobiera dane wejściowe jako argument i dane wyjściowe na standardowe wyjście

Mam nadzieję, że ten wyrażenie regularne jest w porządku, nie spodziewam się, że będzie to zbyt trudne do złamania, ponieważ nie zaciemniłem go zbyt wiele, a wyrażenie regularne daje kilka dobrych punktów początkowych do uzupełnienia luk, jest jedna rzecz w pierwszym segmencie co jest bardzo rzadkie w golfie kodowym, co może kogoś złapać, myślę, że wymagany jest nie chciwy mecz, aby uczynić to nieco trudniejszym.

Mimo to pierwsi gliniarze rzucają wyzwanie.

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 , długość 19 (Pęknięty przez @KritixiLithos)

PCRE:

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

Przykładowe dane wyjściowe (n = 4):

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

Oryginalny kod:

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

Wypróbuj online!

PHP 7 (bezpieczny)

Kod oryginalny

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

Drugie podejście

Regex (PCRE): 29 bajtów

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

Bez spacji, bez komentarzy, bez użycia base64_decode.

Wiele funkcji jest niedozwolonych! podkreślać

Wyjście 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

Wyjście n = 4

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

Wyjście n = 3

1 2 3
6 5 4
7 8 9

MATL , długość 12 (bezpieczny)

Regex

Używa smaku Python:

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

Przykładowe dane wyjściowe

Dla n=4:

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

Rozwiązanie

txU:GeG:oEq*S5M*TTx!

Aby zobaczyć, jak to działa, rozważ dane wejściowe 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]

Galaretka , długość 17 (bezpieczna)

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

Wyrażenie regularne Pythona.

Zacieśniając węzeł, zakazuje to kilku bardziej przydatnych rzeczy, dla twojej pomocy są tutaj zakazane bajty:

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

prawie jedna trzecia z nich!

Dla danych wyjściowych z 4kopalni:

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

... ponieważ sformatowałem listę list jako siatkę za pomocą G.

Rozwiązanie:

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

Wypróbuj online! / regex101

Główną sztuczką jest tutaj indeksowanie do uporządkowanej leksykograficznie listy permutacji liczb naturalnych do n ² (używając, œ?aby uniknąć budowania listy długości n ² ! ) I podzielenie wyniku na kawałki o długości n . Wyżej wymieniony indeks znajduje się poprzez utworzenie jego reprezentacji w systemie liczb silni, który jest formalny, ponieważ „nieskomplikowany” wąż jest tworzony przez permutację elementów w określony sposób (można to łatwo przekonwertować na liczbę za pomocą Æ¡).

Rozwiązanie, które przedstawiam, używa Ŀdo odniesienia poprzednich linków jako monad (zastępujących Ñi Ç), ale $zamiast tego można zastosować wiele z rzędu, aby „wstawić” te funkcje pomocnicze. Korzysta również rod tego czasu Ḷi Rjest zbanowany.

’: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 , długość wyrażenia regularnego 3 (bezpieczny)

Rozwiązaniem jest pełny program, który przyjmuje n jako argument wiersza poleceń. Nie używa żadnych flag wiersza poleceń.

Regex (dowolny smak)

\w+

Próbka wyjściowa

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

Moje rozwiązanie

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Wypróbuj online!

Strategia

Oto kod, który chcielibyśmy napisać:

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

To jest:

• Przechowywać numery od 1 do awy
• Zapętlaj wartości iod 0 doa-1
• Jeśli ijest nieparzysty, odwróć y, dodaj i*ado każdego elementu, połącz spację z każdym elementem i wydrukuj
• W przeciwnym razie zrób to samo, ale bez uprzedniego cofania

Trudności

Wiele poleceń i zmiennych w Pip używa liter, ale niektóre ważne nie:

• Zasięg i zasięg włącznie ( ,i \,)
• Większość operacji matematycznych ( +, -, *, %, ++)
• Zadanie ( :)
• Nie możemy mieć pętli ani funkcji z więcej niż jedną instrukcją (wymagałoby to {})
• Nie możemy używać nawiasów w celu wymuszenia pierwszeństwa

Jak obejść te ograniczenia:

• ENumerat można zastosować zamiast ,; potrzebujemy tylko ciągu znaków z żądaną liczbą znaków i musimy wyodrębnić pierwszy element każdej podlisty w strukturze podobnej do [[0 "H"] [1 "i"]].
• Nie musimy niczego zwiększać, jeśli możemy rozwiązać problem z Fpętlami.
• Możemy przypisać do yzmiennej za pomocą Yoperatora ank.
• Możemy wykonywać matematykę za pomocą łańcuchów: Xto mnożenie łańcucha, a PUsh (lub PB„push-back”) połączy łańcuch z innym ciągiem w miejscu. Aby wziąć długość łańcucha, możemy go ENzapisać i wyodrębnić odpowiednią liczbę z wynikowej listy.
• Możemy używać funkcji, o ile można je zapisać jako funkcje lambda z jednym wyrażeniem _.

Specyfika

Elementy składowe naszego programu:

Zasięg

_MUENsXa

To jest map-unpack(_, enumerate(repeat(space, a)))w pseudokodzie. Rozpakowywanie map przypomina Pythona itertools.starmap: biorąc pod uwagę listę list, wywołuje funkcję na elementach każdej podlisty. _zwraca swój pierwszy argument, więc _MUpobiera tylko pierwszy element każdej podlisty. Na przykład, jeśli a = 3:

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

... który jest taki sam jak ,a.

Zakres obejmujący

Nie jestem pewien, czy można to zrobić inclusive-range(1, a)w pojedynczym wyrażeniu, ale na szczęście potrzebujemy go tylko raz, abyśmy mogli zbudować go w yzmiennej w trzech krokach.

YENsXaPBs

W pseudokodzie yank(enumerate(repeat(space, a).push-back(space))):

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

Następnie POywyskakuje pierwszy element yi odrzuca go, pozostawiając [[1 " "] [2 " "] [3 " "]].

Wreszcie,

Y_MUy

Oznacza to yank(map-unpack(_, y)): wyodrębnij pierwszy element każdej podlisty i przeciągnij wynikową listę z powrotem do y. yjest teraz[1 2 3] .

Długość

PODQENaPBs

W Pseudokod, pop(dequeue(enumerate(a.push-back(space)))). Trudność polega na tym, że wyliczenie daje nam tylko liczby len(a)-1, ale chcemy len(a). Najpierw wciskamy spację a, wydłużając ją o jeden znak, a następnie bierzemy len-1nowy ciąg.

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

Matematyka

Teraz, gdy mamy sposób na określenie długości ciągów, możemy używać ciągów do mnożenia i dodawania liczb:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

Pierwszy robi, sXaXbaby utworzyć ciąg a*bspacji, a następnie przyjmuje jego długość; drugi robi sXaPBsXbwypychanie ciągu bspacji do ciągu aspacji, a następnie przyjmuje jego długość.

Ładne jest to, że wszyscy operatorzy używamy tutaj ( PU, PO, PB, DQ, EN, X) może być używany z_ do wyrażenia forma lambda. Możemy więc odwzorować przekształcenia matematyczne na obejmujący zakres, który zbudowaliśmy wcześniej.

Musimy również sprawdzić i%2wewnątrz pętli, ale to łatwo zrobić z bitowego I: iBA1.

Umieścić je razem

Pełny kod z dodanymi białymi znakami:

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, długość 8, pęknięty

^[a-~]*$

Przykładowe dane wyjściowe dla 4:

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

CJam, PCRE, długość 9, pęknięty

^[a-z~]*$

Przykładowe dane wyjściowe dla 4:

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

Teraz {|}są również zakazane.

Mathematica, długość wyrażenia regularnego 11, niekonkurujący , pęknięty

Smak PCRE:

^[^]@]{49}$

Poprawnym rozwiązaniem będzie funkcja, która przyjmuje liczbę całkowitą i zwraca dane wyjściowe jako zagnieżdżoną listę, taką jak:

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

Tinylisp , regex length 3 ( cracked )

Możesz przetestować kod Tinylisp w Wypróbuj online!

Regex (dowolny smak)

\S+

Czas iść na hardkor.

Wydajność

Rozwiązanie definiuje funkcję, która przyjmuje pojedynczy argument liczby całkowitej i zwraca taką listę (dla n = 4):

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

Mój oryginalny kod wykorzystuje ten sam podstawowy pomysł, który wymyślił Brian McCutchon, budując listy i sprawdzając je. Oto w jednej linii:

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

Raz użyłem pełnej metody konstruowania i ewaluacji, aby zdefiniować makro, d'które sprawia, że ​​definicje są podobne d, ale bierze swoje argumenty w listę: więc zamiast tego (d x 42)możesz to zrobić (d'(x 42)). Potem wystarczyło przepisać dowolne listy w definicjach, które mogą wymagać białych znaków: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, długość 162 (Cracked!)

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

Okej, wiem, to dość długie. Na szczęście nie zostanie złamany w ciągu tygodnia ...: „D.

Myślę, że nigdzie się nie pomyliłem, co pozwoliłoby na luki w odpowiedziach.

Format wyjściowy

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

Oryginalny kod: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)