fundo

Esse quebra-cabeça é uma variação do quebra-cabeça de quatro quatros (o tópico de uma questão do passado ). Como esse quebra-cabeça, o objetivo é encontrar expressões matemáticas para diferentes números inteiros, usando apenas quatro dígitos e certos operadores matemáticos. Nesse caso, no entanto, os dígitos permitidos são apenas 2, 0, 1 e 5 . Cada um deve aparecer precisamente uma vez na solução e na ordem correta. Surpreendentemente, muitos números inteiros podem ser representados dessa maneira. Os solventes são incentivados a tentar resolvê-lo manualmente primeiro, pois é estranhamente agradável.

Regras

As constantes podem ser construídas a partir de um ou vários dígitos:

• Inteiros: por exemplo, 2, 0, 15, etc.
• Decimais: por exemplo, 0,2, 0,01, 1,5, etc.
• Dízima periódica : por exemplo, 0,2 ~ (= 0,222 ...), 0,15 ~ (= 0,1555 ...), 20.15 ~~ (= 20,1515 ...)

As seguintes operações unárias são permitidas:

• Negação unária: -x
• Raiz quadrada: sqrt (x)
• Fatorial inteiro: x!

As seguintes operações binárias são permitidas:

• Operadores aritméticos padrão: x + y, xy, x * ye x / y
• Exponenciação arbitrária: x ^ y
• Raízes arbitrárias: rt [x] (y) (= x'ésima raiz de y)

Tarefa

Seu programa deve imprimir expressões para o maior número possível de números inteiros entre 0 e 100 e depois gerar o número de expressões que produziu.

• As soluções devem ser impressas em ordem no formato n = [expr].
• As expressões devem usar todos os dígitos 2, 0, 1, 5, uma vez cada um nessa ordem.
• As expressões devem ser impressas usando a notação descrita acima. Parênteses desnecessários são permitidos, mas não obrigatórios, como é o espaço em branco. A ordem de precedência do operador é negação unária, fatorial, exponenciação, multiplicação / divisão e adição / subtração.
• O programa não precisa retornar soluções para todos os números. Um programa que simplesmente gera 0 é, portanto, válido; no entanto, consulte a seção de pontuação abaixo.
• O programa deve ser executado em menos de 15 minutos em um computador moderno.

Você pode escrever um programa ou função. As expressões devem ser impressas em STDOUT (ou alternativa mais próxima). O número de expressões pode ser impresso em STDOUT ou retornado como um número inteiro. Aplicam-se restrições de golfe de código padrão.

Saída de exemplo

0=2*0*1*5
10=20*1*.5
42=((2+0!)!+1)!/5!
100=20*1*5
4

Pontuação

Atualização : @orlp notou uma falha no sistema de pontuação. Consulte http://meta.codegolf.stackexchange.com/questions/5106/way-of-salvaging-two-zero-one-five-puzzle-challenge para obter uma discussão sobre como ou se isso deve ser corrigido.

As soluções são pontuadas primeiro pelo número de expressões que produzem e depois pelo comprimento do código em bytes. Portanto, um programa de 1000 bytes que produz 80 resultados superará um programa de 100 bytes que produz apenas 79 (embora o último possa ser facilmente estendido para incluir os resultados ausentes).

Para aqueles que desejam um alvo motivador, abaixo está um limite inferior ao número de expressões que podem ser representadas. Não pretendo enviar uma inscrição, por isso pode ser possível ganhar com menos!

Pelo menos 85 (em 101), embora possa muito bem ser maior.

Placar

Como um incentivo extra, aqui está um resumo da progressão da pontuação. Sempre que você atingir a pontuação mais alta, sinta-se à vontade para se colocar no topo da tabela (ou pedir a alguém que o faça).

• 0 expressões, 1 byte (Pyth): implementação que apenas gera 0

85, ~ 2400 bytes

Estou um pouco triste por se tratar de um desafio de código de golfe, pois sinto que todos os meus esforços anteriores foram inúteis agora que publicarei o seguinte:

  0 = ((2*0)^15)
  1 = ((2^0)^15)
  2 = (2-(0^15))
  3 = (20*.15)
  4 = (20*(1/5))
  5 = (20-15)
  6 = ((.20+1)*5)
  7 = ((20*.1)+5)
  8 = (2*((0-1)+5))
  9 = ((.20/.1~)*5)
 10 = (20/(1/.5))
 11 = ((((2-0)+1))!+5)
 12 = (20*(.1+.5))
 13 = ((-(2)-0)+15)
 14 = (20-(1+5))
 15 = ((2*0)+15)
 16 = ((2^0)+15)
 17 = ((2-0)+15)
 18 = (20-(1/.5))
 19 = (20-(1^5))
 20 = (20^(1^5))
 21 = (20+(1^5))
 22 = (20+(1/.5))
 23 = (((2-0)/.1~)+5)
 24 = ((20-1)+5)
 25 = ((20^1)+5)
 26 = ((20+1)+5)
 27 = (rt[.2](((0)!+1))-5)
 28 = (2*(-((0)!)+15))
 29 = ((((2+(0)!)+1))!+5)
 30 = ((2-0)*15)
 31 = (20+sqrt((1+(5)!)))
 32 = ((20*.1)^5)
 33 = ((.2^-((0)!))/.15~~)
 34 = (2+(((0)!+1)^5))
 35 = (20+15)
 36 = (20*(1/.5~))
 37 = (rt[.2](((0)!+1))+5)
 38 = ((20-1)/.5)
 39 = (-((2^0))+(sqrt(.1~)*(5)!))
 40 = (20*(1/.5))
 41 = (((.2~^-((0)!))/.1~)+.5)
 42 = ((20+1)/.5)
 43 = (-(2)+(((0)!/.1~)*5))
 44 = (20+((-(1)+5))!)
 45 = (20/(1-.5~))
 46 = ((.2+((0)!/.1~))*5)
 47 = (2+(((0)!/.1~)*5))
 48 = (2*(((0-1)+5))!)
 49 = ((((2+(0)!))!/.1~)-5)
 50 = (((2^0)/.1)*5)
 51 = ((.2+((0)!/.1))*5)
 52 = (2+(((0)!/.1)*5))
 54 = (((2+(0)!)/.1)/.5~)
 55 = ((2+((0)!/.1~))*5)
 56 = (((.2-(0)!)+sqrt(.1~))*-((5)!))
 58 = (-(2)+sqrt((((((0)!/sqrt(.1~)))!)!*5)))
 59 = ((((2+(0)!))!/.1~)+5)
 60 = (20/(.1~^.5))
 62 = (2*(-((0)!)+sqrt(rt[-(.1)](.5))))
 64 = ((2-0)^(1+5))
 65 = ((20/sqrt(.1~))+5)
 66 = ((-(((2+(0)!))!)/.1~)+(5)!)
 67 = (((((2+(0)!))!)!*.1)-5)
 69 = ((2^(((0)!/sqrt(.1~)))!)+5)
 70 = (((.2^-((0)!))/-(.1))+(5)!)
 72 = ((2+(0)!)*((-(1)+5))!)
 75 = ((.2^-((0)!))*15)
 76 = (rt[(-(2)^-((0)!))](.1~)-5)
 77 = (((((2+(0)!))!)!*.1)+5)
 78 = (2*(-((0)!)+(sqrt(.1~)*(5)!)))
 80 = (-(20)*(1-5))
 81 = (201-(5)!)
 82 = (2*((0)!+(sqrt(.1~)*(5)!)))
 84 = (((.2-(0)!)+.1)*-((5)!))
 85 = (((((2+(0)!))!)!*.1~)+5)
 86 = (rt[(-(2)^-((0)!))](.1~)+5)
 88 = (rt[.2]((-((0)!)-1))+(5)!)
 90 = ((20/.1~)*.5)
 93 = (((2+(0)!)/-(.1~))+(5)!)
 95 = ((20-1)*5)
 96 = ((.20-1)*-((5)!))
 98 = (-(20)*(.1-5))
 99 = ((-(20)-1)+(5)!)
100 = (20/(1/5))
85

A partir daqui é apenas um desafio de compactação. Talvez eu concorra depois, talvez não. Para mim, a maior parte da diversão foi no desafio de encontrar mais fórmulas.

Uma dica para quem luta para escrever um solucionador - o tempo de execução não deve ser um problema. Se você tiver muitas fórmulas para verificar, precisará de melhores heurísticas para descartar soluções sem esperança e duplicatas. O código que escrevi para gerar as etapas acima é executado em ~ 5 segundos no Python.