40 números em 9 bytes


40

Existem 40 maneiras pelas quais um caminho hamiltoniano direcionado pode ser organizado em uma grade 3 × 3:
todos os 20 caminhos Hamiltonianos não direcionados de um 3 & times3;  grade
Este gráfico ( graças ao Sp3000! ) Mostra apenas os 20 caminhos não direcionados. Percorra cada linha colorida nas duas direções para os 40 caminhos direcionados.

Desafio

Usando apenas ASCII imprimível , escreva uma grade 3 x 3 de caracteres, como:

ABC
DEF
GHI

Quando cada um dos 40 caminhos direcionados é lido nesta grade como 40 programas de linha única e 9 caracteres, o objetivo é fazer com que cada programa produza um número inteiro único de 1 a 40. Fazer isso para todos os 40 caminhos parece difícil e improvável, portanto, você só precisa fazê-lo funcionar para o maior número possível de caminhos.

A submissão cujos 40 programas de caminho produzirem os números mais distintos de 1 a 40 será o vencedor. O desempatador vai para a finalização anterior.

Os programas de caminho que erro ou não produzem um número inteiro de 1 a 40 ou produzem um número inteiro que outro programa de caminho já coberto não é contado. Especificamente:

  • Os programas que apresentam erros ao compilar, executar ou sair não são contados. Os avisos estão ok.
  • Programas que não produzem um número inteiro de 1 a 40 ou produzem algo ligeiramente malformado, como -35ou 35 36não são contados.
  • Programas que requerem entrada do usuário para produzir a saída não são contados.
  • Programas que nunca terminam não são contados.
  • A partir de agora , os programas que não são determinísticos não são contados.
  • Caso contrário, os programas válidos que produzem um número inteiro de 1 a 40 que outro programa válido já produziu não são contados. (O primeiro programa é contado.)
  • Somente os programas que geram representações inteiras de números de 1 a 40 (inclusive) são contados no total. Os números são esperados para estar no costume 1, 2, ..., 39, 40formato, a menos que não é a norma para o seu idioma. (Uma nova linha à direita na saída está correta.)
  • Quais são os números de saída dos programas e em que ordem eles estão, não importa. Somente o número de números inteiros distintos de programas válidos é importante.

Todos os programas de caminho devem ser executados no mesmo idioma. No entanto, os "programas" podem de fato ser funções (sem argumentos necessários) ou comandos REPL , além de programas completos, que imprimem ou retornam seu número inteiro de destino. Você pode misturar e combinar entre funções, comandos REPL e programas completos.

Seus 9 caracteres ASCII imprimíveis não precisam ser distintos.

Exemplo

Se sua grade 3 × 3 fosse

ABC
DEF
GHI

e seus 40 programas e saídas ficaram assim

ABCFEDGHI -> 26
ABCFIHEDG -> 90
ABCFIHGDE -> 2
ABEDGHIFC -> syntax error
ADEBCFIHG -> prints 40 but then errors
ADGHEBCFI -> 6
ADGHIFCBE -> 6
ADGHIFEBC -> 6
CBADEFIHG -> runtime error
CBADGHEFI -> 3
CBADGHIFE -> 4
CFEBADGHI -> -32
CFIHEBADG -> 38.0
CFIHGDABE -> "36"
EDABCFIHG -> 33
EFCBADGHI -> no output
EHGDABCFI -> compilation error
EHIFCBADG -> 8
GDABCFEHI -> 22
GHEDABCFI -> 41
IHGDEFCBA -> 0
GDEHIFCBA -> '9'
EDGHIFCBA -> +10
CFIHGDEBA -> 11
GHIFCBEDA -> error
IFCBEHGDA -> error
EBCFIHGDA -> prints 23 but then loops infinitely
CBEFIHGDA -> randomly prints either 24 or 44
GHIFEDABC -> error
IFEHGDABC -> 30
EFIHGDABC -> 39
IHGDABEFC -> 7
GDABEHIFC -> 29
EBADGHIFC -> -1
GHIFCBADE -> 26
IHGDABCFE -> 1
IFCBADGHE -> error
GDABCFIHE -> no output
IHEFCBADG -> no output
IFCBADEHG -> "quack"

sua pontuação seria 14, porque existem 14 números inteiros distintos de 1 a 40, válidos 26 2 6 3 4 33 8 22 11 30 39 7 29 1.


14
-1, desafio não contém qualquer referência à bandeiras
Alex A.

@ Sp3000 O arranjo na imagem está em uma ordem específica? (Suponho que, para o desafio, a encomenda não seja importante, mas estou morrendo de curiosidade sobre a imagem. Particularmente, se elas foram usadas como sementes em um sistema L para uma curva espacial de Hilbert, existe uma codificação natural para a imagem? ()?
luser droog 12/07/2015

@luserdroog Bem, Sp fez a imagem , melhor perguntar a ele.
22715 Calvin's Hobbies

@luserdroog Se você contar as células de 1 a 9, eles devem estar em ordem lexicográfica, por exemplo, o primeiro é123654789
SP3000

@luserdroog (isto é, escolher o lexicographically-anteriormente representante de cada par de caminhos dirigidos, e em seguida, classificar esses 20 representantes lexicographically.)
mathmandan

Respostas:


27

PARI / GP - 24

1%1
 8
2+3

PARI / GP ignora espaços entre dígitos, para que 1 8 2, por exemplo, seja tratado como 182. O mesmo poderia funcionar para perl, substituindo os espaços por sublinhados. Não esgotei todo o espaço de pesquisa, portanto, pode haver melhores candidatos.

Um programa pode ser alimentado para o gp como gp -q -f program.gp, ou interativamente, no repl.


Saída

1%1 8 2+3 -> 4
1%1 3+8 2 -> 83 # invalid
1%1 3+2 8 -> 29
1%8 2+3 1 -> 32
1 8%1 3+2 -> 7
1 2+8%1 3 -> 20
1 2+3 1%8 -> 19
1 2+3 8%1 -> 12
1%1 8 3+2 -> 3
1%1 2+8 3 -> 84 # invalid
1%1 2+3 8 -> 39
1 8%1 2+3 -> 9
1 3+8%1 2 -> 21
1 3+2 1%8 -> 18
8 1%1 3+2 -> 5
8 1%1 2+3 -> 12 # dup
8+2 1%1 3 -> 16
8+3 1%1 2 -> 15
2 1%1 8+3 -> 6
2+8 1%1 3 -> 5  # dup
3+2 8 1%1 -> 3  # dup
2 8+3 1%1 -> 28
8 2+3 1%1 -> 82 # invalid
1 3+2 8%1 -> 13
2+3 1%8 1 -> 33
3 1%8+2 1 -> 28 # dup
8%1 3+2 1 -> 29 # dup
1%8 3+2 1 -> 22
2+3 8 1%1 -> 2
3 8+2 1%1 -> 38
8 3+2 1%1 -> 83 # invalid
3+2 1%8 1 -> 24
2 1%8+3 1 -> 36
8%1 2+3 1 -> 39 # dup
2+3 1%1 8 -> 15 # dup
3+2 1%1 8 -> 6  # dup
3 1%1 2+8 -> 15 # dup
2 1%1 3+8 -> 16 # dup
3+8 1%1 2 -> 12 # dup
3 1%1 8+2 -> 15 # dup

Todos os valores, com exceção de 4, estão dentro do intervalo necessário, com 12 entradas duplicadas.


Atualizar

Eu terminei o processamento, existem seis 23s distintos e apenas um 24 (conforme lido pelas linhas):

23 1%1 6 2+3 [2, 3, 4, 5, 7, 8, 11, 12, 13, 14, 16, 17, 18, 19, 22, 24, 26, 27, 32, 33, 34, 36, 37]
23 1 2%3+2*8 [2, 5, 7, 8, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20, 22, 23, 25, 26, 29, 31, 32, 37, 40]
23 2 3%1+8 2 [2, 4, 6, 7, 10, 11, 12, 13, 14, 15, 16, 20, 21, 23, 24, 28, 29, 30, 31, 32, 33, 34, 40]
23 4%6%5*7+6 [2, 4, 5, 6, 7, 8, 9, 12, 13, 19, 21, 23, 24, 26, 29, 31, 32, 33, 34, 37, 38, 39, 40]
23 5%6%4*7+6 [2, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 25, 26, 29, 31, 33, 34, 37, 38, 39, 40]
23 5%6%4*8+6 [1, 3, 5, 6, 8, 9, 10, 12, 14, 15, 18, 22, 24, 25, 27, 29, 30, 32, 34, 36, 37, 39, 40]

24 1%1 8 2+3 [2, 3, 4, 5, 6, 7, 9, 12, 13, 15, 16, 18, 19, 20, 21, 22, 24, 28, 29, 32, 33, 36, 38, 39]

O programa que eu usei para triturar está abaixo. O PARI / GP possui recursos limitados de processamento de strings; portanto, lide principalmente com matrizes de char (aka Vecsmall). Os operadores são testadas +, -, *, \(div andar), %, ;(separador de expressão, essencialmente devoluções tudo antes), e (espaço, tal como descrito acima). O operador expoente ^também pode ser adicionado, mas torna-se muito lento para testar exaustivamente.

perms = {[
  [1, 2, 3, 6, 5, 4, 7, 8, 9], [1, 2, 3, 6, 9, 8, 5, 4, 7], [1, 2, 3, 6, 9, 8, 7, 4, 5], [1, 2, 5, 4, 7, 8, 9, 6, 3],
  [1, 4, 5, 2, 3, 6, 9, 8, 7], [1, 4, 7, 8, 5, 2, 3, 6, 9], [1, 4, 7, 8, 9, 6, 3, 2, 5], [1, 4, 7, 8, 9, 6, 5, 2, 3],
  [3, 2, 1, 4, 5, 6, 9, 8, 7], [3, 2, 1, 4, 7, 8, 5, 6, 9], [3, 2, 1, 4, 7, 8, 9, 6, 5], [3, 6, 5, 2, 1, 4, 7, 8, 9],
  [3, 6, 9, 8, 5, 2, 1, 4, 7], [3, 6, 9, 8, 7, 4, 1, 2, 5], [5, 4, 1, 2, 3, 6, 9, 8, 7], [5, 6, 3, 2, 1, 4, 7, 8, 9],
  [5, 8, 7, 4, 1, 2, 3, 6, 9], [5, 8, 9, 6, 3, 2, 1, 4, 7], [7, 4, 1, 2, 3, 6, 5, 8, 9], [7, 8, 5, 4, 1, 2, 3, 6, 9],
  [9, 8, 7, 4, 5, 6, 3, 2, 1], [7, 4, 5, 8, 9, 6, 3, 2, 1], [5, 4, 7, 8, 9, 6, 3, 2, 1], [3, 6, 9, 8, 7, 4, 5, 2, 1],
  [7, 8, 9, 6, 3, 2, 5, 4, 1], [9, 6, 3, 2, 5, 8, 7, 4, 1], [5, 2, 3, 6, 9, 8, 7, 4, 1], [3, 2, 5, 6, 9, 8, 7, 4, 1],
  [7, 8, 9, 6, 5, 4, 1, 2, 3], [9, 6, 5, 8, 7, 4, 1, 2, 3], [5, 6, 9, 8, 7, 4, 1, 2, 3], [9, 8, 7, 4, 1, 2, 5, 6, 3],
  [7, 4, 1, 2, 5, 8, 9, 6, 3], [5, 2, 1, 4, 7, 8, 9, 6, 3], [7, 8, 9, 6, 3, 2, 1, 4, 5], [9, 8, 7, 4, 1, 2, 3, 6, 5],
  [9, 6, 3, 2, 1, 4, 7, 8, 5], [7, 4, 1, 2, 3, 6, 9, 8, 5], [9, 8, 5, 6, 3, 2, 1, 4, 7], [9, 6, 3, 2, 1, 4, 5, 8, 7]
]}

ops = Vecsmall("+-*\\%; ")

ms = 1

for(c = 48, 57, {
 for(d = c, 57,
  for(f = d, 57,
   for(g = c, 57,
    for(e = 48, 57,
     print1(Strchr([c,d,e,f,g,13]));
     for(h = 1, #ops,
      for(i = 1, #ops,
       for(j = 1, #ops,
        for(k = 1, #ops,
         a = Vecsmall([c, ops[h], d, ops[i], e, ops[j], f, ops[k], g]);
         s = Set();
         for(m = 1, #perms,
          v = Strchr(vecextract(a, perms[m]));
          iferr(b = eval(v), E, b = 0);
          if(b >= 1 && b <= 40, s = setunion(s, [b]))
         );
         if(#s >= ms, ms = min(23, #s); print(#s, " ", Strchr(a), " ", s));
        )
       )
      )
     )
    )
   )
  )
 )
})

Infelizmente, um programa Perl não gera seu último valor. Uma sub-rotina Perl faz, mas uma sub-rotina tem chaves. ( "A assinatura faz parte do corpo de uma sub-rotina. Normalmente, o corpo de uma sub-rotina é simplesmente um bloco de código." ) Portanto, não acho que isso seja possível no Perl.
Msh210

29

Peixe morto , 18

Este foi realmente o primeiro idioma que tentei antes de considerar os operadores de infix. Estou publicando agora pela pura hilaridade da idéia de que Deadfish poderia ser útil para alguma coisa.

iii
ios
sii

Para quem não conhece Deadfish, ié incrementado, sé quadrado e oé produzido, com o acumulador começando em 0 (também há uma quarta instrução dpara decremento não usada aqui). O fato de não termos impressão automática e precisamos usar oé uma grande desvantagem, mas surpreendentemente o Deadfish não é muito ruim aqui, considerando todas as coisas. Acontece que o posicionamento ideal do operador de saída está no meio.

iiisoisii 9
iiisiiois 11
iiisiisio 122
iioisiisi 2
iioiisiis 2
iisioiisi 5
iisiisiio 38
iisiisoii 36
iiiiosiis 4
iiiisiosi 17
iiiisiiso 324
isoiiisii 1
isiioiiis 3
isiisiiio 12
oiiiisiis 0
osiiiisii 0
oisiiiisi 0
oiisiiiis 0
siiiisoii 16
sioiiiisi 1
iisiosiii 5
sioiisiii 1
oisiisiii 0
isiisioii 10
siisiioii 6
isiioisii 3
oiisiisii 0
iiosiisii 2
siisoiiii 4
isoisiiii 1
osiisiiii 0
iisiiiosi 7
siiioiisi 3
oiiisiisi 0
siisiiiio 8
iisiiiiso 64
isiiiisio 26
siiiisiio 18
iiosiiiis 2
isiiiiois 5

25

Python REPL e muito mais, 22 23

6+7
*5%
6%4

Observação principal: Se você colorir a grade como um tabuleiro de damas, o caminho alterna as cores da grade à medida que avança e inicia e termina na mesma cor.

Ainda força bruta para melhor. Tentar com +*%(e mesmo **para idiomas onde a ^exponenciação) não resultou em nada melhor, infelizmente. Também tentei usar operadores bit a bit e apenas ^(xor) pareceu ajudar um pouco, mas a pesquisa estava demorando muito, então eu desisti.

6+7%5*6%4 6
6+7%4%5*6 24
6+7%4%6*5 21
6+5*6%4%7 8
6*5+7%4%6 33
6*6%5+7%4 4
6*6%4%7+5 5
6*6%4%5+7 7
7+6*5%4%6 9
7+6*6%5%4 8
7+6*6%4%5 7
7%5+6*6%4 2
7%4%5+6*6 39
7%4%6*6+5 23
5*6+7%4%6 33
5%7+6*6%4 5
5%6*6+7%4 33
5%4%7+6*6 37
6*6+7%5%4 38
6%5*6+7%4 9
4%6*5%7+6 12
6*5%4%7+6 8
5*6%4%7+6 8
7%4%6*5+6 21
6%4%7+5*6 32
4%7+5%6*6 34
5+7%4%6*6 23
7+5%4%6*6 13
6%4%5*6+7 19
4%5%6*6+7 31
5%4%6*6+7 13
4%6*6+5%7 29
6*6+5%4%7 37
5+6*6%4%7 5
6%4%7+6*5 32
4%6*6+7%5 26
4%7+6*6%5 5
6*6+7%4%5 39
4%5%7+6*6 40
4%7+6*5%6 4

5
Próxima tarefa: Escreva um programa que gere o programa com os valores mais exclusivos. Depois golf esse programa. :)
Reto Koradi 08/07

@RetoKoradi A primeira parte foi o que eu fiz. O segundo ... mais tarde: P
Sp3000

@ Sp3000 Eu terminei a força bruta desse estilo de solução. Há 6+7*5%6%4, 6+7*4%6%5e 6+8*4%6%5(esquerda para a direita, de cima para baixo), e nada mais.
Isaacg

11
@isaacg há mais soluções de 23 pontos se você jogar em mais alguns operadores, como & | ^
Sparr

Apenas um pensamento aleatório: você já tentou permitir +e -nos cantos / centro? Como são operadores unários e binários, isso ainda deve resultar em todas as expressões válidas. É improvável que isso resulte em uma solução melhor, mas pelo menos expande o espaço de pesquisa. Hmm, na verdade, pode ser um problema, porque você pode acabar com sequências de operadores.
Reto Koradi

13

J, 15

2 + 1
* 3 *
2 + 3

Isso gera apenas números válidos, mas muitos são duplicados. Os valores únicos são 17 11 16 28 31 23 13 10 21 33 18 24 22 29 27. Definitivamente, você pode fazer melhor alterando operadores e números inteiros envolvidos.

2+1*3*2+3 -> 17
2+1*3+3*2 -> 11
2+1*3+2*3 -> 11
2+3*2+3*1 -> 17
2*3+1*3+2 -> 16
2*2+3+1*3 -> 16
2*2+3*1+3 -> 28
2*2+3*3+1 -> 28
1+2*3*3+2 -> 31
1+2*2+3*3 -> 23
1+2*2+3*3 -> 23
1*3+2*2+3 -> 13
1*3+3+2*2 -> 10
1*3+2*2+3 -> 13
3*2+1*3+2 -> 21
3*1+2*2+3 -> 33
3+2*2+1*3 -> 13
3+3*1+2*2 -> 18
2*2+1*3+3 -> 16
2+3*2+1*3 -> 17
3+2*3*1+2 -> 21
2*3+3*1+2 -> 24
3*2+3*1+2 -> 33
1*3+2*3+2 -> 13
2+3*1+3*2 -> 23
3*1+3+2*2 -> 24
3+1*3+2*2 -> 10
1+3*3+2*2 -> 22
2+3*3*2+1 -> 29
3*3+2*2+1 -> 27
3*3+2*2+1 -> 27
3+2*2+3*1 -> 13
2*2+3+3*1 -> 16
3+2*2+3*1 -> 13
2+3*1+2*3 -> 23
3+2*2+1*3 -> 13
3*1+2*2+3 -> 33
2*2+1*3+3 -> 16
3+3*1+2*2 -> 18
3*1+2*3+2 -> 33

By the way, parabéns por atingir 1k rep! :)
Alex A.

@AlexA. Atingir 1k em uma resposta J, depois de nada além de respostas Prolog. Infiel ...
Fatalize

8
Tudo bem, tenho certeza que o Prolog vai entender.
8285 Alex A.

3
@AlexA. Yes.
John Dvorak

@JanDvorak Você está falando em nome da Prolog?
10289 Alex A.

11

> <>, 36 *

Se você tiver sorte o suficiente!

x;x
lxl
xnx

Como o desafio não exige que o código seja determinístico, precisamos apenas provar que é possível (mesmo que improvável) retornar 36 números e estamos prontos. Foi bom enquanto durou, eu acho.

(Para aqueles que não estão familiarizados com> <>, uma ótima introdução pode ser encontrada aqui )

> <> é uma linguagem 2D baseada em pilha. Isso significa que as instruções não são executadas linearmente como a maioria das linguagens tradicionais - o fluxo do programa pode ser superior, inferior, esquerdo ou direito!

Decidi usar a instrução "x" em> <>, que altera a direção dos ponteiros das instruções para cima, baixo, esquerda ou direita aleatoriamente. Como nosso código será apenas uma linha, isso significa que só podemos olhar para os casos quando ele for para a direita ou para a esquerda, pois se o ponteiro for para cima ou para baixo, ele apenas apertará a instrução "x" novamente.

A instrução "n" exibe o número na parte superior da pilha e o imprime. No entanto, se a pilha estiver vazia e não houver nada para aparecer, um erro será gerado.

A instrução "l" simplesmente empurra o comprimento da pilha para a pilha (e, para nossa sorte, ela não envia um erro se a pilha estiver vazia); portanto, por exemplo, se a pilha estiver vazia e "l" for chamado, ele colocaria 0 na pilha. Se agora chamarmos novamente "l", como a pilha possui um elemento (0), ela enviará 1 para o topo da pilha e agora isso significaria que haveria duas coisas na pilha e isso significaria que se formos chamar "l" novamente, colocaremos 2 na pilha, etc. Assim, podemos usar "l" para inserir um número arbitrário na pilha através do método mostrado anteriormente.

O ";" instrução termina o programa.

A idéia de usar "x" é que, por exemplo, se houver apenas um "x" no código (onde A, B, C, D são algumas instruções):

ABCx;D

O programa executaria A, então B e C, e, ao atingir "x", teríamos duas possibilidades: o código continuava indo para a direita e pressionava o ";" e sai ou vai para a esquerda e executa C, em seguida, B, em seguida, A, em seguida, D e só então sai. Portanto, se nosso código contiver um "x", o programa obterá dois fluxos possíveis de programas, dos quais podemos escolher o programa mais adequado.

Se houver dois ou mais "x" es, obteremos um número infinito de possíveis fluxos de programas.

Nosso código possui cinco "x" es, além disso, cada um deles está em uma "célula inicial" dos caminhos hamiltonianos, o que significa que todo programa começará com um "x" e todo programa terá a estrutura:

xAxBxCxDx

Onde A, B, C, D pertencem a {; , n, l, l} Isso significa que existem apenas 12 programas exclusivos. Além disso, como sempre começamos com um "x", podemos analisar o caso quando o programa for deixado, portanto, programas simétricos também podem ser considerados iguais. Até simetria, existem apenas 6 programas possíveis diferentes. Apenas 4 deles ocorrem nos programas gerados como caminhos hamiltonianos:

xnxlxlx;x
xlxnxlx;x
xnxlx;xlx
xlxnx;xlx

Vejamos o primeiro programa "xnxlxlx; x" se dermos certo no primeiro passo, apertarmos o comando de impressão, o que gerará um erro, pois não temos nada na pilha. Se formos para a esquerda, pressionamos o comando final do programa. Portanto, não podemos produzir nenhum número desses programas.

O segundo programa, "xlxnxlx; x", é muito mais esperançoso, pois, ao irmos para a direita no início, um zero é colocado na pilha; se formos para a esquerda no próximo "x", nossa pilha ganha um, indo para a direita novamente, temos um 2 que podemos imprimir e continuar indo para o final do programa. Podemos observar que, na verdade, podemos imprimir qualquer número par , pois na parte "xlx", no início, podemos atingir um tamanho arbitrário, indo para a direita, para a esquerda e para a direita novamente, um certo número de vezes.

Da mesma forma, pode-se ver que o terceiro programa xnxlx; xlx pode gerar qualquer número ímpar , indo para a esquerda no início e depois repetindo a rotina "xlx" somente desta vez indo para a esquerda, direita e esquerda.

E o quarto programa é essencialmente o mesmo que o segundo programa e pode gerar qualquer número par .

Portanto, para os programas necessários, temos:

x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
x;xlxlxnx (none)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xlx;xlxnx (any odd number)
xlxnx;xlx (any even number)
xlxnxlx;x (any even number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
x;xlxnxlx (any even number)
xnxlxlx;x (none)
xlxnxlx;x (any even number)
xlxnxlx;x (any even number)
xnxlx;xlx (any odd number)
xlx;xnxlx (any even number)
x;xlxnxlx (any even number)
xnxlx;xlx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)
xlx;xlxnx (any odd number)
xnxlx;xlx (any odd number)
xlx;xlxnx (any odd number)

São 4 programas que não podem emitir números, 20 que podem gerar qualquer número par, 16 que podem gerar qualquer número ímpar. Como existem exatamente 20 números pares e pelo menos 16 números ímpares no intervalo de 1 a 40, com uma certa probabilidade, existe a possibilidade de haver 36 números diferentes no intervalo de 1 a 40 emitidos por esse bloco de código.


11
36 sente terrivelmente subóptimos para uma resposta que é efetivamente abuso brecha
SP3000

Às vezes, eu gostaria que o peixe tivesse uma instrução para "imprimir a última coisa na pilha e sair" que seria de grande ajuda. Eu poderia ter uma resposta brecha totalmente ideal em breve, no entanto
cirpis

Eu sinceramente esqueci de adicionar uma regra sobre não contar programas não determinísticos. Eu adicionei agora. Você pode continuar com isso porque é inteligente e bem explicado, mas não aceitarei esta resposta.
22715 Calvin's Hobbies

11
Certamente, essa resposta não pretendia ser uma resposta competitiva de qualquer maneira, foi mais uma reação instintiva quando eu estava lendo esse desafio e pensei em ter uma resposta de peixe.
cirpis

9

GolfScript, 8

192
6#7
281

Atualmente, a solução com maior pontuação. : P Foi legal enquanto durou.

Programas

1927#6281 1927
192718#62 192718
19271826# 19271826
19#628172 19
16#927182 16
1628#9271 1628
16281729# 16281729
162817#92 162817
2916#7182 2916
291628#71 291628
29162817# 29162817
27#916281 27
2718#9162 2718
27182619# 27182619
#61927182 
#72916281 
#82619271 
#81729162 
261927#81 261927
28#619271 28
1826#7291 1826
26#817291 26
#62817291 
271826#91 271826
281729#61 281729
1729#8261 1729
#92718261 
29#718261 29
2817#6192 2817
17#826192 17
#71826192 
182619#72 182619
2619#8172 2619
#91628172 
28172916# 28172916
18261927# 18261927
17291628# 17291628
26192718# 26192718
18#729162 18
172916#82 172916

11
enquanto durou ... por 30 minutos ..
Optimizer

2
O melhor que pude encontrar para o GolfScript é 0)1#2#3(415 anos. Simetria bonita também.
Primo

11
@primo: Isso é inteligente. Não achei que mais comentários realmente melhorassem a pontuação.
1013 Dennis

8

CJam, 14

3(4
;];
0)1

Abaixo os programas de trabalho:

3(4;];0)1 = 11
3(4;1)0;] = 22
3(];0)1;4 = 14
3;0)](4;1 = 11
3;0)1;4(] = 13
3;0)1;](4 = 14
4(3;];1)0 = 20
4(3;0)];1 = 1
4(3;0)1;] = 31
4;1)](3;0 = 20
4;1)0;3(] = 22
0;3(4;])1 = 21
0)];3(4;1 = 21
1)0;];4(3 = 33
4;1)0;](3 = 23
0)1;4(];3 = 3
1;4(])0;3 = 33
4(];1)0;3 = 23
0)1;];3(4 = 24
1)0;3(];4 = 4
0;3(])1;4 = 24
0)1;4(3;] = 13
1)0;3(4;] = 22
1;4(3;0)] = 31
0;3(4;1)] = 22
1)];4(3;0 = 30
1;4(3;])0 = 30

Os valores gerados são: [1, 3, 4, 11, 13, 14, 20, 21, 22, 23, 24, 30, 31, 33]


Esse código você escreveu manualmente? Ou você enumerou e avaliou sistematicamente as variações de código? Eu me pergunto se um idioma com notação infix pode ser inerentemente melhor para isso, ou se é possível superar a abordagem do @ Sp3000 com um idioma de golfe baseado em pilha.
Reto Koradi

@Reto Eu escrevi um programa que tentou todos os valores 0..9 para os 4 parâmetros numéricos. Também tentei alterar manualmente alguns operadores. O problema com uma linguagem baseada em pilha é que a maioria dos operadores precisa de 2 parâmetros na pilha; portanto, temos muitos erros. Os idiomas infix se beneficiam da estrutura de verificadores descrita por Sp3000 em seu post.
Arnaud

Sim, foi exatamente isso que senti quando vi a abordagem básica. Ter um layout simples que garante a geração de todas as expressões válidas é uma grande vantagem. A única vantagem do CJam é que ele possui muito mais operadores de uma letra.
Reto Koradi

5

dc (20)

2+3
*p+
4+5
ABCFEDGHI -> 2+3+p*4+5 -> 5     $ **
ABCFIHEDG -> 2+3+5+p*4 -> 10    $ **
ABCFIHGDE -> 2+3+5+4*p -> 40    $ **
ABEDGHIFC -> 2+p*4+5+3 -> 2     $ **
ADEBCFIHG -> 2*p+3+5+4 -> 2       **
ADGHEBCFI -> 2*4+p+3+5 -> 6     $ **
ADGHIFCBE -> 2*4+5+3+p -> 14    $ **
ADGHIFEBC -> 2*4+5+p+3 -> 11    $ **
CBADEFIHG -> 3+2*p+5+4 -> 6       **
CBADGHEFI -> 3+2*4+p+5 -> 10      **
CBADGHIFE -> 3+2*4+5+p -> 15    $ **
CFEBADGHI -> 3+p+2*4+5 -> 3     $ **
CFIHEBADG -> 3+5+p+2*4 -> 8     $ **
CFIHGDABE -> 3+5+4*2+p -> 34    $ **
EDABCFIHG -> p*2+3+5+4 -> 
EFCBADGHI -> p+3+2*4+5 -> 
EHGDABCFI -> p+4*2+3+5 -> 
EHIFCBADG -> p+5+3+2*4 -> 
GDABCFEHI -> 4*2+3+p+5 -> 9     $ **
GHEDABCFI -> 4+p*2+3+5 -> 4     $ **
IHGDEFCBA -> 5+4*p+3+2 -> 20    $ **
GDEHIFCBA -> 4*p+5+3+2 -> 4       **
EDGHIFCBA -> p*4+5+3+2 -> 
CFIHGDEBA -> 3+5+4*p+2 -> 32    $ **
GHIFCBEDA -> 4+5+3+p*2 -> 12    $ **
IFCBEHGDA -> 5+3+p+4*2 -> 8       **
EBCFIHGDA -> p+3+5+4*2 -> 
CBEFIHGDA -> 3+p+5+4*2 -> 3       **
GHIFEDABC -> 4+5+p*2+3 -> 9       **
IFEHGDABC -> 5+p+4*2+3 -> 5       **
EFIHGDABC -> p+5+4*2+3 -> 
IHGDABEFC -> 5+4*2+p+3 -> 22    $ **
GDABEHIFC -> 4*2+p+5+3 -> 6       **
EBADGHIFC -> p+2*4+5+3 -> 
GHIFCBADE -> 4+5+3+2*p -> 24    $ **
IHGDABCFE -> 5+4*2+3+p -> 25    $ **
IFCBADGHE -> 5+3+2*4+p -> 20      **
GDABCFIHE -> 4*2+3+5+p -> 14      **
IHEFCBADG -> 5+p+3+2*4 -> 5       **
IFCBADEHG -> 5+3+2*p+4 -> 16    $ **

32 saídas, 20 delas distintas (marcadas com a $)

2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 14, 15, 16, 20, 22, 24, 25, 32, 34, 40

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.