introduzione

Sei un criminale incaricato di rubare alcuni piani segreti dalla nuova startup tecnologica Dejavu. Ti intrufoli sopra la parete posteriore, ma trovi una porta che richiede un perno per aprirla. Riconosci la marca del lucchetto e sai che ci vuole un pin di 5 cifre usando tutti i numeri da 0 a 4. Dopo ogni cifra inserita, il lucchetto controlla le ultime 5 cifre inserite e si apre se il codice è corretto. Devi superare questo blocco e in fretta.

Superpermutazioni in breve

Una permutazione è tutte le possibili combinazioni di un determinato insieme di cifre. ad esempio, tutte le permutazioni delle cifre 0, 1, 2 sono:

012, 021, 102, 120, 201 e 210.

Se concateniamo tutte queste permutazioni insieme, otteniamo una supermutazione:

012021102120201210

questa superpermutazione contiene tutte le permutazioni di 0, 1, 2, ma è possibile accorciarne una. Salterò un po 'qui, ma il superpermutazione più breve di queste cifre è:

012010210

Per i nostri intenti e scopi, questa è essenzialmente la stringa di cifre più corta che contiene tutte le possibili permutazioni di quelle cifre, ovvero una supermutazione.

Compito

Il tuo compito è un po 'più difficile dell'esempio di supermutazione come mostrato sopra, perché hai altre due cifre di cui preoccuparti. - Se non hai letto delle superpermutazioni, o il mio esempio sopra è stato un po 'poco chiaro, ti consiglio vivamente di leggere questo fantastico articolo di Patrick Honner sull'argomento (questa sfida è stata fortemente ispirata dal suo articolo, quindi complimenti a lui): https://www.quantamagazine.org/unscrambling-the-hidden-secrets-of-superpermutations-20190116/ . Il tuo obiettivo è scrivere il programma più breve possibile che generi una superpermutazione delle cifre da 0 a 4.

punteggio

Il tuo programma non accetta alcun input di alcun tipo e produce una supermutazione delle cifre da 0 a 4. Questa supermutazione risultante deve essere stampata sulla console o visibilmente mostrata all'utente nella misura fornita dalla tua lingua preferita. Questa non deve essere la permutazione più breve possibile, deve solo essere una superpotutazione valida. Per questo motivo, l'obiettivo è quello di scrivere il programma più breve con la superpermutazione più breve, quindi dovresti calcolare il tuo punteggio in questo modo:

dimensione del file (byte) * lunghezza della supermutazione generata (cifre)

ad esempio, se avessi un programma da 40 byte e la mia superpermutazione fosse lunga 153 cifre, il mio punteggio sarà:

40 * 153 = 6120

come sempre, l'obiettivo è ottenere questo punteggio il più basso possibile.

Modello

Ecco come pubblicare la risposta:

Lingua | Punto

collegamento al codice nell'ambiente di lavoro (se possibile)

code snippet

spiegazione del codice, ecc.

finalità

Questa è una delle mie prime domande su questo sito. Quindi per favore dimmi se mi manca qualcosa o una sezione della mia sfida non è chiara. Grazie e buon divertimento!

05AB1E , punteggio = 1673 (7 byte · 239)

žBœ∊{3ý

Provalo online!

Come funziona

žB          push 1024
  œ         permutations: ["1024", "1042", …, "4201"]
   ∊        vertically mirror: ["1024", "1042", …, "4201", "4201", …, "1042", "1024"]
    {       sort: ["0124", "0124", "0142", "0142", …, "4210", "4210"]
     3      push 3
      ý     join: "01243012430142301423…3421034210"

Pyth , punteggio = 1944 (9 byte · 216)

s+R+4d.p4

Provalo online!

Come funziona

 +R   .p4   append to each permutation d of [0, 1, 2, 3]:
   +4d        [4] + d
s           concatenate

Brachylog , punteggio = 2907 (19 byte × 153)

4⟦pᶠP∧~l.g;Pz{sᵈ}ᵐ∧

Troppo lento per vedere qualcosa, ma se cambi 4da 2puoi provarlo: provalo online!

Questo trova la supermutazione più breve in quanto tale:

4⟦                   The range [0,1,2,3,4]
  pᶠP                P is the list of all permutations of this range
     ∧
      ~l.            Try increasing lengths for the output
         g;Pz        Zip the output with P
             {sᵈ}ᵐ   For each permutation, it must be a substring of the output
                  ∧

JavaScript (ES6), 26975 (325 * 83 byte)

Con questo sistema di punteggio, c'è poco spazio tra "hardcode the supermutazione ottimale" e "basta usare un breve built-in per concatenare tutte le permutazioni" , almeno nei non-esolang.

Ecco comunque un tentativo.

f=(a=[0,1,2,3,4],p=r='')=>a.map((v,i)=>f(a.filter(_=>i--),p+v))|~r.search(p)?r:r+=p

Provalo online!

Genera una stringa di 325 byte:

012340124301324013420142301432021340214302314023410241302431031240314203214032410341203421
041230413204213042310431204321102341024310324103421042310432201342014320314203412041320431
210342104330124301423021430241304123042131024310423201432041321044012340132402134023140312
4032141023410324201342031421034301243021431024320143210

Python 2 , Punteggio: 24327 15147 12852 12628 (154 * 82 byte)

S=str(int('OH97GKT83A0GJRVO309F4SGSRWD0S2T292S1JBPVKJ6CRUY8O',36))
print S+S[::-1]

Provalo online!

Anche:

Python 2 , 12628 (154 * 82 byte)

S=oct(int('FS02C3XQJX14OTVMGM70CGCPWU41MNJZ0CO37ZMU0A0Y',36))[:-1]
print S+S[::-1]

Provalo online!

05AB1E , punteggio: 5355 2160 (216 * 10 byte )

3ÝœJε4yJ}J

Porto di @AndersKaseorg 's risposta Pyth , quindi assicuratevi di upvote lui!

Provalo online.

Spiegazione:

3Ý           # Push a list in the range [0,3]: [0,1,2,3]
  œ          # Get all possible permutations of this list
   J         # Join each inner list together to a single string
    ε        # Map each string `y` to:
             #  (Push string `y` implicitly)
     4       #  Push 4
      y      #  Push string `y` again
       J     #  Join all three together
        }J   # After the map: Join all strings together to a single string
             # (and output it implicitly as result)

Ottava , 27 x 442 = 11934

'01234'(perms(1:5)'(4:445))

Provalo online!

Quindi, risulta, generare ingenuamente tutte le permutazioni e poi troncare alla sottostringa più corta che è ancora una superpermutazione valida è più breve di generare la superpermutazione più breve. Purtroppo, questa volta il punteggio non è un palindromo.

Ottava , 97 x 153 = 14841

a=sym(9);while i<120
i=0;a+=1;q='01234';for t=q(perms(1:5))'
i+=any(regexp(char(a),t'));end
end
a

Provalo online!

Voce aggiornata per alcune cose

• a++ non è implementato per i numeri simbolici.
• contains()non è implementato in Octave. Sostituito con any(regexp()).
• Nel collegamento online, ho inserito manualmente un valore amolto vicino alla super-valutazione di 153 lunghezze. Ciò consente di verificare la soluzione.

CJam (6 * 240 = 1440)

5e!72>

Demo online , convalida (genera l'indice in corrispondenza del quale è 0..4possibile trovare ciascuna permutazione ; deve appiattire l'output perché il programma originale fornisce l'output adatto allo stdout ma ciò che posiziona nello stack non è direttamente utilizzabile).

Approccio rubato da Sanchises , sebbene l'ordine di permutazione di CJam sia diverso, dando una diversa sottostringa.

CJam (22 * 207 = 4554)

0a4{)W@+W+1$)ew\a*W-}/

Demo online , validazione .

Dissezione

Questo utilizza una semplice costruzione ricorsiva.

0a       e# Start with a superpermutation of one element, [0]
4{       e# for x = 0 to 3:
  )      e#   increment it: n = x+1
  W@+W+  e#   wrap the smaller superpermutation in [-1 ... -1]
  1$)ew  e#   split into chunks of length n+1
  \a*    e#   insert an n between each chunk
  W-     e#   remove the -1s from the ends
}/

Jelly , 3000 (600 * 5 byte)

5ḶŒ!F

Provalo online!

Carbone , 29 byte, lunghezza uscita 153, punteggio 4437

”)⊞⧴�r3⁼Ｈ⁴↓¦σ✳ＬïpＷＳ [Ｔ↑ZωÞ”‖Ｏ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione: Come @TFeld, stampo solo metà di una supermutazione e la rispondo. Ho calcolato la superpermutazione utilizzando il seguente codice:

Push(u, w);
for (u) {
    Assign(Plus(Plus(i, Length(i)), i), h);
    Assign(Ternary(i, Join(Split(w, i), h), h), w);
    Assign(Incremented(Length(i)), z);
    if (Less(z, 5)) for (z) Push(u, Slice(h, k, Plus(k, z));
}
Print(w);

Questo si traduce in un programma a 45 byte in Charcoal, quindi avrebbe segnato 6885.

MATL , 16 x 442 = 7072

4Y25:Y@!)K442&:)

Provalo online!

Porta MATL della mia risposta Octave. -442 grazie a Luis Mendo

Japt -P, 2376 (11 x 216)

4o ¬á Ë+4+D

Provalo!

-1 byte grazie a @ Shaggy!

La risposta Pyth di Port of Anders Kaseorg .

Perl 6 , 7191 (153 * 47 byte)

say first *.comb(permutations(5).all.join),0..*

Provalo online!

Trova il primo numero che contiene tutte le permutazioni delle cifre da 0 a 4. Questo richiederà molto tempo per essere eseguito, ma puoi testarlo con le prime due permutazioni 0e0,1

Wolfram Language (Mathematica) , 153 * 95 byte, 14535

Nest[Flatten[Join[#,{Max@#+1},#]&/@Partition[#,Max@#+1,1]]//.{b__,a__,a__,c__}:>{b,a,c}&,{0},4]

Provalo online!