A torre de poder infinita

22

O desafio

Muito simples, considerando uma entrada x, calcule sua torre de energia infinita!

x^x^x^x^x^x...

Para vocês, amantes da matemática, essa é xa infinita tetração .

Lembre-se do seguinte:

x^x^x^x^x^x... = x^(x^(x^(x^(x...)))) != (((((x)^x)^x)^x)^x...)

Surpreendido, não tivemos um desafio "simples" de matemática envolvendo isso! *

Suposições

  • xvai sempre convergem.
  • Números negativos e complexos devem poder ser manipulados
  • Isso é código-golfe , então os bytes mais baixos vencem!
  • Suas respostas devem estar corretas com pelo menos 5 casas decimais

Exemplos

Input >> Output

1.4 >> 1.8866633062463325
1.414 >> 1.9980364085457847
[Square root of 2] >> 2
-1 >> -1
i >> 0.4382829367270323 + 0.3605924718713857i
1 >> 1
0.5 >> 0.641185744504986
0.333... >> 0.5478086216540975
1 + i >> 0.6410264788204891 + 0.5236284612571633i
-i >> 0.4382829367270323 -0.3605924718713857i
[4th root of 2] >> 1.239627729522762

* (Além de um desafio mais complicado aqui )

code-golf  math 
— Graviton
fonte
1
Não acho que essa torre converja em x = -2 ou x = -0,5.
— Anders Kaseorg
@AndersKaseorg Eu concordo, embora todos os programas pareçam ter a mesma resposta convergente. Por que eles não convergem?
— Graviton
2
x = −2 é atraído por um ciclo de 8 e x = −0,5 é atraído por um ciclo de 6. (Meu programa ainda dá uma resposta nestes casos, mas é um dos pontos do ciclo e não um ponto fixo, o que não indica a convergência.)
— Anders Kaseorg
@AndersKaseorg Aha muito interessante. Você não saberia por que '8' para -2 e '6' para -0,5? Apenas por curiosidade, é claro.
— Graviton
2
Você pode executar as iterações tão facilmente como eu posso, mas aqui está uma imagem: commons.wikimedia.org/wiki/File:Tetration_period.png
— Anders Kaseorg

Respostas:

7

Python 3 , 40 39 35 bytes

  • Obrigado @ Ørjan Johansen por um byte: em d>99vez de d==99: mais 1 iteração para uma contagem menor de bytes
  • Obrigado @Uriel por 4 bytes: utilização sábia do fato de que x**Trueavalia x em x**(d>99or g(x,d+1)). A expressão no termo é avaliada como True para profundidade maior que 99 e, portanto, retorna o valor passado.

Lambda recursiva com profundidade máxima 100, isto é, para profundidade 100, retorna o mesmo valor. Na verdade, é independente da convergência, portanto, espere o inesperado para números com valores não convergentes para a função.

g=lambda x,d=0:x**(d>99or g(x,d+1))

Experimente online!

— officialaimm
fonte
1
No link tio, você pode substituir complex('j')por1j
— Sr. Xcoder
1
d>99faz mais uma iteração e é mais curto.
— Ørjan Johansen
1
salvar 4 bytes com g=lambda x,d=0:x**(d>99or g(x,d+1)), x**Trueavalia parax
— Uriel
@ Uriel, Isso é realmente inteligente ..... Obrigado !!!
— officialaimm
6

Python 3, 37 30 27 bytes

-7 bytes de @FelipeNardiBatista.
-3 bytes de @xnor

Não lembro mais muito de Python, mas consegui portar minha resposta em Ruby e vencer a outra resposta em Python 3: D

lambda x:eval('x**'*99+'1')

Experimente online!

— daniero
fonte
1
Para sua informação, parece que as strings-f foram introduzidas pela primeira vez no Python 3.6: consulte python.org/dev/peps/pep-0498 . (Isso explicaria por que seu código não funcionou para mim na versão 3.5.2.) Apenas pensei em mencionar isso caso alguém mais estivesse confuso.
— mathmandan
1
Você não precisa substituir no valor de x, eval('x**'*99+'1')funciona #
— 224
@xnor dó, é claro que sim :) graças
— daniero
@xnor Neat - Eu apliquei a mesma coisa na minha resposta Ruby e que de alguma forma fixa-lo :)
— daniero
+1, estou me dando um tapa por esquecer a existência de eval ....: D #
— officialaimm
4

Mathematica, 12 bytes

#//.x_:>#^x&

Pega um número de ponto flutuante como entrada.

— alefalpha
fonte
4

J , 5 bytes

^^:_~

Experimente online!

Explicação

Primeiro, mostrarei qual comando está sendo executado após analisar ~o final, e o passo a passo será para o novo verbo.

(^^:_~) x = ((x&^)^:_) x

((x&^)^:_) x  |  Input: x
      ^:_     |  Execute starting with y = x until the result converges
  x&^         |    Compute y = x^y
— milhas
fonte
A solução J é muito boa aqui. Para dividir sua primeira linha em detalhes mais finos, é correto dizer que acontece o seguinte: (^^:_) cria um novo verbo diádico via power conj, então o auto-advérbio ~torna esse verbo monádico, de modo que, quando dado um argumento, xele é expandido x (^^:_) x. a esquerda xsubseqüentemente "gruda", dando ((x&^)^:_) xsua nota, e somente o argumento correto é alterado durante a iteração?
— Jonah
1
@ Jonah Claro, ao apresentar dois argumentos para uma díade com poder, x u^:n yo argumento da esquerda é vinculado à díade para formar uma mônada que é aninhada várias nvezes y. x u^:n y -> (x&u)^:n y -> (x&u) ... n times ... (x&u) y
— miles
4

C # (.NET Core) , 79 78 bytes

x=>{var a=x;for(int i=0;i++<999;)a=System.Numerics.Complex.Pow(x,a);return a;}

Experimente online!

Eu escolhi iterar até i= 999 porque, se eu iterasse até 99, alguns exemplos não alcançariam a precisão necessária. Exemplo:

Input:                      (0, 1)
Expected output:            (0.4382829367270323, 0.3605924718713857)
Output after 99 iterations: (0.438288569331222,  0.360588154553794)
Output after 999 iter.:     (0.438282936727032,  0.360592471871385)

Como você pode ver, após 99 iterações, a parte imaginária falhou na quinta casa decimal.

Input:                      (1, 1)
Expected output:            (0.6410264788204891, 0.5236284612571633)
Output after 99 iterations: (0.64102647882049,   0.523628461257164)
Output after 999 iter.:     (0.641026478820489,  0.523628461257163)

Nesse caso, após 99 iterações, obtemos a precisão esperada. Na verdade, eu poderia iterar até i= 1e9 com a mesma contagem de bytes, mas isso tornaria o código consideravelmente mais lento

  • 1 byte salvo graças a um usuário anônimo.
— Charlie
fonte
1
+1 Para a classe complexa, eu nem sabia que existia.
— TheLethalCoder
1
@TheLethalCoder também não fiz isso até pesquisar no Google. :-)
— Charlie
2

Ruby, 21 20 bytes

->n{eval'n**'*99+?1}

Isenção de responsabilidade : Parece que Ruby retorna alguns valores estranhos ao elevar um número complexo a uma potência. Suponho que esteja fora do escopo desse desafio corrigir o módulo de matemática inteiro de Ruby, mas, caso contrário, os resultados dessa função devem estar corretos. Edit : Aplicadas as alterações mais recentes da minha resposta do Python 3 e de repente, de alguma forma, dá os mesmos resultados esperados :)

Experimente online!

— daniero
fonte
Retire o espaço após o eval.
— Value Ink
Sua versão original falhou no caso de teste complexo porque avaliou a string "0+1i**0+1i**0+1i**...", que analisa da maneira errada, pois **tem precedência maior que +.
— Ørjan Johansen
@ ØrjanJohansen hein, você está certo. Eu acho que fui enganado pelo fato de que #inspecte #to_sretornar valores diferentes. Antes de enviar a resposta inicial, fiz alguns testes no irb e vi que, por exemplo, entrar Complex(1,2)no REPL daria (1+2i), incluindo os parênteses. Ao restringir o valor, no entanto, os parênteses não são incluídos; portanto, a precedência, como você indica, estragou tudo.
— Daniero 26/07/19
Eu pensei que o evaluso era proibido.
— V. Courtois
@ V.Courtois Ok. Mas isso não.
— Daniero 26/07/19
2

TI-BASIC, 16 bytes

A entrada e saída são armazenadas em Ans.

Ans→X
While Ans≠X^Ans
X^Ans
End
— kamoroso94
fonte
1

R , 36 33 bytes

- 3 bytes graças a Jarko Dubbeldam

Reduce(`^`,rep(scan(,1i),999),,T)

Lê de stdin. Reduces da direita para obter os expoentes aplicados na ordem correta.

Experimente (função)

Experimente (stdin)

— Giuseppe
fonte
1
scan(,1i)trabalho. Semelhante a como scan(,'')funciona.
— JAD
@JarkoDubbeldam, é claro! às vezes meu cérebro não funciona.
— Giuseppe
1

Javascript, 33 bytes

f=(x,y=x)=>(x**y===y)?y:f(x,x**y)
— quant2016
fonte
JavaScript não lida com números imaginários.
— kamoroso94
1

MATL , 20 10 bytes

reduzido a metade graças a @LuisMendo

t^`Gw^t5M-

Experimente online!

Esta é minha primeira code-golf e minha primeira vez usando MATL, então eu tenho certeza que poderia ser facilmente superada.

— Cinaski
fonte
Bem-vindo ao site, e boa primeira resposta! Algumas sugestões: XIIé equivalente a t. Você também pode se livrar XHe Husar a área de transferência automática M, ou seja ttt^`yw^t5M-]bb-x,. E na última parte, em vez de excluir os valores indesejados que você pode usar &, o que instrui a função de exibição implícita a mostrar apenas o topo. Então, você pode usar ttt^`yw^t5M-]&e salvar alguns bytes.
— Luis Mendo
Além disso, o primeiro tnão é necessário, e usando Gem vez de outro tvocê pode evitar &e, assim, deixar ]implícito: t^`Gw^t5M-. Ei, reduzimos a contagem de bytes pela metade!
— Luis Mendo
@LuisMendo Obrigado pelas ótimas dicas! Eu tenho muito a aprender sobre MATL, mas eu realmente gosto disso.
— Cinaski
Fico feliz em ouvir isso!
— Luis Mendo
0

Perl 6 , 17 bytes

{[R**] $_ xx 999}

Experimente online!

R**é o operador de exponenciação reversa; x R** yé igual a y ** x. [R**]reduz uma lista de 999 cópias do argumento de entrada com exponenciação reversa.

— Sean
fonte
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.