Introdução

Você é um criminoso encarregado de roubar alguns planos secretos da nova startup de tecnologia Dejavu. Você entra pela parede dos fundos, mas encontra uma porta que requer um alfinete para abri-la. Você reconhece a marca da fechadura e sabe que é necessário um pino de 5 dígitos usando todos os números de 0 a 4. Após cada dígito digitado, a fechadura verifica os últimos 5 dígitos digitados e abre se o código estiver correto. Você precisa ultrapassar esse bloqueio e rápido.

Superpermutações em poucas palavras

Uma permutação é todas as combinações possíveis de um determinado conjunto de dígitos. por exemplo, todas as permutações dos dígitos 0, 1, 2 são:

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

Se concatenarmos todas essas permutações juntas, obteremos uma superpermutação:

012021102120201210

essa superpermutação contém todas as permutações de 0, 1, 2, mas é possível diminuir uma delas. Vou pular um pouco aqui, mas a superpermutação mais curta desses dígitos é:

012010210

Para nossos propósitos e propósitos, essa é essencialmente a menor seqüência de dígitos que contém todas as permutações possíveis desses dígitos, ou seja, uma superpermutação.

Tarefa

Sua tarefa é um pouco mais difícil que o exemplo da superpermutação, como mostrado acima, porque você tem mais dois dígitos para se preocupar. - Se você não leu sobre superpermutações, ou se meu exemplo acima foi um pouco obscuro, sugiro que você leia este ótimo artigo de Patrick Honner sobre o assunto (esse desafio foi bastante inspirado em seu artigo, então parabéns a ele): https://www.quantamagazine.org/unscrambling-the-hidden-secrets-of-superpermutations-20190116/ . Seu objetivo é escrever o programa mais curto possível que gere uma superpermutação dos dígitos de 0 a 4.

Pontuação

Seu programa não recebe nenhum tipo de entrada e produz uma superpermutação dos dígitos de 0 a 4. Essa superpermutação resultante deve ser impressa no console ou exibida visivelmente ao usuário na extensão fornecida pelo seu idioma de escolha. Isso não precisa ser a permutação mais curta possível, apenas uma superpermutação válida. Por isso, o objetivo é escrever o programa mais curto com a superpermutação mais curta, portanto, você deve calcular sua pontuação da seguinte forma:

tamanho do arquivo (bytes) * comprimento da superpermutação gerada (dígitos)

por exemplo, se eu tivesse um programa de 40 bytes e minha superpermutação tiver 153 dígitos, minha pontuação será:

40 * 153 = 6120

como sempre, o objetivo é obter essa pontuação o mais baixa possível.

Modelo

Aqui está como você deve postar sua resposta:

Idioma | Ponto

link para código no ambiente de trabalho (se possível)

code snippet

explicação de código, etc.

Finalidades

Esta é uma das minhas primeiras perguntas neste site. Então, diga-me se estou perdendo alguma coisa ou se uma seção do meu desafio não está clara. Obrigado e divirta-se jogando golfe!

05AB1E , pontuação = 1673 (7 bytes · 239)

žBœ∊{3ý

Experimente online!

Como funciona

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

Pitão , pontuação = 1944 (9 bytes · 216)

s+R+4d.p4

Experimente online!

Como funciona

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

Brachylog , pontuação = 2907 (19 bytes × 153)

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

É muito lento para ver qualquer coisa, mas se você mudar 4, 2pode testá-lo: Experimente online!

Isso encontra a superpermutação mais curta como tal:

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

Com este sistema de pontuação, há pouco espaço para algo entre 'codificar a supermutação ideal' e 'apenas usar um pequeno built-in para concatenar todas as permutações' , pelo menos em não-esolangs.

Aqui está uma tentativa de qualquer maneira.

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

Experimente online!

Ele gera uma sequência de 325 bytes:

012340124301324013420142301432021340214302314023410241302431031240314203214032410341203421
041230413204213042310431204321102341024310324103421042310432201342014320314203412041320431
210342104330124301423021430241304123042131024310423201432041321044012340132402134023140312
4032141023410324201342031421034301243021431024320143210

Python 2 , Pontuação: 24327 15147 12852 12628 (154 * 82 bytes)

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

Experimente online!

Além disso:

Python 2 , 12628 (154 * 82 bytes)

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

Experimente online!

05AB1E , pontuação: 5355 2160 (216 * 10 bytes )

3ÝœJε4yJ}J

Porto de @AndersKaseorg 's resposta Pyth , por isso certifique-se de upvote-lo!

Experimente online.

Explicação:

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)

Oitava , 27 x 442 = 11934

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

Experimente online!

Acontece que, ingenuamente, gera todas as permutações e, em seguida, trunca para a substring mais curta que ainda é uma superpermutação válida, é mais curta do que gerar a superpermutação mais curta. Infelizmente, desta vez a pontuação não é um palíndromo.

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

Experimente online!

Entrada atualizada para algumas coisas

• a++ não é implementado para números simbólicos.
• contains()não está implementado no Octave. Substituído por any(regexp()).
• No link online, inseri manualmente uma asuperpermutação de 153 comprimentos. Isso permite que a solução seja verificada.

CJam (6 * 240 = 1440)

5e!72>

Demonstração online , validação (gera o índice no qual cada permutação de0..4 pode ser encontrada; ele precisa achatar a saída porque o programa original fornece uma saída adequada para o stdout, mas o que ele coloca na pilha não é diretamente utilizável).

Abordagem roubada da Sanchises , embora a ordem de permutação do CJam seja diferente, fornecendo uma substring diferente.

CJam (22 * 207 = 4554)

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

Demonstração online , validação .

Dissecação

Isso usa uma construção recursiva simples.

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

Geléia , 3000 (600 * 5 bytes)

5ḶŒ!F

Experimente online!

Carvão , 29 bytes, comprimento de saída 153, pontuação 4437

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

Experimente online! Link é a versão detalhada do código. Explicação: Como o @TFeld, eu apenas imprimo metade de uma superpermutação e espelho. Eu calculei a superpermutação usando o seguinte código:

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

Isso se traduz em um programa de 45 bytes em carvão, de modo que teria marcado 6885.

MATL , 16 x 442 = 7072

4Y25:Y@!)K442&:)

Experimente online!

Porta MATL da minha resposta Octave. -442 agradecimentos a Luis Mendo

Japt -P, 2376 (11 x 216)

4o ¬á Ë+4+D

Tente!

-1 byte graças a @ Shaggy!

Porto de Anders Kaseorg é resposta Pyth .

Perl 6 , 7191 (153 * 47 bytes)

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

Experimente online!

Localiza o primeiro número que contém todas as permutações dos dígitos de 0 a 4. Isso levará muito tempo para ser executado, mas você pode testá-lo com as duas primeiras permutações 0e0,1

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

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

Experimente online!