Pure Evil: Eval
a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1
A instrução dentro do eval cria uma cadeia de comprimento 7 * 10 10 10 10 10 10 8,57, que consiste em nada além de mais chamadas para a função lambda, cada uma das quais constrói uma cadeia de comprimento semelhante , continuamente até eventualmente yse tornar 0. Ostensivelmente isso tem a mesma complexidade do método Eschew abaixo, mas, em vez de depender da lógica de controle if-and-or, ele apenas esmaga cadeias gigantes (e o resultado líquido está ficando mais acumulado ... provavelmente?).
O maior yvalor que posso fornecer e calcular sem o Python gerar um erro é 2, o que já é suficiente para reduzir a entrada de max-float no retorno 1.
A cadeia de comprimento 7.625.597.484.987 é muito grande: OverflowError: cannot fit 'long' into an index-sized integer.
Eu deveria parar.
Evitar Math.log: Indo para a (10ª) raiz (do problema), Pontuação: função efetivamente indistinguível de y = 1.
A importação da biblioteca de matemática está restringindo a contagem de bytes. Vamos acabar com isso e substituir a log(x)função por algo aproximadamente equivalente: x**.1e que custa aproximadamente o mesmo número de caracteres, mas não requer a importação. Ambas as funções têm uma saída sublinear em relação à entrada, mas x 0,1 cresce ainda mais lentamente . No entanto, não nos importamos muito, apenas nos importamos que ele tenha o mesmo padrão de crescimento base em relação a grandes números enquanto consome um número comparável de caracteres (por exemplo, x**.9é o mesmo número de caracteres, mas cresce mais rapidamente, portanto é algum valor que exibirá exatamente o mesmo crescimento).
Agora, o que fazer com 16 caracteres. Que tal ... estender nossa função lambda para ter propriedades de Sequência Ackermann? Essa resposta para grandes números inspirou essa solução.
a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1
A z**zparte aqui me impede de executar esta função em qualquer lugar próximo de entradas sãs para ye z, os maiores valores que posso usar são 9 e 3 para os quais recupero o valor de 1,0, mesmo para os maiores suportes flutuantes de Python (nota: enquanto 1.0 é numericamente maior que 6.77538853089e-05, os níveis de recursão aumentados movem a saída dessa função para mais perto de 1, enquanto permanecem maiores que 1, enquanto a função anterior moveu os valores para mais perto de 0 enquanto permanece maior que 0, portanto, mesmo recursão moderada nessa função resulta em tantas operações que o número do ponto flutuante perde todos os bits significativos).
Reconfigurando a chamada lambda original para ter valores de recursão de 0 e 2 ...
>>>1.7976931348623157e+308
1.0000000071
Se a comparação for feita para "compensar de 0" em vez de "compensar de 1", essa função retornará 7.1e-9, que é definitivamente menor que 6.7e-05.
A recursão base do programa real (valor z) tem 10 10 10 10 1,97 níveis de profundidade, assim que y se esgota, ela é redefinida com 10 10 10 10 10 1,97 (e é por isso que um valor inicial de 9 é suficiente), então não nem sei como calcular corretamente o número total de recursões que ocorrem: cheguei ao fim do meu conhecimento matemático. Da mesma forma, não sei se mover uma das **nexponenciações da entrada inicial para a secundária z**zmelhoraria o número de recursões ou não (idem ao contrário).
Vamos ir ainda mais devagar com ainda mais recursão
import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1
n//1 - economiza 2 bytes sobre int(n)import math, math.economiza 1 bytefrom math import*a(...) economiza 8 bytes no total m(m,...)(y>0)*x salva um byte maisy>0and x9**9**99aumenta a contagem de bytes em 4 e aumenta a profundidade da recursão em aproximadamente 2.8 * 10^xonde xestá a profundidade antiga (ou uma profundidade próxima ao googolplex em tamanho: 10 10 94 ).9**9**9e9aumenta a contagem de bytes em 5 e aumenta a profundidade da recursão em ... uma quantidade insana. A profundidade da recursão agora é 10 10 10 9,93 ; para referência, um googolplex é 10 10 10 2 .- declaração lambda aumenta recursão por um passo extra:
m(m(...))a a(a(a(...)))custos 7 bytes
Novo valor de saída (com 9 profundidade de recursão):
>>>1.7976931348623157e+308
6.77538853089e-05
A profundidade da recursão explodiu até o ponto em que esse resultado é literalmente sem sentido, exceto em comparação com os resultados anteriores usando os mesmos valores de entrada:
- O original ligou
log25 vezes
- A primeira melhoria chama 81 vezes
- O programa real chamaria 1e99 2 ou cerca de 10 10 2,3 vezes
- Esta versão chama 729 vezes
- O programa atual chamaria (9 9 99 ) 3 ou um pouco menos de 10 10 95 vezes).
Lambda Inception, pontuação: ???
Ouvi você gostar de lambdas, então ...
from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))
Não consigo nem executar isso, empilhar estouro, mesmo com meras 99 camadas de recursão.
O método antigo (abaixo) retorna (pulando a conversão para um número inteiro):
>>>1.7976931348623157e+308
0.0909072713593
O novo método retorna, usando apenas 9 camadas de incursão (em vez de o googol completo delas):
>>>1.7976931348623157e+308
0.00196323936205
Eu acho que isso tem complexidade semelhante à sequência de Ackerman, apenas pequena em vez de grande.
Também graças à ETHproductions por uma economia de 3 bytes em espaços que eu não sabia que poderiam ser removidos.
Resposta antiga:
O truncamento inteiro do log da função (i + 1) repetiu 20 25 vezes (Python) usando lambdas lambda'd.
A resposta de PyRulez pode ser compactada introduzindo um segundo lambda e empilhando-o:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))
99 100 caracteres usados.
Isso produz uma iteração de 20 25, sobre o 12. original. Além disso, ele salva 2 caracteres usando em int()vez do floor()que permitiu uma x()pilha adicional . Se os espaços após o lambda puderem ser removidos (não posso verificar no momento), um quinto y()pode ser adicionado. Possível!
Se houver uma maneira de pular a from mathimportação usando um nome totalmente qualificado (por exemplo x=lambda i: math.log(i+1))), isso salvaria ainda mais caracteres e permitiria outra pilha, x()mas não sei se o Python suporta essas coisas (suspeito que não). Feito!
Esse é essencialmente o mesmo truque usado na postagem do blog do XCKD em grandes números , no entanto, a sobrecarga na declaração de lambdas impede uma terceira pilha:
from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))
Essa é a menor recursão possível com três lambdas que excedem a altura da pilha computada de 2 lambdas (reduzir qualquer lambda para duas chamadas reduz a altura da pilha para 18, abaixo da versão 2-lambda), mas infelizmente requer 110 caracteres.
