Alors que je m'ennuyais au lycée (quand j'avais la moitié de mon âge actuel ...), j'ai trouvé que f ( x ) = x ^{( x -1 )} avait des propriétés intéressantes, y compris par exemple que le maximum f pour 0 ≤ x est f ( e ), et que l' énergie de liaison par nucléon d'un isotope peut être approchée comme 6 × f ( x ÷ 21) ...

Quoi qu'il en soit, écrivez la fonction ou le programme le plus court qui calcule la x ^ème racine de x pour n'importe quel nombre dans le domaine de votre langue.

Exemples de cas

Pour toutes les langues

     -1   >       -1
   ¯0.2   >    -3125
   ¯0.5   >        4
    0.5   >     0.25
      1   >        1
      2   >    1.414
      e   >    1.444 
      3   >    1.442
    100   >    1.047
  10000   >    1.001

Pour les langues qui gèrent des nombres complexes

   -2   >        -0.7071i
    i   >            4.81         
   2i   >    2.063-0.745i
 1+2i   >   1.820-0.1834i
 2+2i   >   1.575-0.1003i

Pour les langues qui gèrent les infinis

-1/∞   >   0    (or ∞ or ̃∞)
   0   >   0    (or 1 or ∞)
 1/∞   >   0
   ∞   >   1
  -∞   >   1

Pour les langues qui traitent à la fois les infinis et les nombres complexes

 -∞-2i   >   1      (or ̃∞)

^{̃∞désigne l' infini dirigé .}

TI-BASIC, 3 octets

Ans×√Ans

TI-BASIC utilise des jetons, donc Anset ×√sont tous les deux d'un octet.

Explication

Ansest le moyen le plus simple de fournir des informations; c'est le résultat de la dernière expression. ×√est une fonction pour la xième racine de x, donc par exemple 5×√32est 2.

Gelée, 2 octets

*İ

Essayez-le en ligne!

Comment ça marche

*İ    Main link. Input: n

 İ    Inverse; yield 1÷n.
*     Power (fork); compute n ** (1÷n).

Javascript (ES2016), 11 octets

x=>x**(1/x)

J'utilise rarement ES7 sur ES6.

Python 3, 17 octets

lambda x:x**(1/x)

Explicite

Haskell, 12 11 octets

Merci @LambdaFairy d'avoir fait de la magie:

(**)<*>(1/) 

Mon ancienne version:

\x->x**(1/x)

J, 2 octets

^%

Essayez-le en ligne! .

Comment ça marche

^%  Monadic verb. Argument: y

 %  Inverse; yield 1÷y.
^   Power (hook); compute y ** (1÷y).

Pyth, 3 octets

@QQ

Défi trivial, solution triviale ...

(non compétitif, 1 octet)

@

Cela utilise la fonction d'entrée implicite présente dans une version de Pyth qui postdate ce défi.

JavaScript ES6, 18 octets

n=>Math.pow(n,1/n)

Java 8, 18 octets

n->Math.pow(n,1/n)

Java n'est pas à la dernière place?!?!

Testez avec les éléments suivants:

import java.lang.Math;

public class Main {
  public static void main (String[] args) {
    Test test = n->Math.pow(n,1/n);
    System.out.println(test.xthRoot(6.0));
  }
}

interface Test {
  double xthRoot(double x);
}

Java, 41 octets

float f(float n){return Math.pow(n,1/n);}

Pas vraiment compétitif parce que Java, mais pourquoi pas?

MATL , 5 octets

t-1^^

Essayez-le en ligne!

t       % implicit input x, duplicate
 -1     % push -1
   ^    % power (raise x to -1): gives 1/x
    ^   % power (raise x to 1/x). Implicit display

Mathematica, 8 7 4 7 octets

#^#^-1&

Plus de réponses intégrées et maintenant encore plus courtes! Nan. Par définition, la réponse suivante doit être de 13 octets. (Fibonacci!) Le motif est encore cassé. :(

Perl 5, 10 octets

9 octets plus 1 pour -p

$_**=1/$_

R, 19 17 octets

function(x)x^x^-1

-2 octets grâce à @Flounderer

Rubis, 15 octets

a=->n{n**n**-1}

Non golfé:

->est l' opérateur lambda stabby où a=->nest équivalent àa = lambda {|n|}

NARS APL, 2 octets

√⍨

NARS prend en charge la √fonction, qui donne la ⍺-ème racine de ⍵. L'application de commute (⍨) donne une fonction qui, lorsqu'elle est utilisée de façon monadique, applique son argument aux deux côtés de la fonction donnée. Par conséquent √⍨ x↔ x √ x.

Autres APL, 3 octets

⊢*÷

Il s'agit d'un train de fonctions, c'est-à-dire (F G H) x↔ (F x) G H x. Monadique ⊢est identité, dyadique *est pouvoir et monadique ÷est inverse. Par conséquent, x⊢*÷ est élevé à 1 / x .

Python 2 - 56 octets

La première vraie réponse, si j'ai raison. Utilise la méthode de Newton.

n=x=input();exec"x-=(x**n-n)/(1.*n*x**-~n);"*999;print x

CJam, 6 octets

rd_W##

Essayez-le en ligne!

Comment ça marche

rd     e# Read a double D from STDIN and push it on the stack.
  _    e# Push a copy of D.
   W   e# Push -1.
    #  e# Compute D ** -1.
     # e# Compute D ** (D ** -1).

Sérieusement, 5 octets

,;ì@^

Essayez-le en ligne!

Explication:

,;ì@^
,;     input, dupe
  ì@   1/x, swap
    ^  pow

Pylônes , 5 octets.

ideAe

Comment ça marche.

i # Get command line input.
d # Duplicate the top of the stack.
e # Raise the top of the stack to the power of the  second to the top element of the stack.
A # Push -1 to the stack (pre initialized variable).
e # Raise the top of the stack to the power of the second to the top element of the stack.
  # Implicitly print the stack.

Japt, 3 octets

UqU

Testez-le en ligne!

Très simple: Uc'est l'entier en entrée, et qc'est la fonction racine sur les nombres.

C ++, 48 octets

#include<math.h>
[](auto x){return pow(x,1./x);}

La deuxième ligne définit une fonction lambda anonyme. Il peut être utilisé en l'affectant à un pointeur de fonction et en l'appelant, ou en l'appelant directement.

Essayez-le en ligne

Voie lactée 1.6.5 , 5 octets

'1'/h

Explication

'      ` Push input
 1     ` Push the integer literal
  '    ` Push input
   /   ` Divide the STOS by the TOS
    h  ` Push the STOS to the power of the TOS

x ** (1 / x)

Usage

$ ./mw <path-to-code> -i <input-integer>

O , 6 octets

j.1\/^

Pas de lien en ligne car l'IDE en ligne ne fonctionne pas (en particulier, l'exponentiation est rompue)

Explication:

j.1\/^
j.      push two copies of input
  1\/   push 1/input (always float division)
     ^  push pow(input, 1/input)

𝔼𝕊𝕄𝕚𝕟, 5 caractères / 7 octets

Мű⁽ïï

Try it here (Firefox only).

Banal.

Pyke (commit 29), 6 octets

D1_R^^

Explication:

D      - duplicate top
 1_    - load -1
   R   - rotate
    ^  - ^**^
     ^ - ^**^

C # - 18 43 41 octets

float a(float x){return Math.Pow(x,1/x);}

-2 byes grâce à @VoteToClose

Essaye le

Remarque:

Première tentative réelle de golf - je sais que je pourrais faire mieux.

C, 23 octets

#define p(a)pow(a,1./a)

Ceci définit une fonction macro pqui évalue à la aracine e de a.

Merci à Dennis de m'avoir rappelé qu'il gccn'est pas nécessaire math.hd'être inclus.

Merci à @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ de me rappeler que l'espace après le premier )n'est pas nécessaire.

Essayez-le en ligne

DC , 125 octets

15k?ddsk1-A 5^*sw1sn0[A 5^ln+_1^+ln1+dsnlw!<y]syr1<y1lk/*sz[si1[li*li1-dsi0<p]spli0<p]so0dsw[lzlw^lwlox/+lw1+dswA 2^!<b]dsbxp

Contrairement à l'autre réponse DC, cela fonctionne pour tous les réels xsupérieurs ou égaux à 1 ( 1 ≤ x). Précis à 4-5 places après la décimale.

J'aurais inclus un lien TIO ici, mais pour une raison quelconque, cela jette un défaut de segmentation avec la version là ( dc 1.3) alors qu'il ne le fait pas avec ma version locale ( dc 1.3.95).

Explication

Comme dcne prend pas en charge l'augmentation des nombres à des exposants non entiers à calculer x^(1/x), cela profite du fait que:

Donc, pour calculer ln(x), cela profite également du fait que:

dont l'intégrale définie de 1 to (b = x)est approximée numériquement par incréments en 10^-5utilisant la formule de sommation suivante:

.

La somme résultante est ensuite multipliée par 1/xpour obtenir ln(x)/x. e^(ln(x)/x)est ensuite finalement calculé en utilisant la e^xsérie Maclaurin à 100 termes comme suit:

.

Il en résulte notre sortie relativement précise de x^(1/x).

PHP 5.6, 32 30 29 octets

function($x){echo$x**(1/$x);}

ou

function($x){echo$x**$x**-1;}

_{30-> 29, merci Dennis!}