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...)

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.

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'

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)

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

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) 

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);

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 :

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 ...

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 );
    }
}

TI-Basic, 26 24 bytes

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

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>

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}

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
}

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

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

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]

Lenguaje GameMaker, 51 bytes

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

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

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

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.

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!

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

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);
}

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)