Dies ist der Thread des Polizisten. Der Räuberfaden ist da .

Schreiben Sie einen Code, der eine Eingabe entgegennimmt nund eine n-mal-n "Schlangenmatrix" erstellt.

Eine Schlangenmatrix ist eine Matrix, die diesem Muster folgt:

3-mal-3:

1  2  3
6  5  4
7  8  9

und 4-mal-4:

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

Das genaue Ausgabeformat ist optional. Sie können zum Beispiel ausgeben [[1 2 3],[6 5 4],[7 8 9]], oder etwas ähnliches.

Sie müssen den Namen der Sprache und einen regulären Ausdruck angeben, der vollständig mit Ihrem Code übereinstimmt. Sie können wählen, wie detailliert Ihre Regex sein soll. Im Extremfall können Sie einen regulären Ausdruck schreiben, der zu jeder möglichen Zeichenfolge passt. In diesem Fall ist es sehr einfach, Ihren Code zu knacken. Sie müssen auch die Ausgabe für bereitstellen n=4, damit Räuber das genaue Format kennen, für das Sie sich entschieden haben.

Sie können eine der auf regex101.com verfügbaren Regex- Varianten oder die Ruby- Variante verwenden.

• PCRE (PHP)
• Javascript
• Python
• Golang
• Rubin

Sie müssen angeben, welchen Sie verwenden.

Anmerkungen:

• Sie müssen alle einigermaßen großen unterstützen n. Sie können davon ausgehen, dass der Datentyp oder der Speicher nicht überläuft. Wenn der Standarddatentyp 8-Bit-Ganzzahlen n<=11mit Vorzeichen ist , können Sie davon ausgehen , dass 8-Bit-Ganzzahlen ohne Vorzeichen sind n<=15.
• Die Räuber müssen mit dem Ausgabeformat der Übermittlung übereinstimmen, mit Ausnahme von führenden / nachfolgenden Leerzeichen und Zeilenumbrüchen, da dies möglicherweise durch die SE-Formatierung entfernt wurde.

Gewinnkriterium:

Der Gewinner ist die ungerissene Einsendung mit der kürzesten Regex, gemessen in der Anzahl der Zeichen.

Wenn Ihr Beitrag 7 Tage lang ungerissen geblieben ist, können Sie die beabsichtigte Lösung posten und Ihren Beitrag als sicher markieren.

05AB1E , geknackt von mbomb007

Hoffentlich lustig zu knacken und nicht zu offensichtlich.

Regex (PCRE):

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

Ausgabe n = 4:

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

Originelle Lösung

UXFXLNX*+NFR}ˆ

Python 2 , Länge 62, geknackt

Regex (PCRE)

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

Beispielausgabe

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

Gelee , Länge 6, geknackt

Regex (PCRE)

^.{9}$

Beispielausgabe

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

R, Länge 14 Durch Plannapus geknackt

Ich hoffe, ich habe diesen Regex richtig verstanden. Was ich sagen will ist 77 Zeichen ohne <space>, #, ;und [. Ich habe es hier getestet

Regex

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

Beispielausgabe n = 4

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

05AB1E , Cracked by Value Ink

Lass es
uns noch ein bisschen besser machen :) Hoffentlich ein schönes Puzzle.

Regex (PCRE)

^\w*..\w*$

Ausgabe n = 4

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

> <> , Länge 49, Gebrochen von Aaron

Regex (Javascript)

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

Beispielausgabe (n = 4)

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

Das Formatieren ist etwas seltsam, aber das Überprüfen der Länge der Nummer hätte es viel länger gemacht. Könnte ein bisschen über Bord gegangen sein, nicht sicher!

Bearbeiten: Auch ich habe vergessen zu erwähnen, ich benutze den Anfangsstapel (-v Flag) für die Eingabe, nicht die üblichen Fischeingaben. Es tut uns leid!

Ursprünglicher Code:

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

Aarons ist viel einfacher! Die Komplexität meines ursprünglichen Codes basiert auf der Idee, n[r]jedes n-te Zeichen zu verwenden, um dieses Segment (diese Zeile) zu spiegeln und dann alle Zeichen auf einmal am Ende zu drucken

Ohm , geknackt

Auch meine erste Cops and Robbers-Herausforderung, also sag mir, ob es Probleme mit diesem Muster gibt (zumal dies eine ziemlich unbekannte Sprache ist).

Regex (PCRE)

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

Ausgabe (n = 4)

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

PHP, 221 Bytes ( geknackt )

Ich hoffe es ist schwierig genug.

Regex (PCRE): 16 Bytes

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

Kein Leerzeichen, keine Kommentare, keine Verwendung von base64_decode. Habe Spaß.

Ausgabe

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

Ursprünglicher Code

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

( http://ideone.com/ works)

Regex PCRE Geschmackslänge 58 getestet bei Regex101

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

Nur die Methode ist regulär. Methode gibt ein 2d int [,] Array (int [4,4]) für eine Eingabe n = 4 zurück. Wenn gedruckt so aussieht:

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

Dies ist mein erster Einstieg in so etwas, lass es mich wissen, wenn ich etwas falsch gemacht habe. Ich versuche nicht, mit Regex-Länge zu gewinnen, aber ich bin gespannt, wie gut ich es geschafft habe, Rissbildung zu verhindern :)

Originalcode:

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, Regexlänge 10 ( geknackt )

Regex

Sollte in jedem Regex-Geschmack funktionieren, aber wir werden es Python-Geschmack nennen.

([A-Z]+.)+

HINWEIS: Meine Lösung verwendet unformatiertes QBasic. Nach der Formatierung stimmt der Code aufgrund von Leerzeichen nicht mit dem regulären Ausdruck überein. (Aber ich kann Ihnen sagen, dass dies die einzige Änderung ist, die einen Unterschied macht. Funktioniert ([A-Z]+ ?. ?)+immer noch mit der formatierten Version.)

Zu Testzwecken habe ich QB64 mit deaktivierter Code-Formatierung verwendet (unter Optionen> Code-Layout). Wenn Sie nichts herunterladen möchten, können Sie QBasic auch online unter archive.org ausführen (dort können Sie die Formatierung jedoch nicht deaktivieren).

Beispielausgabe

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

Python 3, 55 Bytes (geknackt)

PCRE / Python / Golang Geschmack.

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

(Denken Sie daran, dass eine vollständige Übereinstimmung erforderlich ist . Angenommen, ^und $beim Testen.)

Beispielausgabe:

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

Ursprüngliche Lösung:

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

Sollte 4 Bytes gekürzt haben: p

dc , Regex Länge 12   Gebrochen von Seshoumara!

^[^# !]{59}$

Dieser reguläre Ausdruck ist so einfach, dass ich den Geschmack von Regex nicht für wichtig halte - er sollte auf ganzer Linie funktionieren. (Beachten Sie das Leerzeichen nach dem # in der Regex.)

Ich habe alle vier Varianten bei regex101.com (PCRE / PHP, Javascript, Python und Golang) sowie die Ruby-Version bei rubular.com getestet. Das DC-Programm entspricht dem regulären Ausdruck in allen fünf regulären Ausdrücken.

Das DC-Programm nimmt seine Eingabe auf stdin und setzt seine Ausgabe auf stdout.

Beispielausgabe für Eingabe 4 (am Ende jeder Zeile befindet sich ein Leerzeichen):

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

Originalcode (hinzugefügt, nachdem geknackt wurde)

Dies wurde von @seshoumara geknackt . Hier ist mein vorgesehener Code:

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

Erläuterung:

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

Die Summe oben auf dem Stapel ist jetzt die nächste Zahl, die gedruckt werden soll:

• Es ist leicht zu erkennen, dass dies richtig ist, wenn die Zeilennummer gerade ist, da die Summe dann nur i ist.

• Beachten Sie bei ungeradzahligen Zeilen, dass i = d * (i / d) + (i% d) = d * (Zeilennummer) + Spaltennummer. Daraus folgt, dass die Summe i + d-2 * (Spaltennummer) -1 d * (Zeilennummer) + Spaltennummer + d - 2 * (Spaltennummer) - 1 = d * (Zeilennummer + 1) - Spaltennummer ist - 1, die Zahl, die wir in die angegebene Zeile und Spalte einfügen möchten, um sicherzustellen, dass wir in den ungeradzahligen Zeilen rückwärts zählen.

Zurück zur Erklärung:

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, Regex Länge 38, geknackt ( @kennytm )

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

Eingang:

n=4; <command>

Ausgabe:

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

PHP

Ich hoffe, dass es Spaß macht! : D

Ausgabe (n = 4)

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

Level 1: PCRE (Länge = 17) ( geknackt von Jörg Hülsermann )

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

• Keine einfachen oder doppelten Anführungszeichen also ... keine Zeichenketten!
• Keine Ziffern!
• Nein {so ... keine anonymen Funktionen!
• Nein vso ... nein eval()!
• Nein ;so ... es muss eine einzelne Aussage sein!
• Nein, <also ... keine Heredocoder mehrere PHP-Blöcke!
• Der Grosse! Kein $ so ... viel Glück Definition von Variablen! >: D

@ JörgHülsermann hatte einen interessanten Ansatz, aber es ist nicht das, was ich im Sinn hatte :). Daher stelle ich einen neuen Schwierigkeitsgrad vor (ich verspreche, dass ich den Code habe, der dazu passt, und ich spiele nicht nur mit Ihnen):

Level 2: PCRE (Länge = 23) ( geknackt von Jörg Hülsermann )

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

• Alle Einschränkungen von Level 1
• Neu auf dieser Ebene: keines davon _~|&A-Z! :)

Habe Spaß!

DIE ORIGINAL-LÖSUNG

Das Verbieten des $Zugriffs auf die Variablen bedeutet also nicht, dass sie überhaupt nicht verwendet werden können! Sie können weiterhin extract()/compact()zum Importieren / Exportieren von Variablen in den aktuellen Bereich verwenden. :)

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

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

Es gibt jedoch ein Problem: compact('x')['x']++würde nicht funktionieren, da Variablen in PHP als Wert übergeben werden ... mit einer Ausnahme! Objekte.

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

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

Der Rest ist einfach.

• Zahlen 0und 1werden leicht erzeugt durch Umwandlung falseund truezu , intindem sie mit dem Voranstellen +Zeichen
• Verwenden andund orseit &und |sind verboten
• Um die verbotenen Anführungszeichen zu umgehen, verwenden Sie einfach undefinierte Konstanten, die als Zeichenfolgen behandelt werden
• Verwenden Sie einfach, um die durch undefinierte Konstanten erzeugten Hinweise zu unterdrücken @
• Der verbotene Buchstabe vkann mithilfe von generiert werden chr(ord('u') + 1), was sich in der @chr(ord(u) + true)Verwendung der oben genannten Problemumgehungen niederschlägt
• Der Unterstrich ähnelt dem obigen: chr(ord('a') - 2)was übersetzt zuchr(ord(a) - true - true)
• Das Aufrufen von Funktionen, die verbotene Zeichen enthalten, kann mithilfe des PHP- callableTyps erfolgen, der eine Zeichenfolge sein kann, die den Namen der Funktion enthält. Sie können also undefinierte Konstanten und einzelne Zeichenfolgen verketten, die von generiert wurden ord(), um den Namen der Funktion zu erstellen, und folgendermaßen aufrufen: array_reverse()wird (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayist ein Sprachkonstrukt, deshalb wird es in die undefinierten Konstanten aund aufgeteilt rray).
• Nutzen Sie die Tatsache, dass die geschweiften Klammern bei Bedingungs- und Schleifenkonstrukten optional sind, wenn das Konstrukt nur für die unmittelbar folgende Anweisung gilt. Das bedeutet, dass Sie folgende Aufgaben ausführen können: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

Die Logik in für Menschen lesbarem Code wäre:

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

Und die unfreundliche Version, die zum Regex passt:

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

Rubin [geknackt]

Erste Cops and Robbers Herausforderung. Hoffe, ich habe das nicht zu einfach gemacht.

EDIT: ersetzt \g<1>durch, (?1)da sie in PCRE offensichtlich gleichwertig sind.

Regex (PCRE)

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

Ausgabe (n = 4)

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

(Gibt ein Array von Arrays zurück. Es ist übrigens ein Lambda, aber vielleicht verrät das zu viel?)

JavaScript (geknackt)

Zum ersten Mal bei einer Cops and Robbers-Herausforderung, hoffentlich richtig.

Regex (JavaScript)

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

Ausgabe

Ein Array gleich:

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

Swift, Regex 25 (Gebrochen)

Richtig, mal sehen, ob ich den Dreh raus habe. Dies ist mein erster Bullen- und Räuberposten, also weiß ich, ob ich es vermasselt habe!

Regex

Ich habe Javascript auf regex101.com verwendet

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

Beispielausgabe

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

Ursprünglicher Code

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

C - Regex mit 42 Zeichen Länge - geknackt

Javascript Regex wie in Regex101 verwendet .

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

Ich schätze, das wird trivial sein ...

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

Die Ausgabe wird \nnach jeder Zeile durch Tabulatoren getrennt.

Meine Lösung, ganze Zahlen hier zum 0 - 2 über erhalten wurden t-t, t/tund 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');}

Gelee , Länge 14 geknackt

von Dennis geknackt

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

Python-Regex.

Wurde mwieder hinzugefügt , nachdem ich es verrutschen ließ.

/(schnell reduzieren);
von P(Produkt) bis `(Monade von Dyade schnell);
m(Modulo-Indizierung);
v(eval dyad);
von Ḋ(dequeue) bis ṫ(tail); und
€(für jeden schnellen)

Für eine Eingabe von 4Minenausgaben:

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

... weil ich eine Liste von Listen als Gitter mit formatiert habe G.

Powershell, 23 Bytes

Von Matt geknackt

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

Ursprüngliche Lösung:

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

Nimmt Eingaben als Argument und gibt sie an stdout aus

Hoffentlich ist diese Regex in Ordnung, ich erwarte nicht, dass es zu schwierig ist, sie zu knacken, da ich nicht viel davon verschleiert habe, und die Regex gibt ein paar gute Ansatzpunkte, um die Lücken zu füllen, es gibt eine Sache im ersten Segment Das ist im Codegolf jedoch sehr ungewöhnlich, was vielleicht jemanden überraschen kann. Ich denke, dass ein nicht gieriges Match erforderlich ist, um dies ein bisschen härter zu machen.

Die ersten Polizisten fordern sowieso.

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 , Länge 19 (Gebrochen von @KritixiLithos)

PCRE:

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

Beispielausgabe (n = 4):

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

Originalcode:

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

Probieren Sie es online!

PHP 7 (sicher)

Ursprünglicher Code

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

Zweiter Versuch

Regex (PCRE): 29 Bytes

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

Kein Leerzeichen, keine Kommentare, keine Verwendung von base64_decode.

Viele Funktionen sind nicht erlaubt! unterstreichen

Ausgabe 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

Ausgabe n = 4

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

Ausgabe n = 3

1 2 3
6 5 4
7 8 9

MATL , Länge 12 (sicher)

Regex

Verwendet Python-Geschmack:

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

Beispielausgabe

Für n=4:

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

Lösung

txU:GeG:oEq*S5M*TTx!

Betrachten Sie die Eingabe, um zu sehen, wie dies funktioniert 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]

Gelee , Länge 17 (sicher)

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

Python-Regex.

Wenn Sie den Knoten enger machen, werden einige weitere nützliche Dinge verboten. Für Ihre Hilfe sind hier die verbotenen Bytes:

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

knapp ein Drittel von ihnen!

Für eine Eingabe von 4Minenausgaben:

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

... weil ich eine Liste von Listen als Gitter mit formatiert habe G.

Eine Lösung:

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

Probieren Sie es online! / regex101

Der wichtigste Trick ist hier , um die Index in eine lexikographisch sortiert Liste der Permutationen der natürlichen Zahlen bis zu n ² (mit den œ?Aufbau der Liste der Länge zu vermeiden n ² ! ), Und das Ergebnis in Stücke von Länge zu spalten n . Der oben genannte Index wird durch Bilden seiner Darstellung in dem faktoriellen Zahlensystem gefunden, das formelhaft ist, da die "ungeschnittene" Schlange durch Permutieren von Elementen auf vorgeschriebene Weise erzeugt wird (dies kann leicht in eine Zahl mit umgewandelt werden Æ¡).

Die Lösung, die ich vorstelle, verwendet, Ŀum frühere Links als Monaden zu referenzieren (Ersetzen von Ñund Ç), aber mehrere $in einer Reihe könnten stattdessen verwendet werden, um diese Hilfsfunktionen "inline" zu schalten. Es nutzt auch rseit Ḷund Rsind verboten.

’: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 Länge 3 (sicher)

Die Lösung ist ein vollständiges Programm, das n als Befehlszeilenargument verwendet. Es werden keine Befehlszeilenflags verwendet.

Regex (jeder Geschmack)

\w+

Beispielausgabe

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

Meine Lösung

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Probieren Sie es online!

Strategie

Hier ist der Code , den wir würden gerne schreiben:

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

Das ist:

• Speichern Sie die Nummern 1 bis a iny
• Schleife über Werte von i von 0 bisa-1
• Wenn iungerade ist, kehre y um, addierei*a zu jedem Element hinzu, verknüpfen Sie jedes Element mit einem Leerzeichen und drucken Sie
• Ansonsten machen Sie dasselbe, aber ohne vorher umzukehren

Schwierigkeiten

Viele Befehle und Variablen in Pip verwenden Buchstaben, einige wichtige jedoch nicht:

• Reichweite und inklusive Reichweite ( ,und\, )
• Die meisten mathematischen Operationen ( +, -, *, %,++ )
• Zuordnung (: )
• Wir können keine Schleifen oder Funktionskörper mit mehr als einer Anweisung haben (das würde nötig sein) {} )
• Wir können keine Klammern verwenden, um die Priorität zu erzwingen

Wie wir diese Einschränkungen umgehen:

• ENumerate kann anstelle von verwendet werden ,; Wir brauchen nur eine Zeichenkette mit der Anzahl der Zeichen, die wir wollen, und wir müssen das erste Element jeder Unterliste in einer Struktur wie der extrahieren [[0 "H"] [1 "i"]].
• Wir müssen nichts erhöhen, wenn wir das Problem mit Foder Schleifen lösen können .
• Wir können die yVariable mit dem Yank-Operator zuweisen .
• Wir können mit Zeichenfolgen rechnen: Xist Zeichenfolgenmultiplikation, und PUsh (oder PB"push-back") verkettet eine Zeichenfolge mit einer anderen vorhandenen Zeichenfolge. Um die Länge eines Strings zu ermitteln, können wir diesen ENumerieren und die richtige Zahl aus der resultierenden Liste extrahieren.
• Wir können Funktionen verwenden, solange sie als Lambda-Funktionen mit einem Ausdruck geschrieben werden können _.

Besonderheiten

Die Bausteine ​​unseres Programms:

Reichweite

_MUENsXa

Das ist map-unpack(_, enumerate(repeat(space, a)))im Pseudocode. Map-Unpack ist wie Pythons itertools.starmap: Wenn eine Liste von Listen angegeben ist, ruft es eine Funktion für die Elemente jeder Unterliste auf. Gibt das _erste Argument zurück und _MUruft nur das erste Element jeder Unterliste ab. Zum Beispiel, wenn a = 3:

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

... das ist das gleiche wie ,a .

Inklusivangebot

Ich bin mir nicht sicher, ob es eine Möglichkeit gibt, inclusive-range(1, a)einen einzelnen Ausdruck zu erstellen, aber zum Glück brauchen wir ihn nur einmal, damit wir ihn yin drei Schritten in der Variablen erstellen können.

YENsXaPBs

Im Pseudocode yank(enumerate(repeat(space, a).push-back(space))):

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

Als nächstes wird POydas erste Objekt aus dem yOrdner entfernt und verworfen[[1 " "] [2 " "] [3 " "]] .

Endlich,

Y_MUy

Das heißt yank(map-unpack(_, y)): extrahiere das erste Element jeder Unterliste und ziehe die resultierende Liste zurück in y. yist jetzt[1 2 3] .

Länge

PODQENaPBs

Im Pseudocode pop(dequeue(enumerate(a.push-back(space)))). Die Schwierigkeit dabei ist, dass die Aufzählung nur Zahlen ergibt len(a)-1, die wir wollen len(a). Also schieben wir zuerst ein Leerzeichen nach a, verlängern es um ein Zeichen und nehmen dann len-1die neue Zeichenfolge.

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

Mathematik

Nachdem wir nun die Möglichkeit haben, die Länge von Zeichenfolgen zu bestimmen, können wir Zeichenfolgen zum Multiplizieren und Addieren von Zahlen verwenden:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

Der erste Befehl sXaXberstellt eine Folge von a*bLeerzeichen und nimmt dann die Länge davon an. Die zweite Methode besteht sXaPBsXbdarin, eine Zeichenfolge von bLeerzeichen in eine Zeichenfolge von aLeerzeichen zu verschieben und nimmt dann die Länge davon an.

Das schöne daran ist , dass alle die Betreiber verwenden wir hier ( PU, PO, PB, DQ, EN, X) mit verwendet werden_ Ausdrücke Form Lambda. So können wir mathematische Transformationen auf den zuvor erstellten Inklusionsbereich abbilden.

Wir müssen auch prüfen , i%2innerhalb der Schleife, aber dies wird leicht erreicht mit bitweise AND: iBA1.

Setze sie zusammen

Der vollständige Code mit zusätzlichen Leerzeichen:

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, Länge 8, geknackt

^[a-~]*$

Beispielausgabe für 4:

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

CJam, PCRE, Länge 9, geknackt

^[a-z~]*$

Beispielausgabe für 4:

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

Jetzt {|}sind auch verboten.

Mathematica, Regex-Länge 11, nicht konkurrierend , geknackt

PCRE-Geschmack:

^[^]@]{49}$

Die richtige Lösung ist eine Funktion, die eine Ganzzahl annimmt und die Ausgabe als verschachtelte Liste zurückgibt:

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

Tinylisp , Regex Länge 3 ( rissig )

Sie können den tinylisp-Code unter Online testen !

Regex (jeder Geschmack)

\S+

Zeit für Hardcore.

Ausgabe

Die Lösung definiert eine Funktion , die ein einzelnes ganzzahliges Argument verwendet und eine Liste wie die folgende zurückgibt (für n = 4):

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

Mein ursprünglicher Code basiert auf der gleichen Grundidee wie Brian McCutchon, der Listen erstellt und auswertet. Hier steht es in einer Zeile:

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

Ich habe einmal die vollständige construct-and-eval-Methode verwendet, um ein Makro zu definieren d', das Definitionen erstellt d, deren Argumente jedoch in eine Liste eingeschlossen (d x 42)sind (d'(x 42)). Dann ging es nur noch darum, Listen in den Definitionen neu zu schreiben, die möglicherweise Leerzeichen benötigen: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, Länge 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\)$

Okay, ich weiß, es ist ziemlich lang. Zum Glück wird es in weniger als einer Woche nicht geknackt ...: 'D.

Ich glaube, ich habe nirgendwo einen Fehler gemacht, der lückenhafte Antworten zuließ.

Ausgabeformat

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

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