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.

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.         

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.

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

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

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

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 .

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"

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 .

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!

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

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

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)

• Überprüfen Sie: https://regex101.com/r/GI1Zvh/1

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)

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

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

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.

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.

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

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

• Überprüfen Sie: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

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

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.

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 .

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.

Jelly, Länge 14, @ JonathanAllan

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

Probieren Sie es online!

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

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

• Perl akzeptiert "\r" =~ /./
• JavaScript Spuck !/./.test('\r') ( \n, \r, \u2028,\u2029 sind alle Zeilenseparatoren )
• Python akzeptiert re.match('.', '\r')( nur\n als Zeilenumbruch betrachtet )
• Golang akzeptiert regexp.Match(".", "\r")
• Ruby akzeptiert /./ =~ "\r"

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

Python 3, Kennytm

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

Regex-Überprüfung

> <>, torcado

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

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.

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

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.

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