La sfida

Abbastanza semplice, dato un input x, calcola la sua infinita torre di potenza!

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

Per voi amanti della matematica, questa è xla tetrazione infinita .

Tieni presente quanto segue:

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

Sorpreso non abbiamo avuto una "semplice" sfida matematica che coinvolge questo! *

ipotesi

xsarà sempre convergere.
È possibile gestire numeri negativi e complessi
Questo è code-golf , quindi vince il byte più basso !
Le risposte devono essere corrette con almeno 5 cifre decimali

Esempi

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

* (Oltre a una sfida più complicata qui )

code-golf math

— Graviton
fonte

1

Non credo che questa torre converga in x = −2 o x = −0,5.

— Anders Kaseorg,

@AndersKaseorg Sono d'accordo, anche se tutti i programmi sembrano avere la stessa risposta convergente. Perché non convergono?

— Graviton,

2

x = −2 viene attratto da un ciclo di 8 e x = −0,5 viene attratto da un ciclo di 6. (Il mio programma fornisce ancora una risposta in questi casi, ma è uno dei punti del ciclo e non un punto fisso; questo non indica la convergenza.)

— Anders Kaseorg,

@AndersKaseorg Aha molto interessante. Non capiresti perché '8' per -2 e '6' per -0,5? Ovviamente per curiosità.

— Graviton,

2

Puoi eseguire le iterazioni nel modo più semplice possibile, ma ecco un'immagine: commons.wikimedia.org/wiki/File:Tetration_period.png

— Anders Kaseorg

14

APL (Dyalog) , 4 byte

*⍣≡⍨

Provalo online!

* energia

⍣ fino a

≡ stabile

⍨ autoscatto

— Adamo
fonte

10

Pyth, 4 3 byte

^{barrato 4 è ancora regolare 4;}

u^Q

Provalo online

Come funziona

u       first repeated value under repeated application of G ↦
 ^QG        input ** G
    Q   starting at input

— Anders Kaseorg
fonte

2

Non è necessario l'ultimo G, verrà riempito automaticamente.

— FryAmTheEggman,

@FryAmTheEggman Giusto, grazie!

— Anders Kaseorg,

7

Haskell , 100 63 byte

Per gli input che non convergono (ad es. -2) Questo non termina:

import Data.Complex
f x=until(\a->magnitude(a-x**a)<1e-6)(x**)x

Grazie mille @ ØrjanJohansen per avermi insegnato untile salvato me 37byte!

Provalo online!

— ბიმო
fonte

1

Puoi accorciarlo molto con la untilfunzione. Provalo online!

— Ørjan Johansen,

! Neat Non lo sapevo until, grazie mille.

— ბიმო

7

Python 3 , 40 39 35 byte

Grazie a Ørjan Johansen per un byte: d>99invece di d==99: 1 iterazione in più per un conteggio dei byte minore
Grazie @Uriel per 4 byte: saggio utilizzo del fatto che x**Truevaluta x in x**(d>99or g(x,d+1)). L'espressione nel termine restituisce True per una profondità maggiore di 99 e quindi restituisce il valore passato.

Lambda ricorsiva con una profondità massima 100, ovvero per una profondità 100, restituisce lo stesso valore. In realtà è indipendente dalla convergenza, quindi aspettati l'inaspettato per i numeri con valori non convergenti per la funzione.

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

Provalo online!

— officialaimm
fonte

1

Nel link tio, è possibile sostituire complex('j')con1j

— Mr. Xcoder il

1

d>99esegue un'altra iterazione ed è più breve.

— Ørjan Johansen,

1

salva 4 byte con g=lambda x,d=0:x**(d>99or g(x,d+1)), x**Truerestituiscex

— Uriel il

@Uriel, è davvero intelligente ..... Grazie !!!

— officialaimm,

6

Python 3, 37 30 27 byte

-7 byte da @FelipeNardiBatista.
-3 byte da @xnor

Non ricordo più molto di Python, ma sono riuscito a eseguire il porting della mia risposta di Ruby e ho battuto l'altra risposta di Python 3: D

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

Provalo online!

— daniero
fonte

1

Cordiali saluti, sembra che le f-string siano state introdotte per la prima volta in Python 3.6: vedi python.org/dev/peps/pep-0498 . (Questo spiegherebbe perché il tuo codice non ha funzionato per me in 3.5.2.) Ho pensato di menzionarlo nel caso in cui qualcun altro fosse confuso.

— Mathmandan,

1

Non è necessario sostituire il valore di x, eval('x**'*99+'1')works

— xnor

@xnor doh, certo che lo fa :) grazie

— daniero il

@xnor Neat - Ho applicato la stessa cosa nella mia risposta di Ruby e in qualche modo è stato risolto :)

— daniero

+1, mi sto schiaffeggiando per aver dimenticato l'esistenza di eval ....: D

— officialaimm,

4

Mathematica, 12 byte

#//.x_:>#^x&

Accetta un numero in virgola mobile come input.

— alephalpha
fonte

4

J , 5 byte

^^:_~

Provalo online!

Spiegazione

In primo luogo, mostrerò quale comando viene eseguito dopo aver analizzato il ~alla fine e la procedura dettagliata sarà per il nuovo verbo.

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

((x&^)^:_) x  |  Input: x
      ^:_     |  Execute starting with y = x until the result converges
  x&^         |    Compute y = x^y

— miglia
fonte

La soluzione J è davvero bella qui. Per spezzare la tua prima riga in grana più fine, è corretto dire che succede quanto segue: (^^:_) crea un nuovo verbo diadico tramite la congiunzione di potenza, quindi l'autoavverbio ~rende quel verbo monadico, così che quando viene dato un argomento xviene espanso x (^^:_) x. la sinistra xsuccessivamente "si attacca", dando ((x&^)^:_) xsecondo la tua nota, e solo l'argomento giusto cambia durante l'iterazione?

— Giona,

1

@Jonah Certo, quando si danno due argomenti a una diade con potere, x u^:n yl'argomento sinistro è legato alla diade per formare una monade che è nidificata più nvolte y. x u^:n y -> (x&u)^:n y -> (x&u) ... n times ... (x&u) y

— miglia

4

C # (.NET Core) , 79 78 byte

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

Provalo online!

Ho scelto di ripetere fino a i= 999 perché se ho ripetuto fino al 99 alcuni esempi non hanno raggiunto la precisione richiesta. Esempio:

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)

Come puoi vedere, dopo 99 iterazioni la parte immaginaria fallì al 5 ° decimale.

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)

In questo caso dopo 99 iterazioni otteniamo la precisione prevista. In effetti, potrei iterare fino a i= 1e9 con lo stesso numero di byte, ma ciò renderebbe il codice considerevolmente più lento

1 byte salvato grazie a un utente anonimo.

— Charlie
fonte

1

+1 Per la classe complessa non sapevo nemmeno che esistesse.

— TheLethalCoder il

1

@TheLethalCoder non l'ho nemmeno fatto finché non ho cercato su Google. :-)

— Charlie,

3

Gelatina , 5 byte

³*$ÐL

Provalo online!

— Dennis
fonte

2

Rubino, 21 20 byte

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

Disclaimer : sembra che Ruby restituisca alcuni valori strani quando si alza un numero complesso ad una potenza. Presumo che sia fuori portata per questa sfida risolvere l'intero modulo matematico di Ruby, ma altrimenti i risultati di questa funzione dovrebbero essere corretti. Modifica : ho applicato le ultime modifiche dalla mia risposta di Python 3 e improvvisamente in qualche modo dà gli stessi risultati attesi :)

Provalo online!

— daniero
fonte

Elimina lo spazio dopo il eval.

— Value Ink

La tua versione originale ha avuto esito negativo sul complesso test case perché ha valutato la stringa "0+1i**0+1i**0+1i**...", che analizza in modo errato poiché **ha una precedenza maggiore di +.

— Ørjan Johansen,

@ ØrjanJohansen eh, hai ragione. Immagino di essere stato preso in giro dal fatto che #inspecte #to_srestituire valori diversi. Prima di inviare la risposta iniziale ho fatto alcuni test in irb e ho visto che Complex(1,2)darebbe (1+2i), ad esempio, l'ingresso nel REPL , comprese le parentesi. Quando si restringe il valore, tuttavia le parentesi non sono incluse, quindi la precedenza, come si sottolinea, lo ha incasinato.

— daniero,

Pensavo evalfosse vietato l'uso.

— V. Courtois,

@ V.Courtois Ok. Ma non lo è.

— daniero,

2

TI-BASIC, 16 byte

L'ingresso e l'uscita sono memorizzati in Ans.

Ans→X
While Ans≠X^Ans
X^Ans
End

— kamoroso94
fonte

1

R , 36 33 byte

- 3 byte grazie a Jarko Dubbeldam

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

Legge da stdin. Reduces da destra per ottenere gli esponenti applicati nell'ordine corretto.

Provalo (funzione)

Provalo (stdin)

— Giuseppe
fonte

1

scan(,1i)lavori. Simile a come scan(,'')funziona.

— JAD,

@JarkoDubbeldam ovviamente! a volte il mio cervello non funziona.

— Giuseppe,

1

Javascript, 33 byte

f=(x,y=x)=>(x**y===y)?y:f(x,x**y)

— quant2016
fonte

JavaScript non gestisce numeri immaginari.

— kamoroso94,

1

MATL , 20 10 byte

ridotto della metà grazie a @LuisMendo

t^`Gw^t5M-

Provalo online!

Questo è il mio primo codice-golf e la mia prima volta che uso MATL, quindi sono sicuro che potrebbe essere facilmente superato.

— Cinaski
fonte

Benvenuti nel sito e bella prima risposta! Alcuni suggerimenti: XIIè equivalente a t. Puoi anche eliminare XHe Hutilizzare gli Appunti automatici M, ovvero ttt^`yw^t5M-]bb-x. E nell'ultima parte, invece di eliminare i valori indesiderati che è possibile utilizzare &, ciò indica alla funzione di visualizzazione implicita di mostrare solo la parte superiore. Quindi, è possibile utilizzare ttt^`yw^t5M-]&e salvare alcuni byte.

— Luis Mendo,

Inoltre, il primo tnon è necessaria, ed usando Gal posto di un altro tsi può evitare &, e quindi lasciare ]implicita: t^`Gw^t5M-. Ehi, abbiamo ridotto il conteggio dei byte della metà!

— Luis Mendo,

@LuisMendo Grazie per gli ottimi consigli! Ho molto da imparare su MATL, ma mi piace molto.

— Cinaski,

Felice di sentirlo!

— Luis Mendo,

0

Perl 6 , 17 byte

{[R**] $_ xx 999}

Provalo online!

R**è l'operatore di esponenziazione inversa; x R** yè uguale a y ** x. [R**]riduce un elenco di 999 copie dell'argomento di input con esponenziazione inversa.

— Sean
fonte

L'infinita torre del potere

La sfida

ipotesi

Esempi

APL (Dyalog) , 4 byte

Pyth, 4 3 byte

Come funziona

Haskell , 100 63 byte

Python 3 , 40 39 35 byte

Python 3, 37 30 27 byte

Mathematica, 12 byte

J , 5 byte

Spiegazione

C # (.NET Core) , 79 78 byte

Gelatina , 5 byte

Rubino, 21 20 byte

TI-BASIC, 16 byte

R , 36 33 byte

Javascript, 33 byte

MATL , 20 10 byte

Perl 6 , 17 byte