Le but de ce code golf est de créer un programme ou une fonction qui calcule et génère la racine cubique d'un nombre donné en entrée.
Les règles:

• Pas de ressources externes
• Aucune utilisation des fonctions de racine de cube intégrées.
• Pas d'utilisation de méthodes / opérateurs qui peuvent élever un nombre à une puissance (qui inclut la racine carrée, la 4ème racine, etc.).
• Votre fonction / programme doit pouvoir accepter des nombres à virgule flottante et des nombres négatifs en entrée.
• Si la racine du cube est un nombre à virgule flottante, arrondissez-le à 4 chiffres après la virgule décimale.
• Il s'agit d'un code golf, le code le plus court en octets gagne.

Cas de test:

27 --> 3
64 --> 4
1  --> 1
18.609625 --> 2.65
3652264 --> 154
0.001 --> 0.1
7  --> 1.9129

Vous pouvez utiliser tous les cas de test ci-dessus pour tester des nombres négatifs ( -27 --> -3, -64 --> -4...)

J: 16 caractères

Traduction lâche de la réponse Haskell:

-:@((%*~)+])^:_~

Cas de test:

   -:@((%*~)+])^:_~27
3
   -:@((%*~)+])^:_~64
4
   -:@((%*~)+])^:_~1
1
   -:@((%*~)+])^:_~18.609625
2.65
   -:@((%*~)+])^:_~3652264
154
   -:@((%*~)+])^:_~0.001
0.1
   -:@((%*~)+])^:_~7
1.91293

Cela fonctionne comme ceci:

     (-:@((% *~) + ])^:_)~ 27
↔ 27 (-:@((% *~) + ])^:_) 27
↔ 27 (-:@((% *~) + ])^:_) 27 (-:@((% *~) + ])) 27
↔ 27 (-:@((% *~) + ])^:_) -: ((27 % 27 * 27) + 27)
↔ 27 (-:@((% *~) + ])^:_) 13.5185
↔ 27 (-:@((% *~) + ])^:_) 27 (-:@((% *~) + ])) 13.5185
↔ 27 (-:@((% *~) + ])^:_) -: ((27 % 13.5185 * 13.5185) + 13.5185)
↔ 27 (-:@((% *~) + ])^:_) 6.83313
...

Dans les mots:

half =. -:
of =. @
divideBy =. %
times =. *
add =. +
right =. ]
iterate =. ^:
infinite =. _
fixpoint =. iterate infinite
by_self =. ~

-:@((%*~)+])^:_~ ↔ half of ((divideBy times by_self) add right) fixpoint by_self

Pas l'une des meilleures traductions verbeuses, car il y a une fourchette dyadique et un ~droit à la fin.

Haskell - 35

c n=(iterate(\x->(x+n/x/x)/2)n)!!99

L'exemple s'exécute:

c 27  =>  3.0
c 64  =>  4.0
c 1  =>  1.0
c 18.609625  =>  2.6500000000000004  # only first 4 digits are important, right?
c 3652264  =>  154.0
c 0.001  =>  0.1
c 7  =>  1.9129311827723892
c (-27)  =>  -3.0
c (-64)  =>  -4.0

De plus, si vous importez Data.Complex, cela fonctionne même sur des nombres complexes, il renvoie une des racines du nombre (il y en a 3):

c (18:+26)  =>  3.0 :+ 1.0

L' :+opérateur doit être lu comme «plus i fois»

SageMath, (69) 62 octets

Cependant, ne croyez jamais que cela vous donnera le résultat, il est très difficile de parcourir tous les chiffres au hasard:

def r(x):
 y=0
 while y*y*y-x:y=RR.random_element()
 return "%.4f"%y

si vous n'avez pas insisté pour tronquer:

def r(x):
 y=0
 while y*y*y-x:y=RR.random_element()
 return y

SageMath, 12 octets, si expautorisé

Fonctionne pour tout: positif, négatif, zéro, complexe, ...

exp(ln(x)/3)

Python - 62 octets

x=v=input()
exec"x*=(2.*v+x*x*x)/(v+2*x*x*x or 1);"*99;print x

Évalue la précision en virgule flottante complète. La méthode utilisée est la méthode de Halley . Comme chaque itération produit 3 fois plus de chiffres corrects que la dernière, 99 itérations est un peu exagéré.

Entrée sortie:

27 -> 3.0
64 -> 4.0
1 -> 1.0
18.609625 -> 2.65
3652264 -> 154.0
0.001 -> 0.1
7 -> 1.91293118277
0 -> 1.57772181044e-30
-2 -> -1.25992104989

Javascript (55)

function f(n){for(i=x=99;i--;)x=(2*x+n/x/x)/3;return x}

BONUS, Formulation générale pour toutes les racines
function f(n,p){for(i=x=99;i--;)x=x-(x-n/Math.pow(x,p-1))/p;return x}

Pour la racine cubique, utilisez simplement f(n,3), racine carrée f(n,2), etc ... Exemple: f(1024,10)retourne 2.

Explication
Basée sur la méthode Newton:

Trouver:, f(x) = x^3 - n = 0la solution est n = x^3
la dérivation:f'(x) = 3*x^2

Itérer:
x(i+1) = x(i) - f(x(i))/f'(x(i)) = x(i) + (2/3)*x + (1/3)*n/x^2

Les tests

[27,64,1,18.609625,3652264,0.001,7].forEach(function(n){console.log(n + ' (' + -n + ') => ' + f(n) + ' ('+ f(-n) +')')})

27 (-27) => 3 (-3)
64 (-64) => 4 (-4)
1 (-1) => 1 (-1)
18.609625 (-18.609625) => 2.65 (-2.65)
3652264 (-3652264) => 154 (-154)
0.001 (-0.001) => 0.09999999999999999 (-0.09999999999999999)
7 (-7) => 1.912931182772389 (-1.912931182772389) 

PHP - 81 octets

Solution itérative:

$i=0;while(($y=abs($x=$argv[1]))-$i*$i*$i>1e-4)$i+=1e-5;@print $y/$x*round($i,4);

Perl, 92 octets

sub a{$x=1;while($d=($x-$_[0]/$x/$x)/3,abs$d>1e-9){$x-=$d}$_=sprintf'%.4f',$x;s/\.?0*$//;$_}

• La fonction arenvoie une chaîne avec le nombre sans partie de fraction inutile ou zéros insignifiants à l'extrémité droite.

Résultat:

              27 --> 3
             -27 --> -3
              64 --> 4
             -64 --> -4
               1 --> 1
              -1 --> -1
       18.609625 --> 2.65
      -18.609625 --> -2.65
         3652264 --> 154
        -3652264 --> -154
           0.001 --> 0.1
          -0.001 --> -0.1
               7 --> 1.9129
              -7 --> -1.9129
 0.0000000000002 --> 0.0001
-0.0000000000002 --> -0.0001
               0 --> 0
              -0 --> 0

Généré par

sub test{
    my $a = shift;
    printf "%16s --> %s\n", $a, a($a);
    printf "%16s --> %s\n", "-$a", a(-$a);
}
test 27;
test 64;
test 1;
test 18.609625;
test 3652264;
test 0.001;
test 7;
test "0.0000000000002";
test 0;

Le calcul est basé sur la méthode de Newton :

APL - 31

(×X)×+/1,(×\99⍴(⍟|X←⎕)÷3)÷×\⍳99

Utilise le fait que cbrt(x)=e^(ln(x)/3), mais au lieu de faire une ⋆exponentiation naïve , il calcule en e^xutilisant la série Taylor / Maclaurin.

Exemples de cycles:

⎕: 27
3
⎕: 64
4
⎕: 1
1
⎕: 18.609625
2.65
⎕: 3652264
154
⎕: 0.001
0.1
⎕: 7
1.912931183
⎕: ¯27
¯3
⎕: ¯7
¯1.912931183

Vu qu'il y a une réponse J en 16 caractères, je dois être vraiment terrible à APL ...

Java, 207 182 181

Parfois, quand je joue au golf, j'ai deux bières et je joue vraiment très mal

class n{public static void main(String[]a){double d=Double.valueOf(a[0]);double i=d;for(int j=0;j<99;j++)i=(d/(i*i)+(2.0*i))/3.0;System.out.println((double)Math.round(i*1e4)/1e4);}}

La méthode d'approximation itérative de Newton exécute 99 itérations.

Voici les non golfés:

class n{
    public static void main(String a[]){
        //assuming the input value is the first parameter of the input
        //arguments as a String, get the Double value of it
        double d=Double.valueOf(a[0]);
        //Newton's method needs a guess at a starting point for the 
        //iterative approximation, there are much better ways at 
        //going about this, but this is by far the simplest. Given
        //the nature of the problem, it should suffice fine with 99 iterations
        double i=d;

        //make successive better approximations, do it 99 times
        for(int j=0;j<99;j++){
            i=( (d/(i*i)) + (2.0*i) ) / 3.0;
        }
        //print out the answer to standard out
        //also need to round off the double to meet the requirements
        //of the problem.  Short and sweet method of rounding:
        System.out.println( (double)Math.round(i*10000.0) / 10000.0 );
    }
}

TI-Basic, 26 24 octets

Input :1:For(I,1,9:2Ans/3+X/(3AnsAns:End

Js 57 octets

f=(x)=>eval('for(w=0;w**3<1e12*x;w++);x<0?-f(-x):w/1e4')

f=(x)=>eval('for(w=0;w**3<1e12*x;w++);x<0?-f(-x):w/1e4')
document.getElementById('div').innerHTML += f(-27) + '<br>'
document.getElementById('div').innerHTML += f(-64) + '<br>'
document.getElementById('div').innerHTML += f(-1) + '<br>'
document.getElementById('div').innerHTML += f(-18.609625) + '<br>'
document.getElementById('div').innerHTML += f(-3652264) + '<br>'
document.getElementById('div').innerHTML += f(-0.001) + '<br>'
document.getElementById('div').innerHTML += f(-7) + '<br><hr>'
document.getElementById('div').innerHTML += f(27) + '<br>'
document.getElementById('div').innerHTML += f(64) + '<br>'
document.getElementById('div').innerHTML += f(1) + '<br>'
document.getElementById('div').innerHTML += f(18.609625) + '<br>'
document.getElementById('div').innerHTML += f(3652264) + '<br>'
document.getElementById('div').innerHTML += f(0.001) + '<br>'
document.getElementById('div').innerHTML += f(7) + '<br>'

<div id="div"></div>

Javascript: 73/72 caractères

Cet algorithme est boiteux et exploite le fait que cette question est limitée à 4 chiffres après la virgule décimale. Il s'agit d'une version modifiée de l'algorithme que j'ai suggérée dans le bac à sable afin de retravailler la question. Il compte de zéro à l'infini h*h*h<a, juste avec une astuce de multiplication et de division pour gérer la précision des 4 chiffres décimaux.

function g(a){if(a<0)return-g(-a);for(h=0;h*h*h<1e12*a;h++);return h/1e4}

Edit, 4 ans plus tard: Comme suggéré par Luis felipe De jesus Munoz, en utilisant **le code est plus court, mais cette fonctionnalité n'était pas disponible en 2014 lorsque j'ai écrit cette réponse. Quoi qu'il en soit, en l'utilisant, nous nous rasons un caractère supplémentaire:

function g(a){if(a<0)return-g(-a);for(h=0;h**3<1e12*a;h++);return h/1e4}

Javascript - 157 caractères

Cette fonction:

• Gérez les nombres négatifs.
• Gérer les nombres à virgule flottante.
• Exécutez rapidement pour n'importe quel numéro d'entrée.
• Possède la précision maximale autorisée pour les nombres à virgule flottante javascript.

function f(a){if(p=q=a<=1)return a<0?-f(-a):a==0|a==1?a:1/f(1/a);for(v=u=1;v*v*v<a;v*=2);while(u!=p|v!=q){p=u;q=v;k=(u+v)/2;if(k*k*k>a)v=k;else u=k}return u}

Version expliquée non golfée:

function f(a) {
  if (p = q = a <= 1) return a < 0 ? -f(-a)      // if a < 0, it is the negative of the positive cube root.
                           : a == 0 | a == 1 ? a // if a is 0 or 1, its cube root is too.
                           : 1 / f (1 / a);      // if a < 1 (and a > 0) invert the number and return the inverse of the result.

  // Now, we only need to handle positive numbers > 1.

  // Start u and v with 1, and double v until it becomes a power of 2 greater than the given number.
  for (v = u = 1; v * v * v < a; v *= 2);

  // Bisects the u-v interval iteratively while u or v are changing, which means that we still did not reached the precision limit.
  // Use p and q to keep track of the last values of u and v so we are able to detect the change.
  while (u != p | v != q) {
    p = u;
    q = v;
    k = (u + v) / 2;
    if (k * k * k > a)
      v=k;
    else
      u=k
  }

  // At this point u <= cbrt(a) and v >= cbrt(a) and they are the closest that is possible to the true result that is possible using javascript-floating point precision.
  // If u == v then we have an exact cube root.
  // Return u because if u != v, u < cbrt(a), i.e. it is rounded towards zero.
  return u
}

PHP, 61

Basé sur la méthode de Newton. Version légèrement modifiée de la réponse de Michael :

for($i=$x=1;$i++<99;)$x=(2*$x+$n/$x/$x)/3;echo round($x,14);

Il fonctionne avec des nombres négatifs, peut gérer des nombres à virgule flottante et arrondit le résultat à 4 nombres après la virgule décimale si le résultat est un nombre à virgule flottante.

Démo de travail

Befunge 98 - Travaux en cours

Cette langue ne prend pas en charge les nombres à virgule flottante; cela tente de les imiter. Il fonctionne actuellement pour les nombres positifs qui ne commencent pas par ( 0après la virgule décimale) (principalement). Cependant, il ne produit que 2 décimales.

&5ka5k*&+00pv
:::**00g`!jv>1+
/.'.,aa*%.@>1-:aa*

Il fonctionne en saisissant la pièce avant le point décimal, en multipliant cela par 100000, puis en saisissant la pièce après le point et en additionnant les deux nombres. La deuxième ligne fait un compteur jusqu'à ce que le cube soit supérieur au nombre entré. Ensuite, la troisième ligne extrait le nombre décimal de l'entier.

Si quelqu'un peut me dire pourquoi la troisième ligne se divise uniquement 100pour obtenir les valeurs correctes, veuillez me le dire.

OI:

27.0       3 .0
64.0       4 .0
1.0        1 .0
18.609625  2 .65
0.001      0 .1
7.0        1 .91

0.1        0 .1

Smalltalk, 37

le mérite revient à mniip pour l'algorithme; Version Smalltalk de son code:

entrée en n; sortie en x:

1to:(x:=99)do:[:i|x:=2*x+(n/x/x)/3.0]

ou, en bloc

[:n|1to:(x:=99)do:[:i|x:=2*x+(n/x/x)/3.0].x]

Langue GameMaker, 51 octets

for(i=x=1;i++<99;1)x=(2*x+argument0/x/x)/3;return x

Haskell: 99C

Impossible de battre @mniip en intelligence. Je suis juste allé avec une recherche binaire.

c x=d 0 x x
d l h x
 |abs(x-c)<=t=m
 |c < x=d m h x
 |True=d l m x
 where m=(l+h)/2;c=m*m*m;t=1e-4

Non golfé:

-- just calls the helper function below
cubeRoot x = cubeRoot' 0 x x

cubeRoot' lo hi x
    | abs(x-c) <= tol = mid           -- if our guess is within the tolerance, accept it
    | c < x = cubeRoot' mid hi x      -- shot too low, narrow our search space to upper end
    | otherwise = cubeRoot' lo mid x  -- shot too high, narrow search space to lower end
    where
        mid = (lo+hi)/2
        cubed = mid*mid*mid
        tol = 0.0001

J 28

*@[*(3%~+:@]+(%*~@]))^:_&|&1

En utilisant la méthode Newtons, trouver la racine de x^3 - Xl'étape de mise à jour est x - (x^3 - C)/(3*x^2), où x est la supposition actuelle et C l'entrée. Faire le calcul sur celui-ci donne l'expression ridiculement simple de (2*x+C/x^2) /3. Il faut faire attention aux nombres négatifs.

Implémenté en J, de droite à gauche:

1. | Prenez les abdos des deux arguments, transmettez-les
2. ^:_ Faire jusqu'à la convergence
3. (%*~@])est C / x^2( *~ yest équivalent à y * y)
4. +:@] est 2 x
5. 3%~divisez par trois. Cela donne la racine positive
6. *@[ * positive_root multiplie la racine positive par le signe de C.

Essai:

   NB. give it a name:
   c=: *@[*(3%~+:@]+(%*~@]))^:_&|&1
   c 27 64 1 18.609625 3652264 0.001 7
3 4 1 2.65 154 0.1 1.91293

AWK, 53 octets

{for(n=x=$1;y-x;){y=x;x=(2*x+n/x/x)/3}printf"%.4g",y}

Exemple d'utilisation:

$ awk '{for(n=x=$1;y-x;){y=x;x=(2*x+n/x/x)/3}printf"%.4g",y}' <<< 18.609625 
2.65$

Merci à @Mig pour la JavaScriptsolution dont elle dérive. Il s'exécute étonnamment rapidement étant donné que la forboucle nécessite l'itération pour arrêter de changer.

C, 69 octets

i;float g(float x){for(float y=x;++i%999;x=x*2/3+y/3/x/x);return x;}

Juste une autre implémentation de la méthode de Newton. Essayez-le en ligne!

Stax , 10 octets ^CP437

╘♀┘A╕äO¶∩'

Exécutez et déboguez en ligne!

Explication

Utilise la version décompressée pour expliquer.

gpJux*_+h4je
gp              Iterate until a fixed point is found, output the fix point
  Ju            Inverse of square
    x*          Multiplied by input
      _+h       Average of the value computed by last command and the value at current iteration
         4je    Round to 4 decimal digits

Solution JAVA

public BigDecimal cubeRoot (nombre BigDecimal) {

    if(number == null || number.intValue() == 0) return BigDecimal.ZERO;
    BigDecimal absNum = number.abs();
    BigDecimal t;
    BigDecimal root =  absNum.divide(BigDecimal.valueOf(3), MathContext.DECIMAL128);


    do {

        t = root;
        root = root.multiply(BigDecimal.valueOf(2))
                .add(absNum.divide(root.multiply(root), MathContext.DECIMAL128))
                .divide(BigDecimal.valueOf(3), MathContext.DECIMAL128);

    } while (t.toBigInteger().subtract(root.toBigInteger()).intValue() != 0);

    return root.multiply(number.divide(absNum), MathContext.DECIMAL128);
}

Solution Python

def cube_root(num):
    if num == 0:
        return 0

    t = 0
    absNum = abs(num)
    root = absNum/3

    while (t - root) != 0:
        t = root
        root = (1/3) * ((2 * root) + absNum/(root * root))

    return root * (num / absNum)