Räuber: Knacken Sie den Regex - Machen Sie eine Schlange

20

Dies ist der Faden des Räubers. Der Thread des Polizisten ist hier .


Eine Schlangenmatrix ist eine quadratische 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

Ihre Aufgabe ist es, einen Code zu schreiben, der eine Eingabe entgegennimmt nund eine solche Matrix in derselben Sprache wie ein Cop-Beitrag erstellt, und mit einem Code, der der Regex des Cop entspricht. Das Ausgabeformat Ihres Codes muss mit dem Ausgabeformat des Cop-Codes übereinstimmen.

Bitte hinterlasse einen Kommentar unter dem Beitrag des Polizisten, um anzuzeigen, dass du ihn geknackt hast.

Gewinnkriterium:

Der Gewinner ist der Benutzer, der die meisten Einsendungen geknackt hat. Im Falle eines Gleichstands gibt es mehrere Gewinner.

Stewie Griffin
quelle

Antworten:

10

Jelly , 9 Bytes, knackt die Antwort von @Dennis

²sµUFḤ$¦G

Probieren Sie es online!

Sollte jetzt korrekt sein; Ich musste lieber überdenken, was ich tat.

Erläuterung

Der schwierigste Teil dieses Problems besteht darin, eine Liste der geraden Indizes innerhalb von ¦(die eine Operation auf bestimmte Indizes anwenden) abzurufen. Im Gegensatz zu den meisten Operationen, bei denen die Eingabe für das gesamte Programm als Standard für den zweiten Operanden verwendet wird, ¦wird der zuletzt angezeigte Wert als Standard verwendet (da er konzeptionell zwei linke Operanden anstelle eines linken und eines rechten Operanden enthält, wie die meisten anderen zwei Werte aufnehmen).

Wir können jedoch beobachten, dass wir eine Liste von Zahlen, einschließlich aller ganzen Zahlen von 1 bis zur Hälfte der Eingabe, bereits im aktuellen Wert zu diesem Zeitpunkt haben. Daher erhalten wir durch Abflachen und Verdoppeln eine Liste mit geraden Zahlen, einschließlich aller geraden Indizes (auch einige andere gerade Zahlen, die uns jedoch egal sind). Es ist sogar möglich, nur einen auszugeben µ, um eine mehrdeutige Syntaxanalyse zu vermeiden, und dennoch innerhalb von 9 Zeichen einzugeben.

²sµUFḤ$¦G
 s         Split
²          {the list of numbers from 1 to} the square of {the input}
  µ        into a number of pieces equal to {the input};
   U       then reverse
       ¦   the elements at indexes
    F      obtained by flattening the split list
      $    and
     Ḥ     doubling each element in the flattened list;
        G  finally, format it into a grid.         
Gemeinschaft
quelle
Uh, die Art und Weise ¦funktioniert tötet mich jedes Mal, habe ich versucht , das gestern , aber mit nicht Uund beschlossen , die nicht trainieren.
Jonathan Allan
Schön, ich hätte es beinahe geschafft, bin aber auch bei der Auswahl jedes anderen Elements hängen geblieben. Fwar eine tolle Idee,
ETHproductions
Mein ursprünglicher Code ist damit ziemlich identisch. Ich habe nur Jstatt F.
Dennis
@Dennis Oh, J... ich hatte es versucht LR, konnte es aber nicht unter 11 Bytes bringen
ETHproductions
9

05AB1E, Emigna

Ich habe 05AB1E zum ersten Mal verwendet. Habe es mit ein bisschen Hilfe geschafft. Das hat Spaß gemacht. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Probieren Sie es online aus

Erläuterung:

U                       Assign input to X
 XF                     For N in range(0,X):
   XL                   Push list [1 .. X]
     NX*+               Add N*X to each element of the list
         N2BSR1k_       Super clever way to get N%2:
                            not bool(reversed(str(bin(N))).index('1')) (N%2 is odd)
                 iR}    if N%2 is odd, then reverse the list
                    ˆ   Add row to global array
                        Implicit print

Ich habe dieses ähnliche Programm tatsächlich selbst gefunden, aber das Ausgabeformat ist anders:

UXFXLNX*+N2BSR1k_iR}=

Probieren Sie es online aus

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

Sehen Sie sich den Bearbeitungsverlauf für meine letzten beiden Versuche an.

mbomb007
quelle
Gute Arbeit! Ganz ähnlich wie die ursprüngliche Lösung.
Emigna
5
not bool(reversed(str(bin(N))).index('1'))... Ich denke, das ist die absurdeste Art und Weise, wie ich jemanden bei einer N%2Operation gesehen habe.
Stewie Griffin
3
@StewieGriffin Wenn das Leben dir Zitronen gibt, aber kein Wasser oder Zucker, musst du sie nur roh essen. : D
mbomb007
6

Python 2, Dennis

Dies ist ein Spaß-Token-Golf-Problem.

while ord>eval:1;int,eval=int<1and(int,eval+1)or(-input(),1);i=int;ord=i*i;print'%*s'%(-i,(eval+~i+~-eval%-i*~1,eval)[eval/i&1])+'\nt'[:-1<eval%int],

Regex-Überprüfung

xsot
quelle
5

Ohm, Nick Clifford

Mein erster Versuch Ohm.
Wirklich schöne Sprache, die ich gerne wieder benutze :)

²@┼σ▓_^è?R

Erläuterung

²             # square input
 @            # range [1 ... input^2]
  ┼σ          # split in input sized chunks
    ▓         # perform the following block on each element of the array
     _        # current element
      ^è?     # if index is odd
         R    # reverse

Mein erster Versuch, bei dem kein Array und kein Int hinzugefügt wurden, ist nicht möglich:

@┼MDR┼+;W

Mein zweiter Versuch, der nicht der Regex entsprach:

²@┼σ▓_^MR
Emigna
quelle
Du hast es genau so gemacht wie ich! Gut gemacht!
Nick Clifford
5

05AB1E, Emigna (2. Einreichung)

Das erste Mal mit 05AB1E arbeiten.

VYLUYFYXDˆ+RU

Probieren Sie es online! | Regex-Überprüfung

Erläuterung

VYLUYFYXDˆ+RU  # Implicit input
V              # Save input to Y
 YL            # Push [1 .. Y]
   U           # Save list to X
    YF         # Repeat Y times:
      YX       # Push Y, then X
        Dˆ     # Add X into the global array (could've used X here instead)
          +    # Push X + Y
           R   # Reverse top of stack
            U  # Save updated list to X
               # Implicit loop end
               # Implicit global array print if stack is empty
Wert Tinte
quelle
Gute Arbeit! Sie haben die beabsichtigte Lösung :)
Emigna
@Emigna danke! Ich hätte es nicht bekommen, wenn nicht die anderen Lösungen hier (Ihre eingeschlossen) mir klar gemacht hätten, dass das globale Array gedruckt wird, wenn der Stapel leer ist! Wenn das nicht gewesen wäre, hätte ich es nie herausgefunden. Ich habe immer wieder versucht, Tricks zu machen, bei denen )ich dachte, es wäre der einzige Weg, das richtige Ergebnis auf dem Stapel zu erzielen.
Value Ink
Ja, das ist ziemlich unmöglich ) wenn Sie nur 2 nicht-alphanumerische Zeichen verwenden können. Der knifflige Teil hier sollte darin bestehen, das Programm so zu strukturieren, dass nur 2 Platzhalter verwendet werden und diese sequentiell sind. Wäre ohne die anderen Lösungen wahrscheinlich etwas schwieriger gewesen, aber es hätte einige Rätsel geben müssen :)
Emigna
@Emigna Was ich wissen möchte ist, ob ^\w*..$es möglich ist.
mbomb007
@ mbomb007: Das glaube ich nicht. Mit dieser Taktik müssten Sie das Ergebnis der Addition für die nächste Iteration speichern, und Sie können den Stapel nicht für diese Bedeutung verwendenUV suchen muss . Ich kann mir keine andere Möglichkeit vorstellen, es mit nur 2 Wildcards am Ende zu tun. Dies kann jedoch mit 3 Platzhaltern erfolgen.
Emigna
5

CJam , Lynn

esmpmpmeimtmemqmememqicelic
esmpmpmeimememqmlmtmemoc
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimeiscic
esmpmpmeimemeimfsic
esmpmpmeisciscimqmtmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeimemomqmqmemeic
esmpmpmeisciscimfsimqic
esmpmpmeimeiscic
esmpmpmeisciscimfsimqic
esmpmpmeimemomqmemqmemtmemoc
esmpmpmeiscic
esmpmpmeimemomeimqmeic
esmpmpmeimemeimqmlmtmeic
esmpmpmeimtmtmqmemtmtmeic
esmpmpmeimemomqmqmtmeic
esmpmpmeimemqmqmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeiscimqmtmtmtmqmemeic
esmpmpmeimeimemtmqmemeic
esmpmpmeimeiscimlmlmtmlmtic
esmpmpmeimemeimqmlmtmeic
~~

Alle Zeilenvorschübe dienen kosmetischen Zwecken und können ohne Beeinträchtigung des Programms entfernt werden.

Probieren Sie es online!

Erläuterung

Nachdem Lynn {|}von der Liste der erlaubten Charaktere gestrichen war, musste ich etwas Neues ausprobieren. Es stellt sich heraus, dass wir immer noch beliebige Zeichenfolgen konstruieren und als Code auswerten können.

Zunächst müssen wir den Stack aufwerten. Die einzige verfügbare integrierten Ins , die etwas drücken , ohne etwas anderes zuerst popping (und ohne die Eingabe zu lesen) sind es, eaund et. Ich bin mir sicher, dass Sie von all diesen Möglichkeiten ausgehen können, aber ich habe versucht, esden aktuellen Zeitstempel zu ändern. Da ich keine Vermutungen über den tatsächlichen Wert anstellen wollte, teste ich seine Ursprünglichkeit mitmp (was 0und ergibt 1) und teste die Primalität dieses Wertes erneut, um sicherzustellen, dass ich einen 0auf dem Stapel habe. A 1ist nützlicher, also berechnen wir exp(0)mit meund wandeln es in eine Ganzzahl mit um i. Alle Zahlen beginnen also mit:

esmpmpmei

Jetzt haben wir eine ganze Reihe von unären Mathematikoperatoren, mit denen wir arbeiten können:

i    int(x) (floor for positive numbers, ceiling for negative)
me   exp(x)
ml   ln(x)
mq   sqrt(x)
mo   round(x)
mt   tan(x)

Wir können auch einige integrierte Funktionen kombinieren, um Folgendes zu erreichen x:

sci     Extract first digit of x and add 48 (convert to string, convert
        to character, convert to integer).
ceui    Convert to character, convert to upper case, convert to integer.
celi    Convert to character, convert to lower case, convert to integer.
mfsi    Get a sorted list of prime factors of x and concatenate them into 
        a new number.
mfseei  Get a sorted list of prime factors, interleave it with 1,2,3,..., and
        concatenate the result into a new number.

Mit diesen können wir eine beliebige Anzahl in 0 <= x < 128(und viele andere) in weniger als 10 Schritten von erhalten 1. Ich bin sicher, dass eine viel kleinere Teilmenge dieser Befehle auch ausreichen würde. Ich habe ein kleines Mathematica-Programm geschrieben, um all diese Ausschnitte zu bestimmen (es ist nicht sehr lesbar, sorry):

codes = SortBy[
  Select[Nest[Select[DeleteDuplicatesBy[SortBy[Join @@ (Through[{
               List,
               If[1 <= # < 50, {Exp@#, #2 <> "me"}, Nothing] &,
               If[# >= 1, {Log@#, #2 <> "ml"}, Nothing] &,
               If[# > 1, {Sqrt@#, #2 <> "mq"}, Nothing] &,
               {If[# > 0, Floor@#, Ceiling@#], #2 <> "i"} &,
               {Floor[# + 1/2], #2 <> "mo"} &,
               {Tan@#, #2 <> "mt"} &,               
               If[NumberQ@# && # >= 0, {First@
                   ToCharacterCode@ToString@#, #2 <> "sci"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToUpperCase@FromCharacterCode@#, #2 <> "ceui"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToLowerCase@FromCharacterCode@#, #2 <> "celi"}, 
                 Nothing] &,
               If[IntegerQ@# && # > 0, ## & @@ {
                   {FromDigits[
                    "" <> (ToString /@ (f = 
                    Join @@ Table @@@ FactorInteger@#))], #2 <> 
                    "mfsi"},
                   {FromDigits[
                    "" <> (ToString /@ 
                    MapIndexed[## & @@ {#2[[1]] - 1, #} &, f])], #2 <>
                     "mfeesi"}
                   }, Nothing] &
               }@##] &) @@@ #, StringLength@*Last], 
       First], #[[1]] < 1000000 &] &, {{1, "esmpmpmei"}}, 9], 
   IntegerQ@# && 0 <= # < 128 &@*First], First]

Damit können wir einfach eine beliebige Liste von Zeichencodes verschieben und diese anschließend in ein Zeichen mit umwandeln c. Sobald wir den gesamten Code gepusht haben, den wir ausführen möchten, drücken wir 95( ]). Wir evaluieren diesen mit ~, um alle anderen in eine Zeichenfolge zu wickeln, und dann evaluieren wir diese Zeichenfolge mit ~.

Der eigentliche Code, der am Ende des Programms ausgeführt wird, lautet erneut:

ri__2#,:)/2/[1W]f.%:~<p

Eine Erklärung finden Sie in meiner vorherigen Lösung .

Martin Ender
quelle
4

Python 3, TuukkaX

Entschuldigung, der von Ihnen verwendete Regex war zu einfach zu trivialisieren. Nein 0, #oder ? Kein Problem!

Möglicherweise habe ich die Beispielausgabe falsch interpretiert, aber es ist immer noch ziemlich einfach, sie zu optimieren, da noch 45 freie Zeichen übrig sind

n=int(input())
print(str(n)+":")
x=1-1
exec("print([*range(1+x*n,1+n*-~x)][::(1,-1)[x%2]]);x+=1;"*n)
"no-op:a_string_that_doesnt_actually_matter"
Wert Tinte
quelle
Nett! : D FYI: Ich werde ein neues in Python erstellen, wenn Sie daran interessiert sind, es zu lösen.
Yytsi
4

R, MickyT

lets_make_a_snake<-function(n)`for`(i,1:n,cat(i*n+1-`if`(i%%2,n:1,1:n),"\n"))

Testfälle:

> lets_make_a_snake(4)
1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13 
> lets_make_a_snake(7)
1 2 3 4 5 6 7 
14 13 12 11 10 9 8 
15 16 17 18 19 20 21 
28 27 26 25 24 23 22 
29 30 31 32 33 34 35 
42 41 40 39 38 37 36 
43 44 45 46 47 48 49 

Und Regex-Bestätigung: https://regex101.com/r/OB8ZIM/1

Ich hatte auch:

invisible(sapply(1:(n=scan()),function(i)cat(i*n+1-`if`(i%%2,n:1,1:n),"\n")))

Dies gibt die gleiche Ausgabe und passt zur gleichen Regex .

Plannapus
quelle
6
lets_make_a_snake... Ich wäre überrascht, wenn das die beabsichtigte Lösung wäre: P
Stewie Griffin
@plannapus Großartige Arbeit. Das erste ist im Grunde das, was ich mit ` for` und ` if` vorhatte , aber viel besser golfen als meins.
MickyT
4

Röda , Fergusq

{|i|;a=1;while[a<=i]do;b=a*i-i+1;c=[];while[b<=a*i]do;c+=b;b++;done;{d=[];x=0;while[x<i]do;d+=c[i-x-1];x++;done[d]}if[a%2<1]else{[c]};a++;done;r="||||||"}

Dies ist eine anonyme Funktion , die diese PCRE regex übereinstimmt: ^{(\|[^\/#\s]*){8}$.

Probieren Sie es online!

Kritixi Lithos
quelle
4

Bash, @Marcos M

sort -n <(seq 1 $((n * n)) | xargs -n$n | sed -n 'p;n'; seq $((n * n)) 1 | xargs -n$n | sort -n | sed -n 'n;p')

Schön gemacht:

sort -n <(               # feed the stdout of this subshell into stdin for `sort -n`
    seq 1 $((n * n)) |   #   generate 1 2 3 ... n²
        xargs -n$n |     #     add line break every n numbers
        sed -n 'p;n';    #     print only odd lines
    seq $((n * n)) 1 |   #   generate n² ... 3 2 1
        xargs -n$n |     #     add line break every n numbers
        sort -n |        #     reverse all lines (keeping each row decreasing)
        sed -n 'n;p'     #     print only even lines
)

Der erste Teil des Unterbefehls wird erzeugt 1 2 3 4, 9 10 11 12und der zweite Teil wird erzeugen 8 7 6 5,16 15 14 13 . Das äußere sort -nwird sie richtig mischen, um das Schlangenmuster zu bilden.

Ich habe den Trick in /superuser//a/101760 verwendet , um die ungeraden und geraden Zeilen zu drucken. Vielen Dank, Marcos, wirklich ein Spaß.

kennytm
quelle
Sehr schöne Lösung
Mitchell Spector
3

Javascript, Tom

f=(a,i=1,j=0)=>Array(a).fill(0).map(b=>Array(a).fill(0).map(a=>i++)).map(a=>j++%2?a.reverse():a).map(a=>a)

console.log(f(4))

ovs
quelle
3

Python 3, @TuukkaX

n=int(input());j=0;exec("print([(j-+i%n-n++2*n-0,j+i%n+1)[1&int(i/n)//1^(0x1)//1]*(2*(i%n)*0+2222222//2222222)for i in range(j,j+n)]);j+=n;"*n)

Wenn Sie den regulären Ausdruck des Polizisten leicht analysieren, wird eine feste Vorlage angezeigt:

________________________"___________i%n____2*n-____i%n__________i/n)//1_____)//1___2*(i%n)____^^^^^^^^^^^^^^^^for i in range(j,____])______"*n)

wo _ist ein Zeichen außer [ '"#]und^ ist eines von[int()2/] .

Das "*n)Ende zeigt deutlich ein eval("..."*n)oder exec("..."*n), also müssen wir nur sicherstellen, dass "..."die j-te Zeile gedruckt wird.

Das for i in range(j,ist zu kurz vor dem Ende der Zeichenfolge, was auf das Verstehen der Liste hinweist, ohne dass es eines gibt if. Also müssen wir die i-te Spalte diejenigen konstruieren i%n, 2*nSachen.

n = int(input())
j=0
exec("""print([
    (
        j - +i%n - n ++ 2*n - 0,    # equivalent to (n + j - i%n) for the decreasing rows
        j + i%n + 1                 # equivalent to (j + i%n + 1 == i + 1) for the increasing rows
    )[1 & int(i/n)//1 ^ (0x1)//1]   # int(i/n)   ->    get row number 0, 1, 2, 3, ...; 
                                    # 1 & int(i/n)//1    ->    0 for increasing rows, 1 for decreasing rows, 
                                    # 1 & int(i/n)//1 ^ (0x1)//1    ->   flip 0 and 1
    * (2*(i%n)*0+2222222//2222222)  # multiply by the constant 1.
    for i in range(j,j+n)
]); j+=n; "*n)
kennytm
quelle
Nett! Na ja, eine Woche fast überstanden: D Ich werde meinen Originalcode posten.
Yytsi
3

dc , Mitchell Spector

Dies war mein erster Einstieg in eine Cops and Robbers Challenge und ich hatte viel Spaß. Der Regex, der angepasst werden musste, war einfach, ^[^# !]{59}$was meinen Job im Grunde zu einem Golfjob machte, ohne diese 3 Zeichen zu verwenden. Anfangs hatte ich Schwierigkeiten, unter 60 Bytes zu kommen, aber am Ende habe ich es geknackt.

?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdlNd*>L]dsLxqqq

Probieren Sie es online!

Erläuterung:

Mein Code verwendet eine Schleife mit N 2 -Iterationen, wobei ein auf Null basierender Zähler (1D) beibehalten wird, und berechnet die zu druckende Zahl basierend auf den entsprechenden Koordinaten der Matrixzeilen und -spalten (r, c).

Beispiel für was ich meine, wenn N = 4:

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

Es sieht kompliziert aus, aber der Zwischenschritt ist hilfreich. Außerdem habe ich von Anfang an versucht, 2 Loops zu verwenden, aber ich habe die Zeichenbegrenzung für reguläre Ausdrücke überschritten. Zahlengenerierung bei jeder Iteration (nullbasiert):

  • ob r % 2 = 0 (normale Zeile),n = (r * N) + c = counter
  • if r % 2 = 1(umgekehrte Zeile),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Oder alles auf einmal, als eine Nummerierung: n = counter + ((N - (2 * c) - 1) * (r % 2)); n++

?sN0             # read input, save as N, initialize iteration counter
[AP]sP           # macro 'P' that prints a newline (ASCII code 10 = A)
[                # start loop
    ddlN~        # push N, calculate row and column coordinates:
                 #r = int(counter / N), c = counter % N, '~' calculates both
    _2*lN+1-     # c is on top, so this does: N - (2 * c) - 1
    r2%*+        # now r is on top, do: (r % 2) * (previous result) + counter
    1+n32P       # do: n++, print space (ASCII code 32)
    1+           # increment counter
    dlN%0=P      # call macro 'P' every Nth printed number
    dlNd*>L      # if: N * N > counter, repeat loop
]dsLx            # this saves the loop to macro 'L', then executes it
qqq              # my script was shorter, so I added a bunch of quit commands to
                 #fit the regex limit. Use of comments ('#') was prohibited.
Seshoumara
quelle
@MitchellSpector Hier ist meine Erklärung. Wie Sie sehen, haben wir beide buchstäblich den gleichen Algorithmus, nur ich benutze den Befehl ~, um die Zeilen- und Spaltenindizes auf einmal zu berechnen. Aber einer meiner vorherigen Versuche hat sie wie Sie separat berechnet. Große Köpfe denken ähnlich? :)
Seshoumara
1
Ja, es ist wirklich derselbe Algorithmus. Ich mag Ihre Verwendung ~, um den Code zu verkürzen.
Mitchell Spector
Ich denke, Sie können es um ein Byte verkürzen, wenn Sie den Quadratwurzel-Trick im Schleifentest am Ende des Makros verwenden: ?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdvlN>L]dsLx tio.run/nexus/…
Mitchell Spector
@MitchellSpector Sie haben Recht, und ich habe es beim Lesen Ihrer Erklärung bemerkt, aber stattdessen im Chatroom kommentiert .
Seshoumara
Ja, das sehe ich jetzt - ich hatte mir heute Morgen noch keinen Chatroom angesehen.
Mitchell Spector
3

PowerShell, ConnorLSW

Riss

$mySnakeIndex=1;$seq=1..$args[0];$seq|%{$rowNum=$seq|%{($mySnakeIndex++)};if(!($_%2)){[array]::Reverse($rowNum)};$rowNum-join" "}

Ich begann mit einer kleineren Lösung für das Problem und füllte meine Variablennamen auf, um den regulären Ausdruck passend zu machen. Der Versuch, eine Verwendung für den Dickdarm zu finden, war vermutlich das Schwierigste, meinen Kopf herumzuwickeln.

$a=1..$args[0];$i=1;$a|%{$r=$a|%{($i++)};if(!($_%2)){[array]::Reverse($r)};$r-join" "}

Erläuterung

# Initialize a counter that starts at one.
$mySnakeIndex=1
# Save the integer array from 1 to the input value. 
$seq=1..$args[0]
# For each row of the output...
$seq|%{
    # Build the integer array for this row sequentially
    $rowNum=$seq|%{
        # Increase the integer index while sending it down the pipeline
        ($mySnakeIndex++)}
        # Check if this is and odd row. If so reverse the integer array.
        if(!($_%2)){[array]::Reverse($rowNum)}
        # Take this row and join all the numbers with spaces.
        $rowNum-join" "
Matt
quelle
Nizza, habe ich eine $scriptVariable und ein paar wirklich chaotisch Looping - Pad es aus, das [array]::Reverse()war richtig aber, congrats - ich glaube , Sie auch aus der Länge wünschen könnte $iund $MySnakeIndexthough.
Colsw
@ConnorLSW Ich weiß, dass Sie nachts nicht schlafen können, da ich Fehler in meinem Räuber hatte. Ich habe es repariert.
Matt
3

CJam, Lynn

Etwas wie das:

ri
{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~c{a}seu~~|
{s}seu~~c{c}seu~~|
{t}seu~~sc{a}seu~~|
{s}seu~~c{a}seu~~|{w}seu~~z{w}seu~~sc~c
{s}seu~~sc{fb}seu~~||
{s}seu~~sc{i}seu~~|
{s}seu~~sc{fb}seu~~||
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c
{a}seu~~scs
{w}seu~~
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c
{fb}s{b}s{w}seu~~sc~
{s}seu~~sc{ee}seu~~||
{s}seu~~sc{z}seu~~|{w}seu~~{w}seu~~sc~{w}seu~~{w}seu~~sc~
{t}seu~~sc{a}seu~~|
{~}s{}s{w}seu~~sc~
{t}seu~~sc{c}seu~~|

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~
s~
p

Alle Leerzeichen sind für ... "Lesbarkeit" ... und können weggelassen werden, um der Regex von Lynn zu entsprechen.

Probieren Sie es online!

Erläuterung

Der reguläre Ausdruck erfordert, dass wir das Problem nur lösen, indem wir Folgendes verwenden:

  • Kleinbuchstaben.
  • {}, mit dem Blöcke erstellt werden können.
  • |Wird hauptsächlich für bitweises ODER verwendet.
  • ~, "eval" und bitweises NOT (auch "dump array", aber ich werde es nicht benutzen).

Seit wir ... Haben, ~ beliebige Zeichenfolgen erstellen können, können wir beliebigen Code ausführen. Zunächst ist es jedoch nicht klar, wie das geht.

Das erste Teil des Puzzles ist, dass Blöcke nicht bewertete Codebits sind, mit denen Zeichenfolgen erstellt werden können s. So {abc}sgibt es uns "{abc}". Als Nächstes können Sie eudiese Zeichenfolgen in Großbuchstaben konvertieren.

{abc}seu  e# gives "{ABC}"

Dies hat den Vorteil, dass Großbuchstaben vorinitialisierte Variablen sind. Wir können also eine Menge konstanter Werte erhalten, indem wir eine solche Zeichenfolge erstellen und zweimal auswerten (einmal, um die Zeichenfolge wieder in einen Block zu verwandeln, und einmal, um diesen Block ausführen). Wir können nicht alle Buchstaben erhalten, da einige, wie z. B., xkeine gültigen Befehle sind (daher lehnt CJam es ab, einen Block zu analysieren, der sie enthält). Wir können es nicht so verwenden, fwie es ist, da es von einem anderen Befehl gefolgt werden muss, aber wir können fbdie beiden Werte zusammen verwenden und dann ODER. Ebenso können wir eestatt verwenden e. Damit können wir die Zahlen erhalten 0, -1, 3, und 10zu19 . Die-1 ist praktisch, denn wenn wir es in einen String ( "-1") verwandeln, dann in ein Zeichen ('-) und dann auswerten, können wir entweder subtrahieren oder die Differenz setzen. Wie ich schon sagte, können wir nicht bekommen X(für .1), aber wir können den absoluten Wert von -1mit nehmenz

Wir können auch verwenden s, um eine Zeichenfolge zu erhalten, die ein Leerzeichen enthält, und dies cin ein Leerzeichen umzuwandeln :

{s}seu~~c

Dies ist praktisch, da wir von dort aus viele nützliche Befehle im unteren ASCII-Bereich erhalten können, indem wir das Leerzeichen mit verschiedenen Zahlen ODER-verknüpfen. Um einige der Zeichen über dem Codepunkt zu erhalten 48, verwenden wir '0stattdessen das Zeichen als Basis:

{t}seu~~si

Dies reicht bereits aus, um beliebige Strings zu konstruieren, da wir '+(Addition und String-Verkettung) aus dem folgenden Snippet erhalten können:

{s}seu~~c{b}seu~~|

Und wir haben eine wörtliche 1 , mit dem wir Leerzeichen einfach verschieben, sie auf den gewünschten Wert erhöhen und dann alle zusammenfügen können, aber das ist etwas langweilig, und der Code würde riesig werden.

Stattdessen habe ich sie generiert [und ]ausgewertet, sodass alle Zeichen, die ich dazwischen drücke, automatisch in eine Zeichenfolge eingeschlossen werden. Das sind diese zwei Zeilen:

{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

...

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~

Und schließlich brauchen wir fund ~in der Zeichenfolge, die wir generieren. Dies sind zwar bereits gültige Zeichen, wir haben jedoch keine Zeichenkettenliterale oder Zeichenliterale, daher müssten wir diese ebenfalls generieren, und es ist etwas ärgerlich, größere Codepunkte aus dem Raum zu erstellen. Stattdessen habe ich hier die Mengen-Subtraktion verwendet, aber zwei Blöcke subtrahiert (um die zu entfernen {}):

{fb}s{b}s{w}seu~~sc~
...
{~}s{}s{w}seu~~sc~

Das ist so ziemlich alles. Wir bewerten [. Wir pushen alle Zeichen, die wir durch verschiedene Berechnungen aus den wenigen eingebauten Konstanten erhalten haben |, -(via eval) und +(via eval). Wir bewerten] . Wir machen das Ganze zu einer Zeichenkette, weil ich irgendwann einige Zeichenketten oder Zahlen in die Liste aufgenommen habe. Wir bewerten unsere beliebige Zeichenfolge mit ~.

Das ri...p sind Teil des eigentlichen endgültigen Programms, aber ich habe sie extrahiert, weil sie keine Kodierung benötigen.

Schließlich ist dies das Programm, das wir gerade ausführen:

ri___*,:)/2/[1-1]f.%:~<p

ri      e# Read input and convert to integer.
__      e# Make two copies.
_*      e# Square the last copy.
,       e# Turn into range [0 1 ... n^2-1].
:)      e# Increment each to get [1 2 ... n^2].
/       e# Split into chunks of length n, creating a square.
2/      e# Split into pairs of lines.
[1-1]   e# Push [1 -1].
f.%     e# Use this to reverse the second line in each pair. If n was odd,
        e# this will pair a -1 with the last line.
:~      e# Flatten the pairs back into the square.
<       e# Truncate to n lines to get rid of that extraneous -1 for odd inputs.
p       e# Pretty-print.
Martin Ender
quelle
3

tinylisp , @ DLosc

(v(c(h(q(d)))(c(h(q(f)))(q((c(q(n))(q((g(v(h(q(n))))(s(v(h(q(n))))(v(h(q(1)))))())))))))))(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((i(l(v(h(q(x))))(v(h(q(y)))))x(mod(s(v(h(q(x))))(v(h(q(y)))))y))))))))))(v(c(h(q(d)))(c(h(q(range)))(q((c(c(h(q(x)))(c(h(q(y)))(c(h(q(z)))(q(w)))))(q((i(l(times(v(h(q(z))))(v(h(q(x))))(v(h(q(0)))))(times(v(h(q(z))))(v(h(q(y))))(v(h(q(0))))))(range(v(h(q(x))))(s(v(h(q(y))))(v(h(q(z)))))z(c(s(v(h(q(y))))(v(h(q(z)))))w))w)))))))))(v(c(h(q(d)))(c(h(q(times)))(q((c(c(h(q(x)))(c(h(q(y)))(q(acc))))(q((i(l(v(h(q(x))))(v(h(q(0)))))(times(s(v(h(q(0))))(v(h(q(x)))))(s(v(h(q(0))))(v(h(q(y)))))acc)(i(e(v(h(q(x))))(v(h(q(0)))))acc(times(s(v(h(q(x))))(v(h(q(1)))))y(a(v(h(q(y))))(v(h(q(acc))))))))))))))))(v(c(h(q(d)))(c(h(q(g)))(q((c(c(h(q(n)))(c(h(q(w)))(q(r))))(q((i(l(v(h(q(w))))(v(h(q(0)))))r(g(v(h(q(n))))(s(v(h(q(w))))(v(h(q(1)))))(c(i(e(v(h(q(0))))(mod(v(h(q(w))))(v(h(q(2))))))(range(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))(a(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))n)1())(range(a(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))n)(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))(s(v(h(q(0))))(v(h(q(1)))))()))r)))))))))))

Probieren Sie es online!

Dies definiert eine Funktion f , die die Antwort zurückgibt. Es gibt auch die Namen der Funktionen aus, die ich für stdout definiert habe, aber ich gehe davon aus, dass das keine Rolle spielt, da [wir unseren Ausgabestream auswählen dürfen] zumindest für Code-Golf. Wenn es eine große Sache ist, denke ich, dass ich es optimieren kann, um diese nicht zu drucken. Wie habe ich das gemacht? Ich habe mit etwas ziemlich Normalem angefangen:

(d f (q ((n)
  (g n (s n 1) ()))))

(d mod (q((x y)
  (i (l x y) x
    (mod (s x y) y)))))

(d range (q((x y z w)
  (i (l (times z x 0) (times z y 0))
    (range x (s y z) z (c (s y z) w))
    w))))

(d times (q ((x y acc)
  (i (l x 0) (times (s 0 x) (s 0 y) acc)
  (i (e x 0) acc
    (times (s x 1) y (a y acc)))))))

(d g (q ((n w r)
  (i (l w 0) r
    (g n (s w 1)
       (c (i (e 0 (mod w 2))
             (range (a 1 (times w n 0)) (a (a 1 (times w n 0)) n) 1 ())
             (range (a (times w n 0) n) (times w n 0) (s 0 1) ()))
          r))))))

Dann habe ich beobachtet, dass man Funktionsdefinitionen wie diese transformieren kann:

(d mod (q ((x y) (body))))

wird

(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((body)))))))))

Und Funktionsaufrufe wie folgt:

(a x y)

wird

(a(v(h(q(x))))y)

Ich habe dieses rekursive Vim - Makro verwendet, das im Register gespeichert ist q, um das zweite zu machen (das ich habe)jk abgebildet habe <Esc>):f s(v(h(q(jkea))))jk@q .

Diese beiden Transformationen reichten aus, um alle Leerzeichen zu entfernen.

Brian McCutchon
quelle
Schön gemacht! Mein ursprünglicher Code ist ziemlich ähnlich, obwohl ich ein Hilfsmakro geschrieben habe, um das Schreiben etwas schmerzfreier zu machen. Ich bin gespannt auf Ihre Überlegungen, wie Sie das Drucken der definierten Symbole vermeiden können. Wenn Sie sie weitergeben möchten , bin ich im Chat-Raum von tinylisp .
DLosc
@ DLosc Fertig, ich habe dort gepostet.
Brian McCutchon
2

Swift, James Webster

{n in for j in 0..<n{print((1...n).map{j%2==0 ?$0+j*n:j*n+n+1-$0})}} as(CShort)->()

Überprüfung: https://regex101.com/r/7ukrM0/1

kennytm
quelle
Ich bekomme "Ausdruck löst zu einer unbenutzten Funktion auf", bin aber mit allem, was eine akzeptable Antwort ergibt, nicht vertraut. Ist das zB `let a = <code>; a (CShort (4)); benötigt um es laufen zu lassen nicht nötig?
James Webster
@JamesWebster Ich bin mir nicht sicher über die genauen Regeln, da "ein Code" ziemlich mehrdeutig ist. Für Code-Golf kann die Einreichung ein Programm oder eine Funktion sein , daher biete ich hier nur eine anonyme Funktion an. Wie erhalten wir sonst die Eingabeargumente?
Kennytm
Mein Original war der Körper einer Funktion, also bin ich mir auch nicht sicher, ob meine gültig ist! Also mache ich einfach mit "Klar, das ist in Ordnung" und stimme dem zu. :)
James Webster
@JamesWebster Sie können das Ganze als aufrufen (…)(4), ohne das Integer-Literal in CShort umwandeln zu müssen.
Kennytm
Oh ja! Daran hätte ich nie gedacht.
James Webster
2

PHP, @ JörgHülsermann

<?=(function($n,$snake){foreach(array_chunk(range(1,$n*$n),$n)as$i=>$a){if($i%2)$a=array_reverse($a);echo"\n",join('',array_map(function($e){return(sprintf("%3d",$e));},$a));}})($argv[1],'-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')?>

221 Bytes sind zu lang (also die Schlange), und das fehlende Leerzeichen kann leicht umgangen werden.

Schön gemacht:

<?=
(
    function($n, $snake) {
        foreach (array_chunk(range(1, $n*$n), $n) as $i => $a) {
            if($i % 2)
                $a = array_reverse($a);
            echo "\n", join('', array_map(function($e) {
                return (sprintf("%3d", $e));
            }, $a));
        }
    }
)($argv[1], '-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')
?>
kennytm
quelle
Schöne Variante. Mein Fehler war, nicht über eine Funktion nachzudenken und nur eine Ausgabe zu machen
Jörg Hülsermann
2

Jelly, Länge 12, JonathanAllan

Ḷ-*m@"s@²$G

Probieren Sie es online!

Wie es funktioniert

Ḷ-*m@"s@²$G  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n-1].
 -*          Yield [(-1)**0, ..., (-1)**(n-1)].
         $   Combine the two links to the left into a chain.
        ²    Yield n².
      s@     Split [1, ..., n²] into chunks of length n.
   m@"       Take the lists to the right modulo the units to the left, 1 being
             normal order and -1 being reversed.
Dennis
quelle
2

Gelee , 12 Bytes, knackt @ JonathanAllans zweite Antwort

²sµ;@/€FḤ$¦G

Probieren Sie es online!

Erläuterung

Dies ist fast das gleiche wie meine andere Antwort . Ich habe gerade zwei Änderungen vorgenommen:

Zuerst habe ich U"jedes Element Ṛ€umkehren" in "jedes Element umkehren" geändert . Das hilft nicht von alleine, weil es auch verboten ist.

Dann habe ich das geändert ("reverse") in ;@/( /"fold by" ;"concatenating" @"in der entgegengesetzten Reihenfolge zur ursprünglichen Liste") geändert. Das vermeidet alle gesperrten Zeichen und gibt eine gültige Lösung.

Ich gehe davon aus, dass der nächste Schritt darin besteht, die Array-Manipulation zu verbieten gehe besteht , zusätzlich zu den Atomen Quicks .

Gemeinschaft
quelle
Äh, ich wusste, ich hätte verbieten sollen ...
Jonathan Allan
Sie können auch in Bezug auf schreiben /. Es ist nur etwas ausführlicher als diese Lösung.
Ja und man könnte ;@\ṫ0, der Regex wird lang.
Jonathan Allan
2

Jelly, Länge 13, JonathanAllan

1r-*Nm@"s@²$G

Probieren Sie es online!

Wie es funktioniert

1r-*Nm@"s@²$G  Main link. Argument: n

1r             Range 1; yield [1, ..., n].
 -*            Yield [(-1)**1, ..., (-1)**n].
   N           Negate each unit.
           $   Combine the two links to the left into a chain.
          ²    Yield n².
        s@     Split [1, ..., n²] into chunks of length n.
     m@"       Take the lists to the right modulo the units to the left, 1 being
               normal order and -1 being reversed.
Dennis
quelle
Oh warte, was habe ich verpasst m?!
Jonathan Allan
2

Jelly, Länge 14, @ JonathanAllan

²sµðạ"J×2$$¦GµL.xị"ḅ1µ$

Probieren Sie es online!

Dennis
quelle
Das ist beeindruckend: D
Jonathan Allan
Vielen Dank! :) Aus irgendeinem Grund war ich überzeugt, dass mein Code keine Zeilenumbrüche enthalten konnte, was mich dazu zwang, einige Kettentricks zu entdecken.
Dennis
2

Scala, @Soapy

def g(n:Int) = {
    var vec = Vector.fill(0)(Vector.fill(0)(1))
    for (p <- 1 to n) {
        var vec2 = Vector.fill(0)(1)
        for (q <- (p-1)*n+1 to p*n) {
            vec2 = vec2 ++ Vector(q)
        }
        if (p%2==1) vec = vec ++ Vector(vec2)
        else vec = vec ++ Vector(vec2.reverse)

    }
    println(vec)
}

Ich habe Scala schon eine Weile nicht mehr angerührt, es hat Spaß gemacht, sie noch einmal zu besuchen. Leider fehlen dieser Lösung viele coole Funktionen von Scala.

Probieren Sie es hier aus

Regex Bestätigung

Mathe-Junkie
quelle
2

QBasic (QB64), @DLosc

Beachten Sie, dass der Zeilenumbruch hier ein (U + 000D, CR) ist , da der .nicht übereinstimmt \n(U + 000A, LF \r).

INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM
NEXT:PRINT:NEXT

Überprüfen:

>>> re.match('^([A-Z]+.)+$', 'INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM\rNEXT:PRINT:NEXT')
<_sre.SRE_Match object; span=(0, 141), match='INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR >

Die Hauptschwierigkeit besteht darin, ein Wort nach dem einzufügen ; . Zum Glück behandelt QB64 CR als Zeilenumbruch, während Pythons Regex dies nicht tut REM\r. Von den fünf erlaubten Regex-Aromen

Dieser Riss ist also in Ordnung, solange wir JavaScript nicht erwähnen ... 🤐

kennytm
quelle
Ich werde das akzeptieren, da es in QB64 funktioniert. Ich werde jedoch auch sagen, dass QBasic von archive.org (von dem ich denke, dass es sich eher um das eigentliche QBasic als um eine Emulation handelt) sich darüber beschwert, REMunmittelbar einer Anweisung ohne Anweisungstrennzeichen zu folgen. Meine ursprüngliche Lösung verwendete keine Kommentare. Ich habe eine weitere Variante, die ich in Kürze veröffentlichen werde. : D
DLosc
2

> <>, torcado

!v &0_!
_<>~ao1+>_v_
?______;__>:&:&=?;::2%:}+&:&*{3+0$.
?!v1+:n' 'o:&:&%_
?!v:n' 'o1-:&:&%_
Aaron
quelle
1

C, @Yimin Rong

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

Das Programm kann keine Zahlen enthalten, aber wir können Zahlen erhalten über:

  1. c, allgemein bekannt als "argc", was immer 2 ist.
  2. +und -sind verfügbar, also können wir 0 mit n-nund 1 mit erstellen o=c;--o.
kennytm
quelle
Kleinere Probleme: Die Cop-Version war tabulatorgetrennt und nicht speicherplatzgerecht, aber nicht zu groß.
1

Ruby, @ Value Ink

->n{(1..n).map{|r|x=(r*n-n+1..r*n).to_a;if(r.modulo(2)==1)then(x)else(x.reverse)end}}#1-2-3-4-5-6--

[(-=Z-~]* bedeutet "Ich kann alles schreiben, was ich mag :)"

kennytm
quelle
Ah, ich habe das durcheinander gebracht, nicht
Value Ink
1

tinylisp, @ DLosc

Eine sehr unkomplizierte und völlig unoptimierte Lösung :)

(d p(q((m n)(s m(s(s 1 1)n)))))(d j(q((f g)(i(l f g)(c f(j(p f 1) g))()))))(d r(q((f g)(i(l f g)(c(s g 1)(r f(s g 1)))()))))(d k(q((m o f g n)(i(l n g)()(c(m f(p f n))(k o m(p f n)(p g 1) n))))))(d f(q((n)(k j r 1 1 n))))

Anrufen als (disp (f 4)).

  • (p m n) Berechnet m + n durch Subtraktion s (m + n == m - ((1 - 1) - n))
  • (j f g) erzeugt (f f+1 f+2 ... g-1)
  • (r f g) erzeugt (g-1 g-2 g-3 ... f)
  • (k m o f g n)Generieren Sie eine Zeile der Schlangenmatrix und rekurvieren Sie sich dann für die nächste Zeile, bis n Zeilen erstellt wurden. Die Argumente m, owerden durch substituierte j/ rzu erzeugen Erhöhen oder Erniedrigen Reihen. Die Argumente f,g laufen Indizes zu wissen , welche Zeile sind wir auf.
  • (f n)ruft (k j r 1 1 n)auf, um die Generierung zu starten.
kennytm
quelle
Gute Arbeit. ( (f 4)Übrigens dispist es idiomatischer, nur zu tun - das ist impliziert.)
DLosc
1

PHP, @Ionut Botizan

Im Moment habe ich keine bessere Idee, die ursprüngliche Lösung zu knacken.

Unterstützt n <= 15

Es ist das erste Mal, dass ich getopt benutze. Vielleicht ist es nicht die beste Idee, Optionen als Eingabe zu verwenden.

Starten Sie von der Kommandozeile wie folgt

php hack.php -a=4

Original Regex

Level 1:

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

Sehr schöne Buchstabenkombination. Fühlen Sie sich frei, den Cops-Thread zu stimmen.

Es blockiert mich Funktionen wie - strrev - array_reverse - get_defined_vars

https://regex101.com/r/5rGTnw/2

Level 2:

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

https://regex101.com/r/XtVl9G/1

Lösung

 <?php
    error_reporting(~E_NOTICE)&
    define(A,a.chr(E_COMPILE_ERROR-E_NOTICE+E_WARNING))
    &define(B,getopt(A,[])[a])&print_r(array_chunk(
    array_slice(
    array_merge(
    range(E_ERROR,B)
    ,range(E_WARNING*B,E_ERROR+B)
    ,range(E_WARNING*B+E_ERROR,(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B,+E_ERROR+(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B+E_ERROR,(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B,+E_ERROR+(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B+E_ERROR,(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B,+E_ERROR+(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B+E_ERROR,(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B,E_ERROR+(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B+E_ERROR,(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B,E_ERROR+(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B+E_ERROR,(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B,E_ERROR+(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B+E_ERROR,(E_CORE_ERROR-E_ERROR)*B)
    )
    ,B-B,B*B
    ),B)
    )
    ?>

Level 2:

<?php
define(aa,a.chr(ord(strtoupper(a))-ord(h)+ord(a)))and
define(bb,getopt(aa,[])[a])and
define(us,chr(ord(a)-true-true))and
(prin.t.(us).r)(
(arra.y.(us).chunk)(
(arra.y.(us).slice)(
(arra.y.(us).merge)(
range((ord(b)-ord(a)),bb)
,range((ord(c)-ord(a))*bb,(ord(b)-ord(a))+bb)
,range((ord(c)-ord(a))*bb+(ord(b)-ord(a)),((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(q)-ord(a))-(ord(b)-ord(a)))*bb)
)
,bb-bb,bb*bb
),bb)
)
?>
Jörg Hülsermann
quelle