Tujuan golf kode ini adalah untuk membuat program atau fungsi yang menghitung dan mengeluarkan akar pangkat tiga dari angka yang diberikan sebagai input.
Aturan:

• Tidak ada sumber daya eksternal
• Tidak menggunakan fungsi akar pangkat tiga bawaan.
• Tidak menggunakan metode / operator yang dapat meningkatkan angka ke daya (yang mencakup akar kuadrat, akar ke-4, dll.).
• Fungsi / program Anda harus dapat menerima angka titik-mengambang dan angka negatif sebagai input.
• Jika akar pangkat tiga adalah angka floating-point, maka bulatkan ke 4 angka setelah titik desimal.
• Ini adalah kode golf, kode terpendek dalam byte menang.

Kasus uji:

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

Anda dapat menggunakan semua kasus uji di atas untuk menguji angka negatif ( -27 --> -3, -64 --> -4...)

J: 16 karakter

Terjemahan Haskell yang longgar:

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

Kasus uji:

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

Ini berfungsi seperti ini:

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

Dalam kata kata:

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

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

Bukan salah satu terjemahan bertele-tele terbaik, karena ada garpu diad dan ~hak di akhir.

Haskell - 35

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

Contoh berjalan:

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

Selain itu, jika Anda mengimpor Data.Complex, itu bahkan berfungsi pada bilangan kompleks, ia mengembalikan salah satu akar bilangan (ada 3):

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

The :+Operator harus dibaca sebagai 'ditambah i kali'

SageMath, (69) 62 byte

Namun, jangan pernah percaya itu akan memberi Anda hasilnya, sangat sulit untuk melewati semua angka secara acak:

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

jika Anda tidak bersikeras memotong:

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

SageMath, 12 byte, jika expdiizinkan

Berfungsi untuk semua hal: positif, negatif, nol, kompleks, ...

exp(ln(x)/3)

Python - 62 byte

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

Mengevaluasi ke presisi titik mengambang penuh. Metode yang digunakan adalah metode Halley . Karena setiap iterasi menghasilkan 3 kali lebih banyak digit yang benar daripada yang terakhir, 99 iterasi sedikit berlebihan.

Input output:

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, formulasi umum untuk semua akar
function f(n,p){for(i=x=99;i--;)x=x-(x-n/Math.pow(x,p-1))/p;return x}

Untuk root cube, cukup gunakan f(n,3), root kuadrat f(n,2), dll ... Contoh: f(1024,10)mengembalikan 2.

Penjelasan
Berdasarkan metode Newton:

Cari f(x) = x^3 - n = 0:, solusinya adalah n = x^3
Derivasi:f'(x) = 3*x^2

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

Tes

[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 byte

Solusi berulang:

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

Perl, 92 byte

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

• Fungsi amengembalikan string dengan nomor tanpa bagian fraksi yang tidak perlu atau nol yang tidak signifikan di ujung kanan.

Hasil:

              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

Dihasilkan oleh

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;

Perhitungan didasarkan pada metode Newton :

APL - 31

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

Menggunakan fakta bahwa cbrt(x)=e^(ln(x)/3), tetapi bukannya melakukan ⋆eksponensial naif , itu menghitung e^xmenggunakan seri Taylor / Maclaurin.

Sampel berjalan:

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

Melihat ada jawaban J dalam 16 karakter, saya pasti sangat buruk di APL ...

Jawa, 207 182 181

Kadang-kadang ketika saya bermain golf, saya memiliki dua bir dan bermain sangat buruk

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

Metode Pendekatan Iteratif Newton, menjalankan 99 iterasi.

Inilah yang belum disatukan:

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 byte

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

Js 57 byte

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 karakter

Algoritma ini lumpuh, dan mengeksploitasi fakta bahwa pertanyaan ini dibatasi hingga 4 digit setelah titik desimal. Ini adalah versi modifikasi dari algoritma yang saya sarankan di kotak pasir untuk tujuan pengerjaan ulang pertanyaan. Itu dihitung dari nol hingga tak terbatas h*h*h<a, hanya dengan trik perkalian dan pembagian untuk menangani pecahan 4 angka desimal.

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

Sunting, 4 tahun kemudian: Seperti yang disarankan oleh Luis felipe De jesus Munoz, dengan menggunakan **kode lebih pendek, tetapi fitur itu tidak tersedia pada tahun 2014 ketika saya menulis jawaban ini. Bagaimanapun, dengan menggunakannya, kami mencukur karakter tambahan:

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

Javascript - 157 karakter

Fungsi ini:

• Tangani angka negatif.
• Tangani angka-angka yang mengambang.
• Jalankan dengan cepat untuk nomor input apa pun.
• Memiliki ketelitian maksimum yang diizinkan untuk angka javascript floating-point.

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 yang dijelaskan 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

Berdasarkan metode Newton. Versi Michael jawaban yang sedikit dimodifikasi :

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

Ia bekerja dengan angka negatif, dapat menangani angka floating point, dan membulatkan hasilnya menjadi 4 angka setelah titik desimal jika hasilnya adalah angka floating point.

Demo kerja

Befunge 98 - Pekerjaan sedang berlangsung

Bahasa ini tidak mendukung angka floating point; ini mencoba untuk meniru mereka. Saat ini berfungsi untuk angka positif yang tidak dimulai dengan 0setelah titik desimal (kebanyakan). Namun, itu hanya menghasilkan 2 tempat desimal.

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

Ia bekerja dengan memasukkan bagian sebelum titik desimal, mengalikannya dengan 100000, kemudian memasukkan bagian setelah titik dan menambahkan dua angka bersamaan. Baris kedua melakukan penghitung sampai kubus lebih besar dari angka yang dimasukkan. Kemudian baris ketiga mengekstrak angka desimal dari bilangan bulat.

Jika ada yang bisa memberi tahu saya mengapa baris ketiga hanya dibagi 100untuk mendapatkan nilai yang benar, tolong beri tahu saya.

IO:

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

kredit jatuh ke mniip untuk algoritme; Versi Smalltalk dari kodenya:

masukan dalam n; output dalam x:

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

atau, sebagai blok

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

Bahasa GameMaker, 51 byte

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

Haskell: 99C

Tidak bisa mengalahkan @mniip dalam kepintaran. Saya hanya pergi dengan pencarian biner.

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

Tidak Disatukan:

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

Menggunakan metode Newtons, menemukan akar dari x^3 - Xlangkah pembaruan adalah x - (x^3 - C)/(3*x^2), di mana x adalah dugaan saat ini, dan C input. Melakukan perhitungan matematika yang satu ini menghasilkan ekspresi sederhana yang sangat sederhana (2*x+C/x^2) /3. Perawatan harus diambil untuk angka negatif.

Diimplementasikan dalam J, dari kanan ke kiri:

1. | Ambil abs dari kedua argumen, teruskan
2. ^:_ Lakukan sampai konvergensi
3. (%*~@])adalah C / x^2( *~ ysetara dengan y * y)
4. +:@] adalah 2 x
5. 3%~mempertiga. Ini menghasilkan akar positif
6. *@[ * positive_root mengalikan akar positif dengan signum C.

Uji coba:

   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 byte

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

Contoh penggunaan:

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

Terima kasih buka @Mig untuk JavaScriptsolusi dari mana ini berasal. Ini berjalan sangat cepat mengingat bahwa forloop membutuhkan iterasi untuk berhenti berubah.

C, 69 byte

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

Hanya implementasi lain dari metode Newton. Cobalah online!

Stax , 10 byte ^CP437

╘♀┘A╕äO¶∩'

Jalankan dan debug online!

Penjelasan

Gunakan versi yang belum dibongkar untuk menjelaskan.

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

Solusi JAWA

kubus BigDecimal publik (Nomor 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);
}

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