La tour de puissance infinie

22

Le défi

Assez simple, étant donné une entrée x, calculez sa tour de puissance infinie!

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

Pour vous, amateurs de mathématiques, c'est xla tétration infinie .

Gardez à l'esprit les points suivants:

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

Surpris, nous n'avons pas eu de défi mathématique «simple» impliquant cela! *

Hypothèses

  • xsera toujours converger.
  • Les nombres négatifs et complexes devraient pouvoir être traités
  • Il s'agit de code-golf , donc les octets les plus bas gagnent!
  • Vos réponses doivent être correctes à au moins 5 décimales

Exemples

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

* (Autre qu'un défi plus compliqué ici )

code-golf  math 
— Graviton
source
1
Je ne pense pas que cette tour converge à x = -2 ou x = -0,5.
— Anders Kaseorg
@AndersKaseorg Je suis d'accord, bien que tous les programmes semblent avoir la même réponse convergente. Pourquoi ne convergent-ils pas?
— Graviton
2
x = −2 est attiré par un cycle de 8 et x = −0,5 est attiré par un cycle de 6. (Mon programme donne toujours une réponse dans ces cas, mais c'est l'un des points du cycle et non un point fixe; cela n'indique pas la convergence.)
— Anders Kaseorg
@AndersKaseorg Aha très intéressant. Vous ne sauriez pas pourquoi «8» pour -2 et «6» pour -0,5? Juste par curiosité bien sûr.
— Graviton
2
Vous pouvez exécuter les itérations aussi facilement que possible, mais voici une image: commons.wikimedia.org/wiki/File:Tetration_period.png
— Anders Kaseorg

Réponses:

7

Python 3 , 40 39 35 octets

  • Merci @ Ørjan Johansen pour un octet: d>99au lieu de d==99: 1 itération supplémentaire pour un nombre d'octets moindre
  • Merci à @Uriel pour 4 octets: utilisation judicieuse du fait qu'il x**Trueévalue à x in x**(d>99or g(x,d+1)). L'expression du terme est évaluée à True pour une profondeur supérieure à 99 et renvoie donc la valeur transmise.

Lambda récursif avec une profondeur maximale de 100, c'est-à-dire pour une profondeur de 100, renvoie la même valeur. En fait, il est indépendant de la convergence, attendez-vous donc à l'inattendu pour les nombres avec des valeurs non convergentes pour la fonction.

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

Essayez-le en ligne!

— officialaimm
source
1
Dans le lien tio, vous pouvez remplacer complex('j')par1j
— M. Xcoder
1
d>99fait une autre itération et est plus courte.
— Ørjan Johansen
1
enregistrer 4 octets avec g=lambda x,d=0:x**(d>99or g(x,d+1)), x**Trueévalue àx
— Uriel
@Uriel, c'est vraiment intelligent ..... Merci !!!
— officialaimm
6

Python 3, 37 30 27 octets

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

Je ne me souviens plus beaucoup de Python, mais j'ai réussi à porter ma réponse Ruby et à battre l'autre réponse Python 3: D

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

Essayez-le en ligne!

— daniero
source
1
Pour info, il semble que les chaînes f aient été introduites pour la première fois dans Python 3.6: voir python.org/dev/peps/pep-0498 . (Cela expliquerait pourquoi votre code ne fonctionnait pas pour moi en 3.5.2.) Je pensais juste le mentionner au cas où quelqu'un d'autre serait confus.
— mathmandan
1
Vous n'avez pas besoin de remplacer la valeur de x, eval('x**'*99+'1')works
— xnor
@xnor doh, bien sûr que
— oui
@xnor Neat - J'ai appliqué la même chose dans ma réponse Ruby et cela l'a en quelque sorte corrigé :)
— daniero
+1, je me gifle pour avoir oublié l'existence d'eval ....: D
— officialaimm
4

Mathematica, 12 octets

#//.x_:>#^x&

Prend un nombre à virgule flottante comme entrée.

— alephalpha
source
4

J , 5 octets

^^:_~

Essayez-le en ligne!

Explication

Tout d'abord, je montrerai quelle commande est exécutée après avoir analysé le ~à la fin, et la procédure sera pour le nouveau verbe.

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

((x&^)^:_) x  |  Input: x
      ^:_     |  Execute starting with y = x until the result converges
  x&^         |    Compute y = x^y
— miles
source
La solution J est vraiment sympa ici. Pour décomposer votre première ligne en grain plus fin, est-il correct de dire que ce qui suit se produit: (^^:_) crée un nouveau verbe dyadique via le pouvoir conj, puis auto-adverbe ~rend ce verbe monadique, de sorte que lorsqu'il est donné un argument, xil est étendu à x (^^:_) x. la gauche x"colle" ensuite, donnant ((x&^)^:_) xselon votre note, et seul le bon argument change pendant l'itération?
— Jonah
1
@Jonah Bien sûr, lorsque vous donnez deux arguments à une dyade avec pouvoir, x u^:n yl'argument de gauche est lié à la dyade pour former une monade qui est imbriquée plusieurs nfois y. x u^:n y -> (x&u)^:n y -> (x&u) ... n times ... (x&u) y
— miles
4

C # (.NET Core) , 79 78 octets

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

Essayez-le en ligne!

J'ai choisi d'itérer jusqu'à i= 999 car si je répétais jusqu'à 99, certains exemples n'atteignaient pas la précision requise. Exemple:

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)

Comme vous pouvez le voir, après 99 itérations, la partie imaginaire a échoué à la 5ème décimale.

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)

Dans ce cas, après 99 itérations, nous obtenons la précision attendue. En fait, je pouvais irépéter jusqu'à = 1e9 avec le même nombre d'octets, mais cela rendrait le code considérablement plus lent

  • 1 octet enregistré grâce à un utilisateur anonyme.
— Charlie
source
1
+1 Pour la classe complexe, je ne savais même pas que ça existait.
— TheLethalCoder
1
@TheLethalCoder non plus jusqu'à ce que je le recherche sur Google. :-)
— Charlie
2

Rubis, 21 20 octets

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

Avertissement : Il semble que Ruby renvoie des valeurs étranges lors de l'augmentation d'un nombre complexe à une puissance. Je suppose qu'il est hors de portée de ce défi de corriger l'intégralité du module mathématique de Ruby, mais sinon les résultats de cette fonction devraient être corrects. Edit : appliqué les dernières modifications de ma réponse Python 3 et soudain, il donne en quelque sorte les mêmes résultats attendus :)

Essayez-le en ligne!

— daniero
source
Retirez l'espace après le eval.
— Value Ink
Votre version d'origine a échoué dans le cas de test complexe, car elle a évalué la chaîne "0+1i**0+1i**0+1i**...", qui est analysée de manière incorrecte car **a une priorité plus élevée que +.
— Ørjan Johansen
@ ØrjanJohansen hein, vous avez raison. Je suppose que j'ai été trompé par le fait que #inspectet #to_srenvoyer des valeurs différentes. Avant de soumettre la réponse initiale, j'ai fait quelques tests dans irb et j'ai vu que, par exemple, entrer Complex(1,2)dans le REPL donnerait (1+2i), y compris les parenthèses. Lors de la chaîne de la valeur, les parenthèses ne sont pas incluses, donc la priorité, comme vous le faites remarquer, l'a gâché.
— daniero
Je pensais que l' evalutilisation était interdite.
— V. Courtois
@ V.Courtois Ok. Mais ce n'est pas.
— daniero
2

TI-BASIC, 16 octets

L'entrée et la sortie sont stockées dans Ans.

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

R , 36 33 octets

- 3 octets grâce à Jarko Dubbeldam

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

Lit à partir de stdin. Reduces de droite pour obtenir les exposants appliqués dans le bon ordre.

Essayez-le (fonction)

Essayez-le (stdin)

— Giuseppe
source
1
scan(,1i)travaux. Similaire au scan(,'')fonctionnement.
— JAD
@JarkoDubbeldam bien sûr! parfois mon cerveau ne fonctionne pas.
— Giuseppe
1

MATL , 20 10 octets

réduit de moitié grâce à @LuisMendo

t^`Gw^t5M-

Essayez-le en ligne!

C'est mon premier code-golf et ma première utilisation de MATL, donc je suis sûr qu'il pourrait être facilement dépassé.

— Cinaski
source
Bienvenue sur le site et bonne première réponse! Quelques suggestions: XIIéquivaut à t. Vous pouvez également vous débarrasser XHet Hutiliser le presse M- papiers automatique , c'est-à-dire ttt^`yw^t5M-]bb-x. Et dans la dernière partie, au lieu de supprimer les valeurs indésirables que vous pouvez utiliser &, qui indique à la fonction d'affichage implicite d'afficher uniquement le haut. Vous pouvez donc utiliser ttt^`yw^t5M-]&et enregistrer quelques octets.
— Luis Mendo
En outre, le premier tn'est pas nécessaire, et d' utiliser à la Gplace d'un autre , tvous pouvez éviter &et laisser ainsi ]implicitement: t^`Gw^t5M-. Hé, nous avons réduit le nombre d'octets de moitié!
— Luis Mendo
@LuisMendo Merci pour les bons conseils! J'ai beaucoup à apprendre sur MATL, mais j'aime vraiment ça.
— Cinaski
Content de l'entendre!
— Luis Mendo
0

Perl 6 , 17 octets

{[R**] $_ xx 999}

Essayez-le en ligne!

R**est l'opérateur d'exponentiation inverse; x R** yest égal à y ** x. [R**]réduit une liste de 999 copies de l'argument d'entrée avec exponentiation inverse.

— Sean
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.