Calcular la raíz cúbica de un número

12

El objetivo de este código de golf es crear un programa o función que calcule y genere la raíz cúbica de un número que se proporciona como entrada.
Las normas:

  • Sin recursos externos
  • No se utilizan funciones de raíz de cubo incorporadas.
  • No se utilizan métodos / operadores que puedan elevar un número a una potencia (que incluye raíz cuadrada, cuarta raíz, etc.).
  • Su función / programa debe poder aceptar números de punto flotante y números negativos como entrada.
  • Si la raíz cúbica es un número de coma flotante, redondea a 4 números después del punto decimal.
  • Este es un código de golf, gana el código más corto en bytes.

Casos de prueba:

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

Puede usar todos los casos de prueba anteriores para probar números negativos ( -27 --> -3, -64 --> -4...)

ProgramFOX
fuente
maldita sea, si permitieras solo números con un cubo preciso, tendría un buen campo de golf
yo '
1
A juzgar por sus casos de prueba, ¿supongo que el programa solo necesita lidiar con números reales?
user12205
@ace agregar complejo y cambio 2 letras en mi código;)
yo
2
¿El redondeo a 4 dígitos después del punto decimal es un requisito importante? ¿O podría ser algo así como "no es necesario que muestres más de 4 dígitos después del punto decimal"?
Victor Stafusa
Con referencia a mi respuesta usando Exp (ln (x) / 3) (y varios clones), aclare si Exp está permitido. Supongo que pow (x, 1/3) no lo es (aunque técnicamente no es una función de raíz cúbica).
Level River St

Respuestas:

6

J: 16 caracteres

Traducción suelta de la respuesta de Haskell:

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

Casos de prueba:

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

Funciona así:

     (-:@((% *~) + ])^:_)~ 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
...

En palabras:

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

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

No es una de las mejores traducciones verbales, ya que hay una bifurcación diádica y una ~derecha al final.

James Wood
fuente
19

Haskell - 35

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

Ejecuciones de ejemplo:

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

Además, si importa Data.Complex, incluso funciona en números complejos, devuelve una de las raíces del número (hay 3):

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

El :+operador debe leerse como 'más i veces'

mniip
fuente
1
Esto merece un +1. He estado refactorizando enésimas raíces generalizadas enésimas durante la última hora, y acabo de llegar al mismo resultado. Bravo.
primo
@primo Inmediatamente recordé todos los algoritmos de aproximación de la enésima raíz, y después de renunciar a la serie Taylor / Maclaurin en APL, usé esto.
mniip
Usando el método Newton que obtuve x=(2*x+n/x/x)/3, ¿puedes explicar por qué puedes usarlo x=(x+n/x/x)/2? Converge más despacio pero no puedo explicar por qué converge ...
Michael M.
@Michael porque si tomas x=cbrt(n), entonces x=(x+n/x/x)/2es cierto. Entonces, ¿es cierto para su expresión
mniip
@ Michael Llegué de esta manera: codepad.org/gwMWniZB
primo
7

SageMath, (69) 62 bytes

Sin embargo, nunca creas que te dará el resultado, es muy difícil ir al azar a través de todos los números:

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

si no insististe en truncar:

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

SageMath, 12 bytes, si expestá permitido

Funciona para todo: positivo, negativo, cero, complejo, ...

exp(ln(x)/3)
yo'
fuente
Creo que está utilizando un operador que puede elevar un número a una potencia.
usuario12205
ah ok, correcto, editado
yo '
66
+1 para un algoritmo monumentalmente estúpido que aún cumple los requisitos.
Caracol mecánico
@Mechanicalsnail Gracias. Espero que sea obvio que lo que hago es una especie de recesión: D Sin embargo, si expestá permitido, bajaré a 12 y no seré estúpido en absoluto :)
yo
Teniendo en cuenta que expes la abreviatura de "función exponencial", que es "una función cuyo valor es una constante elevada a la potencia del argumento, especialmente la función donde la constante es e", y hay "No se utilizan métodos / operadores que puede elevar un número a una potencia ", expno está permitido.
mbomb007
5

Python - 62 bytes

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

Evalúa con precisión de punto flotante completo. El método utilizado es el método de Halley . Como cada iteración produce 3 veces más dígitos correctos que la última, 99 iteraciones son un poco exageradas.

De entrada y salida:

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
primo
fuente
¿Como funciona esto?
justhalf
1
@justhalf Creo que este es el método de aproximación de Newton básicamente.
yo '
Por cierto, falla en0
yo'
Falla -2, perdón por eso.
yo '
3
@plg La descripción del problema prohíbe el uso de cualquier función exponencial, de lo contrario v**(1/.3)sería un ganador seguro.
primo
3

Javascript (55)

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

BONIFICACIÓN, formulación general para todas las raíces.
function f(n,p){for(i=x=99;i--;)x=x-(x-n/Math.pow(x,p-1))/p;return x}

Para la raíz cúbica, simplemente use f(n,3), raíz cuadrada f(n,2), etc. Ejemplo: f(1024,10)devuelve 2.

Explicación
Basado en el método de Newton:

Buscar: f(x) = x^3 - n = 0la solución es n = x^3
La derivación:f'(x) = 3*x^2

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

Pruebas

[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) 
Michael M.
fuente
Uno de los personajes más corto:function f(n){for(i=x=99;i--;)x-=(x-n/x/x)/3;return x}
copia
Puede reducirse a 47 bytesf=(n)=>eval('for(i=x=99;i--;)x=(2*x+n/x/x)/3')
Luis felipe De jesus Munoz
2

PHP - 81 bytes

Solución iterativa:

$i=0;while(($y=abs($x=$argv[1]))-$i*$i*$i>1e-4)$i+=1e-5;@print $y/$x*round($i,4);
Razvan
fuente
¿Qué sucede si intenta calcular la raíz cúbica de cero?
Victor Stafusa
Solo mostrará "0" (gracias al operador de supresión de errores - "@").
Razvan
1
0.0001puede ser reemplazado por 1e-4y 0.00001por 1e.5.
ComFreek
Esto requiere PHP <7 ( 0/0da NANen PHP 7). $i=0;es innecesario (-5 bytes. Si no fuera así, forahorraría un byte). El espacio posterior printno es necesario (-1 byte). -Rpuede guardar 3 bytes con $argn.
Titus
Guarde un par de paréntesis con while(1e-4+$i*$i*$i<$y=abs($x=$argn))(-2 bytes).
Titus
2

Perl, 92 bytes

sub a{$x=1;while($d=($x-$_[0]/$x/$x)/3,abs$d>1e-9){$x-=$d}$_=sprintf'%.4f',$x;s/\.?0*$//;$_}
  • La función adevuelve una cadena con el número sin una parte de fracción innecesaria o ceros insignificantes en el extremo derecho.

Resultado:

              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

Generado por

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;

El cálculo se basa en el método de Newton :

Cálculo

Heiko Oberdiek
fuente
2

APL - 31

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

Utiliza el hecho de que cbrt(x)=e^(ln(x)/3), pero en lugar de hacer una exponenciación ingenua , calcula e^xusando la serie Taylor / Maclaurin.

Ejecuciones de muestra:

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

Como hay una respuesta J en 16 caracteres, debo ser realmente terrible en APL ...

mniip
fuente
2

Java, 207 182 181

A veces, cuando juego al golf, tomo dos cervezas y juego realmente muy 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);}}

Método de aproximación iterativo de Newton, ejecuta 99 iteraciones.

Aquí está el no golfista:

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 );
    }
}
md_rasler
fuente
1
Puede cambiar el nombre de la argsvariable a algo como z, reduciendo 6 caracteres. Puede eliminar el espacio y las llaves en el cuerpo del bucle for, reduciendo 3 caracteres. Puede reemplazar 10000.0por 1e4, reduciendo 6 caracteres. La clase no necesita ser pública, por lo que puede reducir más 7 caracteres. De esta manera se reducirá a 185 caracteres.
Victor Stafusa
¿Es realmente necesario el reparto al final? No es para mi.
Victor Stafusa
@Victor Gracias por el buen ojo, el uso de la notación E para el doble 10000.0 fue una idea espectacularmente buena. Por el diseño de la pregunta, creo que es legítimo hacer de este un método en lugar de una clase cli que funcione, lo que reduciría el tamaño considerablemente. Con Java, no pensé que tuviera una oportunidad, así que me equivoqué del lado funcional.
md_rasler
Bienvenido a CodeGolf! ¡No olvides agregar una explicación en respuesta de cómo funciona esto!
Justin
@Quincunx, gracias, hizo el cambio recomendado.
md_rasler
2

TI-Basic, 26 24 bytes

Input :1:For(I,1,9:2Ans/3+X/(3AnsAns:End
Timtech
fuente
Eso usa directamente al ^operador, ¿no? Está prohibido por las reglas
mniip
@mniip: ¿ e^Es un solo operador en la serie TI-83? No me acuerdo De cualquier manera, está violando el espíritu de las reglas.
Caracol mecánico
@Mechanicalsnail No importa, diría. En la mayoría de los idiomas, podría hacer exp(ln(x)/3)o e^(ln(x/3))si permitiera alguno de estos dos. Pero de alguna manera entiendo que exp(ln(x)/a)es demasiado equivalente a x^(1/a)ser permitido por las reglas: - /
yo
Función exponencial: "una función cuyo valor es una constante elevada a la potencia del argumento , especialmente la función donde la constante es e". ... "No se utilizan métodos / operadores que pueden elevar un número a una potencia"
mbomb007
Gracias por la captura @ mbomb007, escribí esta respuesta hace más de 3 años y la arreglaré para cumplirla ahora.
Timtech
2

Js 57 bytes

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>

Luis felipe De jesus Munoz
fuente
2

Javascript: 73/72 caracteres

Este algoritmo es poco convincente y explota el hecho de que esta pregunta está limitada a 4 dígitos después del punto decimal. Es una versión modificada del algoritmo que sugerí en el sandbox con el propósito de reelaborar la pregunta. Cuenta desde cero hasta el infinito h*h*h<a, solo con un truco de multiplicación y división para manejar la precisión de 4 dígitos decimales.

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

Edición, 4 años después: como sugirió Luis felipe De jesus Munoz, usar **el código es más corto, pero esa característica no estaba disponible en 2014 cuando escribí esta respuesta. De todos modos, al usarlo, afeitamos un personaje adicional:

function g(a){if(a<0)return-g(-a);for(h=0;h**3<1e12*a;h++);return h/1e4}
Victor Stafusa
fuente
1
En cambio h*h*h, puede hacer h**3y guardar 1 byte
Luis felipe De jesus Munoz
@LuisfelipeDejesusMunoz Esta respuesta es de 2014. El **operador fue propuesto en 2015 y fue aceptado como parte de ECMAScript 7 en 2016. Entonces, en el momento en que escribí eso, no había **en el idioma.
Victor Stafusa
1

Javascript - 157 caracteres

Esta función:

  • Manejar números negativos.
  • Manejar números que apuntan flotando.
  • Ejecutar rápidamente para cualquier número de entrada.
  • Tiene la máxima precisión permitida para los números de coma flotante de 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}

Versión explicada de Ungolfed:

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
}
Victor Stafusa
fuente
1

PHP, 61

Basado en el método de Newton. Versión ligeramente modificada de la respuesta de Michael :

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

Funciona con números negativos, puede manejar números de coma flotante y redondea el resultado a 4 números después del punto decimal si el resultado es un número de coma flotante.

Demostración de trabajo

Amal Murali
fuente
Puede guardar dos bytes con for($x=1;++$i<100;).... Pero el uso de variables predefinidas como entrada generalmente está mal visto . Mejor uso $argv[1]o $argn.
Titus
1

Befunge 98 - Trabajo en progreso

Este lenguaje no admite números de coma flotante; esto intenta emularlos. Actualmente funciona para números positivos que no comienzan 0después del punto decimal (principalmente). Sin embargo, solo genera 2 decimales.

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

Funciona ingresando la parte antes del punto decimal, multiplicándola por 100000, luego ingresando la parte después del punto y sumando los dos números. La segunda línea hace un contador hasta que el cubo es mayor que el número ingresado. Luego, la tercera línea extrae el número decimal del entero.

Si alguien puede decirme por qué la tercera línea solo se divide 100para obtener los valores correctos, dígame.

IOs:

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
Justin
fuente
1

Smalltalk, 37

el crédito va a mniip por el algoritmo; Versión Smalltalk de su código:

entrada en n; salida en x:

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

o como un bloque

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

Lenguaje GameMaker, 51 bytes

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

Haskell: 99C

No se puede vencer a @mniip en inteligencia. Acabo de ir con una búsqueda binaria.

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

Sin 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
danmcardle
fuente
Puede usar un operador infijo para d(como (l#h)x) para guardar un byte para cada llamada. centonces se convierte id>>=(0#).
Esolanging Fruit
Puede eliminar espacios alrededor c < x.
Esolanging Fruit
Puedes usar en 1>0lugar de True.
Esolanging Fruit
0

J 28

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

Usando el método de Newton, encontrar la raíz del x^3 - Xpaso de actualización es x - (x^3 - C)/(3*x^2), donde x es la suposición actual y C la entrada. Hacer las matemáticas en este caso produce la expresión ridículamente simple de (2*x+C/x^2) /3. Se debe tener cuidado con los números negativos.

Implementado en J, de derecha a izquierda:

  1. | Toma abdominales de ambos argumentos, pásalos
  2. ^:_ Hacer hasta la convergencia
  3. (%*~@])es C / x^2( *~ yes equivalente a y * y)
  4. +:@] es 2 x
  5. 3%~dividir por tres. Esto produce la raíz positiva
  6. *@[ * positive_root multiplica la raíz positiva con el signo de C.

Prueba de funcionamiento:

   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
jpjacobs
fuente
0

AWK, 53 bytes

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

Ejemplo de uso:

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

Gracias a @Mig por la JavaScriptsolución de la que se deriva. Se ejecuta sorprendentemente rápido dado que el forciclo requiere que la iteración deje de cambiar.

Robert Benson
fuente
0

C, 69 bytes

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

Solo otra implementación del método de Newton. Pruébalo en línea!

techo
fuente
0

Stax , 10 bytes CP437

╘♀┘A╕äO¶∩'

¡Ejecute y depure en línea!

Explicación

Utiliza la versión desempaquetada para explicar.

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
Weijun Zhou
fuente
0

Solución JAVA

Public BigDecimal cubeRoot (número 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);
}
Ramanathan Ganesan
fuente
1
Bienvenido a PPCG! Este es un desafío de código de golf , lo que significa que el objetivo es resolver el desafío con el menor código posible (contado en bytes del archivo fuente). Debe mostrar cierto esfuerzo para optimizar su solución hacia ese objetivo e incluir el recuento de bytes en su respuesta.
Martin Ender
0

Solución 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)
Ramanathan Ganesan
fuente