Ceci est le fil du voleur. Le fil du flic est ici .

Une matrice de serpent est une matrice carrée qui suit ce modèle:

3 par 3:

1  2  3
6  5  4
7  8  9

et 4 par 4:

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

Votre tâche consiste à écrire un code qui prend une entrée net crée une telle matrice, dans la même langue qu'un article de flic, et avec un code qui correspond à l'expression régulière du flic. Le format de sortie de votre code doit correspondre au format de sortie du code du flic.

Veuillez laisser un commentaire sous le post du Cop pour indiquer que vous l'avez craqué.

Critère gagnant:

Le gagnant sera l'utilisateur qui a le plus craqué les soumissions. En cas d'égalité, il y aura alors plusieurs gagnants.

Jelly , 9 octets, craque la réponse de @Dennis

²sµUFḤ$¦G

Essayez-le en ligne!

Devrait être correct maintenant; J'ai dû repenser plutôt ce que je faisais.

Explication

La partie la plus difficile de ce problème consiste à obtenir une liste des indices pairs à l'intérieur de ¦(qui applique une opération à des indices spécifiques). Contrairement à la plupart des opérations, qui utilisent l'entrée de l'ensemble du programme comme valeur par défaut pour le deuxième opérande, ¦utilise la valeur la plus récemment vue comme valeur par défaut (car elle a conceptuellement deux opérandes gauches, plutôt qu'un opérande gauche et droit comme la plupart des choses qui prendre deux valeurs).

Cependant, nous pouvons observer que nous avons une liste de nombres, y compris tous les entiers de 1 à la moitié de l'entrée, déjà dans la valeur actuelle à l'époque. En tant que tel, l'aplatissement et le doublement nous donnent une liste de nombres pairs, y compris tous les indices pairs (également quelques autres nombres pairs, mais nous ne nous en soucions pas). Il est même possible d'en dépenser un µuniquement pour éviter une ambiguïté d'analyse et tout de même entrer dans les 9 caractères.

²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

C'était ma première utilisation de 05AB1E. Je l'ai avec un peu d'aide. C'était amusant. :)

UXFXLNX*+N2BSR1k_iR}ˆ

Essayez-le en ligne

Explication:

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

J'ai trouvé ce programme similaire par moi-même, mais le format de sortie est différent:

UXFXLNX*+N2BSR1k_iR}=

Essayez-le en ligne

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

Voir l'historique des modifications pour mes deux précédentes tentatives.

Python 2, Dennis

Il s'agit d'un problème de golf amusant.

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],

Vérification d'expression régulière

Ohm, Nick Clifford

Ma première fois en essayant Ohm.
Langage vraiment sympa que j'ai hâte de réutiliser :)

²@┼σ▓_^è?R

Explication

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

Ma première tentative qui n'a pas fonctionné comme l'ajout d'un tableau et d'un int n'est pas possible:

@┼MDR┼+;W

Ma deuxième tentative qui ne correspondait pas à l'expression régulière:

²@┼σ▓_^MR

05AB1E, Emigna (2e soumission)

Première collaboration avec 05AB1E.

VYLUYFYXDˆ+RU

Essayez-le en ligne! | Vérification d'expression régulière

Explication

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

Tous les sauts de ligne sont à des fins esthétiques et peuvent être supprimés sans affecter le programme.

Essayez-le en ligne!

Explication

Après que Lynn ait été supprimée {|}de la liste des personnages autorisés, j'ai dû essayer quelque chose de nouveau. Il s'avère que nous pouvons encore construire des chaînes arbitraires et les évaluer comme du code.

Tout d'abord, nous devons mettre de la valeur dans la pile. Les seuls éléments intégrés disponibles qui poussent quelque chose sans faire sauter autre chose en premier (et sans lire l'entrée) sont es, eaet et. Je suis sûr que vous pourriez commencer à partir de tout cela d'une manière ou d'une autre, mais je suis allé avec esce qui pousse l'horodatage actuel. Comme je ne voulais pas faire d'hypothèses sur sa valeur réelle, je teste sa primalité avec mp(qui donne 0et 1) et teste à nouveau la primalité de cette valeur pour m'assurer que j'ai un 0sur la pile. Un 1sera plus utile, donc nous calculons exp(0)avec meet le transformons en un entier avec i. Donc, tous les chiffres commencent par:

esmpmpmei

Maintenant, nous avons un tas d'opérateurs mathématiques unaires avec lesquels travailler:

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)

Nous pouvons également combiner quelques éléments intégrés pour des fonctions plus élaborées de 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.

En utilisant ces derniers, nous pouvons obtenir n'importe quel nombre dans 0 <= x < 128(et beaucoup d'autres) en moins de 10 étapes 1. Je suis sûr qu'un sous-ensemble beaucoup plus petit de ces commandes suffirait également. J'ai écrit un petit programme Mathematica pour déterminer tous ces extraits (ce n'est pas très lisible, désolé):

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]

Avec cela, nous pouvons simplement pousser une liste arbitraire de codes de caractères, en convertissant chacun d'eux en un caractère avec censuite. Une fois que nous avons poussé tout le code que nous voulons exécuter, nous poussons 95( ]). Nous évaluons celui-ci avec ~pour envelopper tous les autres dans une chaîne, puis nous évaluons cette chaîne avec ~.

Le code réel exécuté à la fin du programme est à nouveau:

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

Voir ma solution précédente pour une explication.

Python 3, TuukkaX

Désolé, l'expression régulière que vous avez utilisée était trop facile à banaliser. Non 0, #ou ? Aucun problème!

J'ai peut-être mal interprété la sortie de l'exemple, mais c'est toujours assez facile à modifier car il me reste 45 caractères de rechange

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

Cas de tests:

> 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 

Et confirmation regex: https://regex101.com/r/OB8ZIM/1

J'avais aussi:

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

qui donne la même sortie et correspond à la même expression régulière .

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

Ceci est une fonction anonyme qui correspond à cette PCRE regex: ^{(\|[^\/#\s]*){8}$.

Essayez-le en ligne!

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

Prettifié:

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
)

La première partie de la sous - commande génère 1 2 3 4, 9 10 11 12et la seconde partie va générer 8 7 6 5, 16 15 14 13. L'extérieur sort -nles mélangera correctement pour former le motif de serpent.

J'ai utilisé l'astuce dans /superuser//a/101760 pour imprimer les lignes paires et impaires. Merci Marcos, vraiment amusant.

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)

• Vérifiez: https://regex101.com/r/GI1Zvh/1

Une légère analyse de l'expression rationnelle du policier montre un modèle fixe:

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

où _est n'importe quel caractère sauf [ '"#]et ^est n'importe lequel [int()2/].

Le "*n)à la fin montre clairement un eval("..."*n)ou exec("..."*n)se passe, nous avons donc juste besoin de nous assurer que les "..."imprime la j-ème ligne.

Le for i in range(j,est trop près de la fin de la chaîne, suggérant une compréhension de la liste sans aucun if. Nous devons donc construire le i-ième colonne en utilisant ceux i%n, des 2*nchoses.

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

C'était ma première participation à un défi de policiers et de voleurs, et je me suis beaucoup amusé. Le regex devait être apparié était simple, ^[^# !]{59}$ce qui a essentiellement transformé mon travail en golf, sans utiliser ces 3 caractères. Au début, j'ai eu des difficultés à descendre en dessous de 60 octets, mais je l'ai finalement craqué.

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

Essayez-le en ligne!

Explication:

Mon code utilise une boucle avec N ² itérations, en gardant un compteur à base zéro (1D), et calcule le nombre à imprimer en fonction des coordonnées matricielles de ligne et de colonne (r, c) correspondantes.

Exemple de ce que je veux dire, si 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

Cela semble compliqué, mais l'étape intermédiaire est utile. De plus, j'ai essayé d'utiliser 2 boucles depuis le début, mais je me suis retrouvé au-dessus de la limite de caractères regex. Génération de nombres à chaque itération (base zéro):

• si r % 2 = 0(ligne normale),n = (r * N) + c = counter
• si r % 2 = 1(ligne inversée),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

Ou tout à la fois, en une seule numérotation: 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

Fissure

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

J'ai commencé avec une solution plus petite au problème et j'ai complété mes noms de variables pour obtenir la correspondance avec l'expression régulière. Essayer de trouver une utilisation pour le côlon, je suppose, a été la partie la plus difficile à envelopper.

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

Explication

# 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

Quelque chose comme ça:

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

Tous les espaces sont destinés à ... la "lisibilité" ... et peuvent être omis pour se conformer à l'expression régulière de Lynn.

Essayez-le en ligne!

Explication

Le regex nécessite que nous résolvions le problème en utilisant uniquement:

• Minuscules.
• {}, qui peut être utilisé pour créer des blocs.
• |, principalement utilisé pour OR au niveau du bit.
• ~, "eval" et bitwise NOT (également "dump array", mais je ne vais pas l'utiliser).

Puisque nous avons, ~si nous pouvons construire des chaînes arbitraires, nous pouvons exécuter du code arbitraire. Cependant, au début, il n'est pas évident de savoir comment procéder.

La première pièce du puzzle est que les blocs sont des morceaux de code non évalués, qui peuvent se transformer en chaînes avec s. Alors {abc}snous donne "{abc}". Ensuite, nous pouvons utiliser eupour convertir ces chaînes en majuscules.

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

L'avantage de ceci est que les lettres majuscules sont des variables pré-initialisées, donc nous pouvons obtenir beaucoup de valeurs constantes en créant une telle chaîne, et en l'évaluant deux fois (une fois pour transformer la chaîne en bloc et une fois pour exécuter ce bloc). Nous ne pouvons pas obtenir toutes les lettres, car certaines, comme xne sont pas des commandes valides (donc CJam refusera d'analyser un bloc les contenant). Nous ne pouvons pas utiliser ftel quel, car il doit être suivi d'une autre commande, mais nous pouvons utiliser fbpuis OU les deux valeurs ensemble. De même, nous pouvons utiliser à la eeplace de e. Avec cela, nous pouvons obtenir les chiffres 0, -1, 3et 10à 19. Le -1est pratique, car si nous le transformons en chaîne ( "-1") puis en caractère ('-), puis évaluez-le, nous pouvons obtenir une soustraction ou définir une différence. Comme je l'ai dit, nous ne pouvons pas obtenir X(pour 1), mais nous pouvons prendre la valeur absolue de -1with z.

Nous pouvons également utiliser spour obtenir une chaîne contenant un espace, et utiliser cpour transformer cela en un caractère d' espace :

{s}seu~~c

C'est pratique, car à partir de là, nous pouvons obtenir de nombreuses commandes utiles dans la plage ASCII inférieure en effectuant une opération OR sur l'espace avec différents nombres. Pour obtenir certains des caractères au-dessus du point de code 48, nous utilisons '0plutôt le caractère comme base:

{t}seu~~si

C'est déjà suffisant pour construire des chaînes arbitraires, car nous pouvons obtenir '+(addition et concaténation de chaînes) à partir de l'extrait de code suivant:

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

Et nous avons un littéral 1afin que nous puissions simplement pousser les caractères d'espace, les incrémenter à la valeur dont nous avons besoin, puis les concaténer tous ensemble, mais c'est un peu ennuyeux et le code deviendrait énorme.

Au lieu de cela, je les ai générés [et ]supprimés, de sorte que tous les caractères entre lesquels je pousse sont automatiquement enveloppés dans une chaîne. Voilà ces deux lignes:

{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~

Et enfin, nous aurons besoin fet ~dans la chaîne que nous générons. Bien que ce soient déjà des caractères valides, nous n'avons pas de littéraux de chaîne ou de littéraux de caractères, nous devons donc les générer également et créer des points de code plus grands à partir de l'espace est un peu ennuyeux. Au lieu de cela, j'ai utilisé la soustraction d'ensemble ici, mais en soustrayant deux blocs (pour se débarrasser de {}):

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

C'est à peu près tout ce qu'il y a à faire. Nous évaluons [. Nous poussons tous les caractères, obtenus par différents calculs à partir des quelques constantes intégrées que nous avons |, -(via eval) et +(via eval). Nous évaluons ]. Nous aplatissons le tout dans une chaîne, car à un moment donné, j'ai ajouté des chaînes ou des nombres dans la liste. Nous évaluons notre chaîne arbitraire avec ~.

Ils ri...pfont partie du programme final, mais je les ai extraits car ils n'ont pas besoin d'encodage.

Enfin, voici le programme que nous exécutons actuellement:

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

Essayez-le en ligne!

Cela définit une fonction fqui renvoie la réponse. Il affiche également les noms des fonctions que j'ai définies sur stdout, mais je suppose que cela n'a pas d'importance, car [nous sommes autorisés à choisir notre flux de sortie] pour le code golf, au moins. Si c'est un gros problème, je pense que je peux le modifier pour ne pas les imprimer. Comment l'ai-je fait? J'ai commencé avec quelque chose d'assez standard:

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

Ensuite, j'ai observé que l'on peut transformer des définitions de fonctions comme ceci:

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

devient

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

Et les appels de fonction comme ceci:

(a x y)

devient

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

J'ai utilisé cette macro récursive Vim, stockée dans le registre q, pour faire le second (j'ai jkmis en correspondance <Esc>): f s(v(h(q(jkea))))jk@q.

Ces deux transformations ont suffi à éliminer tous les espaces.

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

Vérification: 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~')?>

• Vérifiez: https://regex101.com/r/81pUrB/1
• TIO: https://tio.run/#aNvF0

221 octets est trop long (donc le serpent), et le manque d'espace peut être facilement contourné.

Prettifié:

<?=
(
    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, longueur 12, @JonathanAllan

Ḷ-*m@"s@²$G

Essayez-le en ligne!

Comment ça fonctionne

Ḷ-*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.

Jelly , 12 octets, craque @ deuxième réponse de JonathanAllan

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

Essayez-le en ligne!

Explication

C'est presque la même chose que mon autre réponse . Je viens de faire deux changements:

Tout d'abord, j'ai changé U("inverser chaque élément") en Ṛ€("inverser" "chaque élément"). Cela n'aide pas en soi, car il Ṛest également interdit.

Ensuite, j'ai changé le Ṛ("reverse") en ;@/( /"fold by" ;"concatenating" @"dans l'ordre inverse de la liste d'origine"). Cela évite tous les caractères interdits, donnant une solution valide.

Je suppose que la prochaine étape serait de commencer à interdire les rapides de manipulation de tableaux , en plus des atomes.

Jelly, longueur 13, @JonathanAllan

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

Essayez-le en ligne!

Comment ça fonctionne

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, longueur 14, @JonathanAllan

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

Essayez-le en ligne!

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

Je n'ai pas touché Scala depuis un moment, c'était amusant de revisiter. Malheureusement, cette solution passe à côté de nombreuses fonctionnalités intéressantes de Scala.

Essayez-le ici

Confirmation de l'expression régulière

QBasic (QB64), @DLosc

Notez que puisque le .ne correspond pas \n(U + 000A, LF), la nouvelle ligne ici est un \r(U + 000D, CR).

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

Vérifier:

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

La principale difficulté est de savoir comment insérer un mot après le ;. Heureusement, QB64 traite CR comme une nouvelle ligne alors que l'expression régulière de Python ne le fait pas, donc nous pourrions glisser un REM\rici. Sur les cinq saveurs regex autorisées,

• Perl accepte "\r" =~ /./
• JavaScript rejets !/./.test('\r') ( \n, \r, \u2028, \u2029sont tous les séparateurs de ligne )
• Python accepte re.match('.', '\r')( seul \nest considéré comme un saut de ligne )
• Golang accepte regexp.Match(".", "\r")
• Ruby accepte /./ =~ "\r"

Donc, cette fissure est très bien tant que nous ne mentionnons pas JavaScript ... 🤐

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

Vérification d'expression régulière

> <>, 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');}

Le programme ne peut pas contenir de nombres, mais nous pouvons obtenir des nombres via:

1. c, communément appelé "argc", qui est toujours 2.
2. +et -sont disponibles, nous pouvons donc créer 0 avec n-net créer 1 avec 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-~]* signifie "je peux écrire tout ce que j'aime :)"

tinylisp, @DLosc

Une solution très simple et totalement non optimisée :)

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

Appelez le (disp (f 4)).

• (p m n)calcule m + n en utilisant la soustraction s(m + n == m - ((1 - 1) - n))
• (j f g) génère (f f+1 f+2 ... g-1)
• (r f g) génère (g-1 g-2 g-3 ... f)
• (k m o f g n)générer une ligne de la matrice de serpent, puis se recourber pour la ligne suivante, jusqu'à ce que n lignes soient créées. Les arguments m, osont substitués par j/ rpour générer l' augmentation ou la diminution des rangées. Les arguments f, gsont des indices en cours d' exécution à savoir quelle ligne nous sommes.
• (f n)appelle (k j r 1 1 n)à démarrer la génération.

PHP, @Ionut Botizan

Pour le moment, je n'ai aucune meilleure idée de casser la solution d'origine.

Prend en charge n <= 15

C'est la première fois que j'utilise getopt. Ce n'est peut-être pas la meilleure idée d'utiliser des options en entrée.

commencer à partir de la ligne de commande comme celle-ci

php hack.php -a=4

Regex d'origine

Niveau 1:

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

Très belle combinaison de lettres. N'hésitez pas à voter pour le fil des flics.

Il me bloque des fonctions comme - strrev - array_reverse - get_defined_vars

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

Niveau 2:

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

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

Solution

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

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