Questo è il filo del poliziotto. Il filo del ladro è qui .

Scrivi un codice che accetta un input ne crea una "matrice di serpenti" n-by-n.

Una matrice di serpenti è una matrice che segue questo schema:

3-by-3:

1  2  3
6  5  4
7  8  9

e 4 per 4:

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

Il formato di output esatto è facoltativo. È possibile ad esempio l'output [[1 2 3],[6 5 4],[7 8 9]]o qualcosa di simile.

Devi fornire il nome della lingua e una regex che corrisponda completamente al tuo codice. Puoi scegliere quanto dettagliato dovrebbe essere il tuo regex. All'estremo, puoi scrivere una regex che corrisponde a ogni possibile stringa, nel qual caso sarà molto facile decifrare il tuo codice. Devi anche fornire l'output per n=4, in modo che i ladri conoscano il formato esatto per cui hai optato.

È possibile utilizzare uno degli aromi regex disponibili su regex101.com o l'aroma Ruby.

• PCRE (PHP)
• Javascript
• Pitone
• Golang
• Rubino

Devi specificare quale stai usando.

Gli appunti:

• È necessario supportare qualsiasi ragionevolmente grande n. Si può presumere che non trabocchi il tipo di dati o la memoria. Se il tipo di dati predefinito è numeri interi con n<=11segno a 8 bit, allora puoi assumere , se è numeri interi a 8 bit senza segno, puoi assumere n<=15.
• I ladri devono corrispondere al formato di output dell'invio, ad eccezione degli spazi iniziali e finali e delle nuove righe, poiché ciò potrebbe essere stato eliminato dalla formattazione SE.

Criterio vincente:

Il vincitore sarà la presentazione non crackata con la regex più breve, misurata in numero di caratteri.

Se il tuo post è rimasto inalterato per 7 giorni, puoi pubblicare la soluzione prevista e contrassegnare l'invio come sicuro.

05AB1E , Cracked by mbomb007

Spero divertente da rompere e non troppo ovvio.

Regex (PCRE):

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

Uscita n = 4:

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

Soluzione originale

UXFXLNX*+NFR}ˆ

Python 2 , lunghezza 62, incrinato

Regex (PCRE)

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

Uscita campione

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

Gelatina , lunghezza 6, screpolata

Regex (PCRE)

^.{9}$

Uscita campione

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

R, lunghezza 14 Incrinato da plannapus

Spero di aver capito bene questa regex. Quello che cercando di dire è di 77 caratteri escluso <space>, #, ;e [. L'ho provato qui

regex

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

Uscita campione n = 4

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

05AB1E , incrinato da Value Ink

Diamo il massimo :)
Speriamo che sia un bel puzzle.

Regex (PCRE)

^\w*..\w*$

Uscita n = 4

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

> <> , lunghezza 49, incrinato da Aaron

Regex (Javascript)

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

Uscita campione (n = 4)

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

La formattazione è un po 'strana, ma il controllo della lunghezza del numero lo avrebbe reso molto più lungo. Potrebbe essere andato un po 'fuori bordo sul regex, non sono sicuro!

Modifica: Inoltre ho dimenticato di menzionare, utilizzo lo stack iniziale (-v flag) per l'input, non il solito input fish. Scusate!

Codice originale:

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

Aaron è molto più semplice! La complessità del mio codice originale si basa sull'idea di utilizzare n[r]ogni n-esimo numero per capovolgere quel segmento (riga), quindi stampare tutti i numeri contemporaneamente alla fine

Oh , incrinato

Anche la mia prima sfida a sbirri e poliziotti, quindi dimmi se ci sono problemi con questo schema (soprattutto perché si tratta di un linguaggio abbastanza sconosciuto).

Regex (PCRE)

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

Uscita (n = 4)

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

PHP, 221 byte ( crackato )

Spero sia abbastanza difficile.

Regex (PCRE): 16 byte

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

Nessuno spazio, nessun commento, nessun utilizzo di base64_decode. Divertiti.

Produzione

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

Codice originale

$w=$argv[1];$s="";$r=range(1,$w**2);for($i=0;$i<$w;$i++)if($i%2)array_splice($r,$i*$w,$w,array_reverse(array_slice($r,$i*$w,$w)));foreach(($r)as$v)$s.=str_pad($v,$l=strlen(max($r))+1,"\x20",0);echo(chunk_split($s,$l*$w));

C # net46 (Cracked)

( http://ideone.com/ works)

Lunghezza del sapore Regre PCRE 58 testato su regex101

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

Viene regexato solo il metodo. Il metodo restituisce un array 2d int [,] (int [4,4]) per un input n = 4. Se la stampa è simile alla seguente:

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

Questa è la mia prima entrata in qualcosa del genere, fammi sapere se ho fatto qualcosa di sbagliato. Non provando a vincere per regex di sicuro, sono solo interessato a vedere quanto sono riuscito a prevenire il cracking :)

Codice originale:

static int[,]g(int n){int l,j,k=n-n,c,s;var _=new int[n,n];var d=n!=n;c=k;c++;s=k;for(l=k;l<n;l++){for(j=k;j<n;j++){_[l,d?n-j-c:j]=++s;}d=!d;}return _;}

QBasic, regex lunghezza 10 ( incrinato )

regex

Dovrebbe funzionare con qualsiasi sapore regex, ma lo chiameremo sapore Python.

([A-Z]+.)+

NOTA: la mia soluzione utilizza QBasic non formattato; dopo la formattazione, il codice non corrisponde alla regex a causa di spazi aggiunti. (Ma posso dirti che è l'unica modifica che fa la differenza. ([A-Z]+ ?. ?)+Funziona ancora con la versione formattata.)

A scopo di test, ho usato QB64 con la formattazione del codice disattivata (in Opzioni> Layout del codice). Se non vuoi scaricare qualcosa, puoi anche eseguire QBasic online su archive.org (ma lì non puoi disattivare la formattazione).

Uscita campione

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

Python 3, 55 byte (Cracked)

Sapore PCRE / Python / Golang.

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

(Ricorda che è richiesta la corrispondenza completa . Supponi ^e $durante i test.)

Uscita campione:

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

Soluzione originale:

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

Dovrebbe essere stato eliminato 4 byte: p

dc , Regex lunghezza 12   Incrinato da seshoumara!

^[^# !]{59}$

Questa espressione regolare è abbastanza semplice da non pensare che il sapore della regex sia importante: dovrebbe funzionare su tutta la linea. (Nota lo spazio dopo il # nella regex.)

Ho testato tutti e quattro i gusti su regex101.com (PCRE / PHP, Javascript, Python e Golang), così come la versione Ruby su rubular.com. Il programma dc corrisponde al regex in tutte e cinque le versioni regex.

Il programma dc prende il suo input su stdin e mette il suo output su stdout.

Esempio di output per input 4 (c'è uno spazio finale alla fine di ogni riga):

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

Codice originale (aggiunto dopo essere stato crackato)

Questo è stato risolto da @seshoumara . Ecco il mio codice previsto:

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

Spiegazione:

?sd      Input number and store it in register d.
[AP]s+   Macro that prints a newline. The macro is stored in register '+'.
0        Push 0 on the stack, initializing a loop.  (The top of the stack is the index variable.  It will go up to d^2-1.)
[        Start a macro definition.  (The macro will be stored in register l.)
ddd      Push 3 copies of the loop index variable on the stack, so they'll be available later. I'll call this number i.
ld/      Divide the last copy of i by d (integer division); this computes the row of the square that we're in (starting with row 0).
2%       Replace the row number with 0 if the row number is even, with 1 if the row number is odd.
r        Swap the top two items on the stack, so the top item is now the next to last copy of i, and the second item on the stack is the row number mod 2.
ld%      Compute i mod d; this goes from 0 to d-1. It is the column in the square that the next number will be placed in.  (The leftmost column is column 0.)
2*1+     Top of the stack is replaced with 2*(column number)+1.
ldr      Inserts d as the second item on the stack.
-        Computes d-2*(column number)-1.
*        The second item on the stack is the row number mod 2, so multiplying yields 0 if the row number is even, and d-2*(column number)-1 if the row number is odd.
+        Add to the remaining copy of i. The sum is i itself in even-numbered rows, and it's i+d-2*(column number)-1 in odd-numbered rows.

La somma in cima alla pila ora è il prossimo numero che vogliamo stampare:

• È facile vedere che è corretto se il numero di riga è pari, da allora la somma è solo io.

• Per le righe dispari, nota che i = d * (i / d) + (i% d) = d * (numero di riga) + numero di colonna. Ne consegue che la somma i + d-2 * (numero colonna) -1 è d * (numero riga) + numero colonna + d - 2 * (numero colonna) - 1 = d * (numero riga + 1) - numero colonna - 1, che è il numero che vogliamo inserire nella riga e nella colonna indicate per garantire che contiamo all'indietro nelle righe dispari.

Tornando alla spiegazione ora:

n        Print the desired number for the current row and column.
2CP      Print a space.  (2C, which is computed by dc as 20 + 12, is 32, the ASCII code for a space.)
1+       The original copy of i is at the top of the stack; add 1 to it.
dld%0=+  If (the incremented value of) i is a multiple of d, call the macro at register '+', which prints a newline.
dvld>l   If d > sqrt(i) (in other words, if i < d^2), then go back to the top of the loop by calling macro l again.
]dslx    End the macro definition, store the macro in register l, and execute it.

Bash, regex lunghezza 38, incrinato ( @kennytm )

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

Ingresso:

n=4; <command>

Produzione:

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

PHP

Spero che questo sia divertente! : D

Uscita (n = 4)

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

Livello 1: PCRE (lunghezza = 17) ( Cracked di Jörg Hülsermann )

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

• Non ci sono virgolette singole o doppie quindi ... niente stringhe!
• Nessuna cifra!
• No, {quindi ... nessuna funzione anonima!
• No vcosì ... no eval()!
• No, ;quindi ... deve essere una singola affermazione!
• No <così ... no Heredocné più blocchi PHP!
• Quello grande! No $ quindi ... buona fortuna nel definire le variabili! >: D

@ JörgHülsermann ha avuto un approccio interessante, ma non è quello che avevo in mente :). Pertanto, sto introducendo un nuovo livello di difficoltà (prometto di avere il codice adatto a questo e non sto solo scherzando):

Livello 2: PCRE (lunghezza = 23) ( Cracked di Jörg Hülsermann )

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

• Tutte le restrizioni di livello 1
• Novità a questo livello: nessuna di queste _~|&A-Z! :)

Divertiti!

LA SOLUZIONE ORIGINALE

Quindi, vietando il $significato, non è possibile accedere alle variabili in modo regolare, ma ciò non significa che non possano essere utilizzate affatto! È ancora possibile utilizzare extract()/compact()per importare / esportare variabili nell'ambito corrente. :)

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

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

Tuttavia, c'è un gotcha: compact('x')['x']++non funzionerebbe perché le variabili in PHP vengono passate per valore ... con un'eccezione! Oggetti.

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

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

Il resto è facile.

• I numeri 0e 1sono facilmente generati convertendo falsee trueper intda loro anteponendo il +segno
• Utilizzare ande orpoiché &e |sono vietati
• Per aggirare le virgolette proibite, basta usare costanti indefinite, che sono trattate come stringhe
• Per sopprimere gli avvisi generati usando costanti indefinite, basta usare @
• La lettera proibita vpuò essere generata utilizzando chr(ord('u') + 1), che si traduce @chr(ord(u) + true)nell'utilizzo delle soluzioni alternative sopra
• Il carattere di sottolineatura è simile al precedente: chr(ord('a') - 2)che si traduce inchr(ord(a) - true - true)
• La chiamata di funzioni che contengono caratteri proibiti può essere effettuata sfruttando il callabletipo di PHP , che può essere una stringa contenente il nome della funzione. Quindi, puoi concatenare costanti indefinite e stringhe di singoli caratteri generate da ord()per costruire il nome della funzione e invocarlo in questo modo: array_reverse()diventa (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayè un costrutto di linguaggio, ecco perché è diviso in costanti indefinite ae rray)
• Approfitta del fatto che, quando si tratta di costrutti condizionali e ad anello, le parentesi graffe sono opzionali se il costrutto si applica solo all'istruzione immediatamente successiva. Questo significa che puoi fare cose come: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

La logica nel codice leggibile dall'uomo sarebbe:

if (
    $x = (object) [
        'result' => [],
        'i' => 0
    ]

    and

    define('n', $argv[1])

    and

    define('un', '_')

    and

    // create the initial set which we'll loop through
    define('segments', array_chunk(range(1, pow(n, 2)), n))
) while (
    // store each odd segment as-is and increment the "pointer"
    ($x->result[] = @segments[$x->i++])

    and

    // store each even segment reversed and increment the "pointer"
    ($x->result[] = @array_reverse(segments[$x->i++]))

    and

    // check if we need to break out of the loop
    n > $x->i

    or

    // exit and output the result if the above is false
    die(json_encode(
        // if n is odd, the above would have copied a NULL entry 
        // from the segments, so it needs to be filtered out
        array_filter($x->result)
    ))
)

E la versione ostile che corrisponde alla regex:

<?php if (@extract([x=>(object)[s=>[],i=>+false]])and@define(n,compact(arg.chr(ord(u)+true))[arg.chr(ord(u)+true)][+true]?:+true)and@define(un,chr(ord(a)-true-true))and@define(s,(a.rray.un.chunk)(range(+true,pow(n,true+true)),n)))while((@compact(x)[x]->s[]=s[@compact(x)[x]->i++])and(@compact(x)[x]->s[]=(a.rray.un.re.chr(ord(u)+true).erse)(s[@compact(x)[x]->i++]))and(n>@compact(x)[x]->i)or(@die((json.un.encode)((a.rray.un.filter)(@compact(x)[x]->s)))))?>

Ruby [incrinato]

La prima sfida di poliziotti e ladri. Spero di non averlo reso troppo facile.

EDIT: sostituito \g<1>con (?1)perché evidentemente equivalenti in PCRE.

Regex (PCRE)

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

Uscita (n = 4)

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

(Restituisce una matrice di array. È un lambda, BTW, ma forse questo dà via troppo?)

JavaScript (crackato)

La prima volta a fare una sfida a sbirri e poliziotti, si spera di farlo nel modo giusto.

Regex (JavaScript)

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

Produzione

Un array uguale a:

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

Swift, regex 25 (Cracked)

Bene, vediamo se ho capito. Questo è il mio primo post su poliziotti e ladri, quindi fammi sapere se ho sbagliato!

regex

Ho usato il sapore javascript su regex101.com

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

Uscita campione

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

Codice originale

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

C - regex di 42 caratteri di lunghezza - incrinato

Javascript regex come usato in regex101 .

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

Indovinare questo sarà banale ...

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

L'output è delimitato da tabulazioni \ndopo ogni riga.

La mia soluzione, qui numeri interi 0-2 sono stati ottenuti tramite t-t, t/te t:

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

Gelatina , lunghezza 14 incrinata

incrinato da Dennis

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

Python regex.

Aggiunto mdi nuovo dopo che l'ho lasciato scivolare.

/(ridurre rapidamente);
da P(prodotto) a `(monade dalla diade veloce);
m(indicizzazione modulo);
v(eval dyad);
da Ḋ(dequeue) a ṫ(tail); e
€ (per ogni rapido)

Per un input delle 4mie uscite:

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

... perché ho formattato un elenco di elenchi come una griglia con G.

Powershell, 23 byte

Cracked By Matt

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

Soluzione originale:

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

Accetta input come argomento e output su stdout

Spero che questa regex sia OK, non mi aspetto che sia troppo difficile da spezzare, dato che non ne ho offuscato gran parte, e la regex fornisce alcuni buoni punti di partenza per colmare le lacune, c'è una cosa nel primo segmento che è molto raro nel code golf, ma che potrebbe catturare qualcuno, penso che sia necessaria una partita non golosa per renderlo un po 'più duro.

I primi poliziotti sfidano comunque.

1..4 | % { "----$_----" ; .\snake-cops.ps1 $_  }
----1----
1
----2----
1 2
4 3
----3----
1 2 3
6 5 4
7 8 9
----4----
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13

Röda 0.12 , lunghezza 19 (Cracked by @KritixiLithos)

PCRE:

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

Uscita campione (n = 4):

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

Codice originale:

{|n|seq(0,n-1+n%2)|push([{|i|seq(n*i+1,n*i+n)}(_)],[{|j|seq(n*j+n,n*j+1,step=-1)}(_)])|head(n)}

Provalo online!

PHP 7 (Sicuro)

Codice originale

for($z=0,$q="";$z<($x=$argv[1])**2;){$w=($d=intdiv($z,$x))%2?($d+1)*$x-$z%$x:($z+1);for($f=0;$f<(log10($x**2)^0)-(log10($w)^0);$f++)$q.="\x20";$q.=++$z%$x?"$w\x20":"$w\n";}print(rtrim($q));

Secondo tentativo

Regex (PCRE): 29 byte

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

Nessuno spazio, nessun commento, nessun utilizzo di base64_decode.

Molte funzioni non sono consentite! sottolineare

Uscita n = 11

  1   2   3   4   5   6   7   8   9  10  11
 22  21  20  19  18  17  16  15  14  13  12
 23  24  25  26  27  28  29  30  31  32  33
 44  43  42  41  40  39  38  37  36  35  34
 45  46  47  48  49  50  51  52  53  54  55
 66  65  64  63  62  61  60  59  58  57  56
 67  68  69  70  71  72  73  74  75  76  77
 88  87  86  85  84  83  82  81  80  79  78
 89  90  91  92  93  94  95  96  97  98  99
110 109 108 107 106 105 104 103 102 101 100
111 112 113 114 115 116 117 118 119 120 121

Uscita n = 4

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

Uscita n = 3

1 2 3
6 5 4
7 8 9

MATL , lunghezza 12 (sicuro)

regex

Usa il sapore Python:

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

Esempio di output

Per n=4:

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

Soluzione

txU:GeG:oEq*S5M*TTx!

Per vedere come funziona, considera l'input n=4.

tx   % Implicit input n, duplicate, delete. So this does nothing
     % STACK: 4
U    % Square
     % STACK: 16
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
Ge   % Reshape as an n-row array in column major order
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
G:   % Push range [1 2 ... n]
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
               [1 2 3 4]
o    % Modulo 2
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1  0  1  0]
Eq   % Times 2, minus 1 (element-wise)
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1 -1  1 -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1 -5  9 -13;
               2 -6 10 -14
               3 -7 11 -15
               4 -8 12 -16]
S    % Sort each column
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
5M   % Push [1 -1 1 -1] again
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
              [1 -1  1  -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1  8  9  16;
               2  7 10  15;
               3  6 11  14;
               4  5 12  13]
TTx  % Push [true true] and delete it. So this does nothing
!    % Transpose. Implicitly display
     % STACK: [ 1  2  3  4;
                8  7  6  5;
                9 10 11 12;
               16 15 14 13]

Gelatina , lunghezza 17 (sicura)

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

Python regex.

Stringendo il nodo, questo vieta alcune cose più utili, per il tuo aiuto qui ci sono i byte vietati:

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

poco meno di un terzo di loro!

Per un input delle 4mie uscite:

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

... perché ho formattato un elenco di elenchi come una griglia con G.

Una soluzione:

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

Provalo online! / regex101

Il trucco principale qui è indicizzare in un elenco lessicograficamente delle permutazioni dei numeri naturali fino a n ² (usando œ?per evitare di costruire la lista della lunghezza n ² ! ) E dividere il risultato in blocchi di lunghezza n . L'indice di cui sopra si trova formando la sua rappresentazione nel sistema numerico fattoriale che è formulaico poiché il serpente "non affettato" viene creato permutando gli elementi in un modo prescritto (questo può essere prontamente convertito in un numero con Æ¡).

La soluzione che presento utilizza Ŀper fare riferimento a collegamenti precedenti come monadi (sostituendo Ñe Ç), ma $al posto di "incorporare" queste funzioni di supporto potrebbero essere utilizzati multipli di fila. Utilizza anche rda Ḷe Rsono vietati.

’:2o1 - Link 1, periodic repetitions in the factorial base representation: n
’     - decrement n
 :2   - integer divide by 2
   o1 - or 1 (keep one period in the cases n=1 and n=2)

Ḃ¬aẋ@0 - Link 2, n zeros if n is even, else an empty list: n
Ḃ      - mod 2
 ¬     - not
   ẋ@0 - 0 repeated n times
  a    - and

’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G - Main link: n                    e.g. 6
’r0                        - inclusive range(n-1, 0)              [5,4,3,2,1,0]
    0ẋ$                    - 0 repeated n times                   [0,0,0,0,0,0]
   ;                       - concatenate (makes one "period")     [5,4,3,2,1,0,0,0,0,0,0,0]
        1Ŀ                 - call link 1 as a monad               2
       ẋ                   - repeat list                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,0]
           0¦              - apply to index 0 (rightmost index):
          ¬                -     not (make the last 0 a 1)        [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1]
              2Ŀ           - call link 2 as a monad               [0,0,0,0,0,0]
             ;             - concatenate                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0]
                Æ¡         - convert from factorial base          45461852049628918679695458739920
                      ¤    - nilad followed by link(s) as a nilad
                    ⁸      -     left argument, n                 6
                     ²     -     square                           36
                  œ?       - lexicographical permutation lookup   [1,2,3,4,5,6,12,11,10,9,8,7,13,14,15,16,17,18,24,23,22,21,20,19,25,26,27,28,29,30,36,35,34,33,32,31]
                       s⁸  - split into chunks of length n        [[1,2,3,4,5,6],[12,11,10,9,8,7],[13,14,15,16,17,18],[24,23,22,21,20,19],[25,26,27,28,29,30],[36,35,34,33,32,31]]
                         G - format as a grid

Pip , regex lunghezza 3 (sicuro)

La soluzione è un programma completo che accetta n come argomento della riga di comando. Non utilizza alcun flag della riga di comando.

Regex (qualsiasi sapore)

\w+

Uscita campione

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

La mia soluzione

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

Provalo online!

Strategia

Ecco il codice ci piacerebbe scrivere:

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

Questo è:

• Memorizza i numeri da 1 a a iny
• Ripassa i valori ida 0 aa-1
• Se iè dispari, invertire y, aggiungere i*aa ciascun elemento, concatenare uno spazio per ciascun elemento e stampare
• Altrimenti, fai la stessa cosa, ma senza prima invertire

Le difficoltà

Molti comandi e variabili in Pip usano le lettere, ma alcuni importanti non lo fanno:

• Gamma e gamma inclusiva ( ,e \,)
• La maggior parte delle operazioni matematiche ( +, -, *, %, ++)
• Assegnazione ( :)
• Non possiamo avere un loop o un corpo di funzione con più di un'istruzione (che avrebbe bisogno {})
• Non possiamo usare le parentesi per imporre la precedenza

Come aggirare queste limitazioni:

• ENumerate può essere usato al posto di ,; abbiamo solo bisogno di una stringa con il numero di caratteri che vogliamo e abbiamo bisogno di estrarre il primo elemento di ciascun elenco secondario in una struttura come[[0 "H"] [1 "i"]] .
• Non abbiamo bisogno di incrementare nulla se possiamo risolvere il problema con Fo loop.
• Possiamo assegnare alla yvariabile con l' Yoperatore ank.
• Possiamo fare matematica con le stringhe: Xè la moltiplicazione delle stringhe e PUsh (o PB"push-back") concatenerà una stringa a un'altra stringa sul posto. Per prendere la lunghezza di una stringa, possiamo ENumerarla ed estrarre il numero giusto dall'elenco risultante.
• Possiamo usare le funzioni purché possano essere scritte come funzioni lambda a espressione singola usando _.

specifiche

I mattoni del nostro programma:

Gamma

_MUENsXa

Questo è map-unpack(_, enumerate(repeat(space, a)))in pseudocodice. Map-unpack è come quello di Python itertools.starmap: dato un elenco di elenchi, chiama una funzione sugli elementi di ciascun elenco secondario. _restituisce il suo primo argomento, quindi _MUottiene solo il primo elemento di ciascun elenco secondario. Ad esempio, se a = 3:

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

... che è lo stesso di ,a.

Gamma inclusiva

Non sono sicuro che ci sia un modo di fare inclusive-range(1, a)in una singola espressione, ma per fortuna ne abbiamo bisogno solo una volta, quindi possiamo costruirlo nella yvariabile in tre passaggi.

YENsXaPBs

In pseudocodice, yank(enumerate(repeat(space, a).push-back(space))):

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

Next POyestrae il primo oggetto da ye lo scarta, lasciando [[1 " "] [2 " "] [3 " "]].

Finalmente,

Y_MUy

Cioè yank(map-unpack(_, y)): estrarre il primo elemento di ciascun elenco secondario e riportare l'elenco risultante in y. yè ora[1 2 3] .

Lunghezza

PODQENaPBs

In pseudocodice, pop(dequeue(enumerate(a.push-back(space)))). La difficoltà qui è che elencare ci dà solo numeri fino a len(a)-1, ma vogliamo len(a). Quindi prima spingiamo uno spazio verso a, allungandolo di un carattere, e poi prendiamo len-1la nuova stringa.

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

Matematica

Ora che abbiamo un modo per prendere la lunghezza delle stringhe, possiamo usare le stringhe per fare moltiplicazione e aggiunta di numeri:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

Il primo fa sXaXbcreare una stringa di a*bspazi e poi ne prende la lunghezza; il secondo fa sXaPBsXbspingere una stringa di bspazi in una stringa di aspazi e poi ne prende la lunghezza.

La parte bella è che tutti gli operatori che stiamo usando qui ( PU, PO, PB, DQ, EN, X) possono essere utilizzati con_ alle espressioni forma di lambda. Quindi possiamo mappare le trasformazioni matematiche all'intervallo inclusivo che abbiamo costruito in precedenza.

Abbiamo anche bisogno di controllare i%2all'interno del ciclo, ma questo è facilmente realizzabile con AND bit a bit: iBA1.

Mettili insieme

Il codice completo, con alcuni spazi bianchi aggiunti:

YENsXaPBs POy Y_MUy              Get \,a into y
F i _MUENsXa                     For i in ,a
 I iBA1                           If i%2=1
  P sPUPODQENsXiXaPBsX_PBs M RVy   Print sPUi*a+_ M RVy
 EI1                              Elseif 1 (using E would cause a parsing problem)
  P sPUPODQENsXiXaPBsX_PBs M y     Print sPUi*a+_ M y

CJam, PCRE, lunghezza 8, incrinato

^[a-~]*$

Esempio di output per 4:

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

CJam, PCRE, lunghezza 9, incrinato

^[a-z~]*$

Esempio di output per 4:

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

Adesso {|}sono anche banditi.

Mathematica, regex lunghezza 11, non competitiva , screpolata

Sapore PCRE:

^[^]@]{49}$

La soluzione corretta sarà una funzione che accetta un numero intero e restituisce l'output come un elenco nidificato come:

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

tinylisp , regex lunghezza 3 ( incrinato )

Puoi testare il codice tinylisp su Provalo online!

Regex (qualsiasi sapore)

\S+

È ora di andare hardcore.

Produzione

La soluzione definisce una funzione che accetta un singolo argomento intero e restituisce un elenco come questo (per n = 4):

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

Il mio codice originale usa la stessa idea di base ideata da Brian McCutchon, costruendo elenchi e valutandoli. Eccolo in una riga:

(v(c(h(q(d)))(c(h(q(d')))(c(c(h(q(q)))(c(c()(c(q(arglist))(c(c(h(q(v)))(c(c(h(q(c)))(c(c(h(q(q)))(q(d)))(q(arglist))))()))())))()))()))))(d'(seq-args(c(h(q(start)))(c(h(q(stop)))(c(h(q(step)))())))))(d'(seq(c(c(h(q(accum)))seq-args)(q((i(e(v(h(q(start))))stop)(c(v(h(q(start))))accum)(seq(c(v(h(q(stop))))accum)start(s(v(h(q(stop))))step)step)))))))(d'(f'(c(c(h(q(index)))(c(h(q(size)))seq-args))(q((i(e(v(h(q(index))))size)()(c(seq()start(v(h(q(stop))))step)(f'(a(h(q(1)))index)size(a(v(h(q(stop))))size)(a(v(h(q(start))))size)(s(h(q(0)))step)))))))))(d'(f(q((size)(f'(h(q(0)))size(h(q(1)))size(h(q(1))))))))

Ho usato il metodo completo costrutti ed eval una volta, per definire una macro d'che rende simili le definizioni d, ma prende i suoi argomenti racchiusi in un elenco: quindi invece di (d x 42), puoi farlo (d'(x 42)). Quindi si trattava solo di riscrivere gli elenchi nelle definizioni che potrebbero aver bisogno di spazi bianchi: (q(a b))-> (c a(q(b)))-> (c(h(q(a)))(q(b))).

Python3, lunghezza 162 (Cracked!)

regex: ^([^"' #]){24}"(?1){11}i%n(?1){4}2\*n-(?1){4}i%n(?1){10}i\/n(\)\/\/1)(?1){5}(?2)(?1){3}2\*\(i%n\)(?1){4}[int()2\/]{16}for i in range\(j,(?1){4}\]\)(?1){6}\"\*n\)$

Ok, lo so, è piuttosto lungo. Fortunatamente, non si spezzerà in meno di una settimana ...: 'D.

Penso di non aver commesso un errore da nessuna parte, che consentirebbe risposte scappatoie.

Formato di output

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

Codice originale:n=int(input());j=0;exec("print([int(i%n+1+(2*n-(2*(i%n)+1))*((((i/n)//1+1)/2)//1)+(2*(i%n)+1)*int(int(i/n)/2))for i in range(j,j+n)]);j+=n;"*n)