เป้าหมายของการเล่นกอล์ฟรหัสนี้คือการสร้างโปรแกรมหรือฟังก์ชั่นที่คำนวณและส่งออกรูทคิวบ์ของตัวเลขที่ได้รับเป็นอินพุต
กฎระเบียบ:

• ไม่มีทรัพยากรภายนอก
• ไม่มีการใช้ฟังก์ชันรูตคิวบ์ในตัว
• ไม่มีการใช้วิธีการ / ตัวดำเนินการที่สามารถเพิ่มจำนวนเป็นพลังงาน (ซึ่งรวมถึงรากที่สองรากที่สี่เป็นต้น)
• ฟังก์ชั่น / โปรแกรมของคุณจะต้องสามารถยอมรับตัวเลขทศนิยมและจำนวนลบเป็นอินพุต
• ถ้ารูทคิวบ์เป็นตัวเลขทศนิยมให้ปัดเศษเป็น 4 ตัวเลขหลังจุดทศนิยม
• นี่คือรหัสกอล์ฟรหัสที่สั้นที่สุดเป็นไบต์ชนะ

กรณีทดสอบ:

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

คุณสามารถใช้กรณีทดสอบทั้งหมดข้างต้นเพื่อทดสอบจำนวนลบ ( -27 --> -3, -64 --> -4... )

J: 16 ตัวอักษร

คำแปลที่หลวมของคำตอบ Haskell:

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

กรณีทดสอบ:

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

มันทำงานได้เช่นนี้:

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

ในคำ:

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

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

ไม่ใช่หนึ่งในคำแปลที่ดีที่สุดเนื่องจากมีส้อมย้อมและ~ขวาที่ท้าย

Haskell - 35

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

ตัวอย่างการทำงาน:

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

ยิ่งไปกว่านั้นถ้าคุณนำเข้าData.Complexมันสามารถใช้งานได้กับจำนวนเชิงซ้อนมันจะส่งกลับหนึ่งในรากของจำนวน (มี 3):

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

:+ผู้ประกอบการควรจะอ่านเป็น 'บวกฉันครั้ง'

SageMath (69) 62 ไบต์

อย่างไรก็ตามไม่เคยเชื่อว่าจะให้ผลลัพธ์กับคุณมันเป็นเรื่องยากมากที่จะสุ่มเลือกตัวเลขทั้งหมด:

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

หากคุณไม่ได้ยืนยันที่จะตัดทอน:

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

SageMath ขนาด 12 ไบต์หากexpได้รับอนุญาต

ใช้งานได้กับทุกสิ่ง: บวกลบศูนย์ซับซ้อน ...

exp(ln(x)/3)

Python - 62 ไบต์

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

ประเมินความแม่นยำจุดลอยตัวแบบเต็ม วิธีการที่ใช้เป็นวิธีการที่ฮัลเลย์ เนื่องจากการวนซ้ำแต่ละครั้งจะผลิตตัวเลขที่ถูกต้อง 3 ครั้งมากที่สุดเท่าที่ผ่านมาการทำซ้ำ99ครั้งเป็นบิตที่มากเกินไป

อินพุต / เอาต์พุต:

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}

โบนัสสูตรทั่วไปสำหรับทุกราก
function f(n,p){for(i=x=99;i--;)x=x-(x-n/Math.pow(x,p-1))/p;return x}

สำหรับรากที่สามเพียงแค่ใช้f(n,3)รากตารางf(n,2)ฯลฯ ... ตัวอย่าง: ผลตอบแทนf(1024,10)2

คำอธิบาย
ตามวิธีการของนิวตัน:

ค้นหา: f(x) = x^3 - n = 0โซลูชันคือn = x^3
The derivation:f'(x) = 3*x^2

พูดซ้ำ:
x(i+1) = x(i) - f(x(i))/f'(x(i)) = x(i) + (2/3)*x + (1/3)*n/x^2

การทดสอบ

[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 ไบต์

โซลูชั่นซ้ำ:

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

Perl, 92 ไบต์

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

• ฟังก์ชันaส่งคืนสตริงที่มีตัวเลขโดยไม่มีส่วนที่ไม่จำเป็นหรือเลขศูนย์ที่ไม่มีนัยสำคัญที่ปลายด้านขวา

ผลลัพธ์:

              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

ที่สร้างขึ้นโดย

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;

การคำนวณขึ้นอยู่กับวิธีของนิวตัน :

APL - 31

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

ใช้ความจริงที่ว่าcbrt(x)=e^(ln(x)/3)แต่แทนที่จะทำการ⋆ยกกำลังไร้เดียงสามันคำนวณe^xโดยใช้ซีรีส์เทย์เลอร์ / Maclaurin

ตัวอย่างการวิ่ง:

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

เมื่อเห็นว่ามีคำตอบ Jใน 16 ตัวอักษรฉันต้องเป็นคนที่แย่มากที่ APL ...

Java, 207 182 181

บางครั้งเมื่อฉันเล่นกอล์ฟฉันมีสองเบียร์มากมายและเล่นได้แย่จริงๆ

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

วิธีการประมาณค่าซ้ำของนิวตันทำซ้ำได้ 99 ครั้ง

นี่คือ unGolfed:

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 ไบต์

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

Js 57 ไบต์

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 ตัวอักษร

อัลกอริทึมนี้เป็นง่อยและใช้ประโยชน์จากความจริงที่ว่าคำถามนี้ถูก จำกัด ไว้ที่ 4 หลักหลังจุดทศนิยม มันเป็นอัลกอริธึมที่แก้ไขซึ่งฉันแนะนำในกล่องทรายเพื่อแก้ไขคำถาม มันนับจากศูนย์ถึงไม่มีที่สิ้นสุดในขณะที่h*h*h<aเพียงแค่มีเคล็ดลับการคูณและการหารเพื่อจัดการ pecision ทศนิยม 4 หลัก

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

แก้ไข 4 ปีต่อมา: ตามคำแนะนำของ Luis felipe De jesus Munoz โดยใช้**รหัสสั้นกว่านี้ แต่ฟีเจอร์นั้นไม่พร้อมใช้งานในปี 2014 เมื่อฉันเขียนคำตอบนี้ อย่างไรก็ตามโดยการใช้มันเราโกนอักขระพิเศษ:

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

Javascript - 157 ตัวอักษร

ฟังก์ชั่นนี้:

• จัดการกับจำนวนลบ
• จัดการหมายเลขชี้ลอย
• ดำเนินการอย่างรวดเร็วสำหรับหมายเลขอินพุตใด ๆ
• มีความแม่นยำสูงสุดที่อนุญาตสำหรับหมายเลขทศนิยมของจาวาสคริปต์

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}

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

ตามวิธีของนิวตัน คำตอบของ Michaelเวอร์ชันดัดแปลงเล็กน้อย:

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

ทำงานร่วมกับตัวเลขลบสามารถจัดการกับตัวเลขทศนิยมและปัดเศษผลลัพธ์เป็นตัวเลข 4 หลังจุดทศนิยมถ้าผลลัพธ์นั้นเป็นตัวเลขทศนิยม

สาธิตการทำงาน

Befunge 98 - กำลังดำเนินการ

ภาษานี้ไม่รองรับหมายเลขทศนิยม ความพยายามที่จะเลียนแบบพวกเขา ปัจจุบันใช้งานได้กับจำนวนบวกที่ไม่ได้ขึ้นต้นด้วย0จุดทศนิยม (ส่วนใหญ่) อย่างไรก็ตามมันจะแสดงผลเป็นทศนิยม 2 ตำแหน่งเท่านั้น

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

มันทำงานได้โดยการใส่ชิ้นส่วนก่อนจุดทศนิยมคูณด้วย100000แล้วใส่ส่วนหลังจุดและเพิ่มตัวเลขทั้งสองเข้าด้วยกัน บรรทัดที่สองทำตัวนับจนกว่าคิวบ์จะมากกว่าจำนวนที่ป้อน จากนั้นบรรทัดที่สามจะแยกตัวเลขทศนิยมออกจากจำนวนเต็ม

หากใครสามารถบอกฉันได้ว่าทำไมบรรทัดที่สามหารด้วย100เพื่อให้ได้ค่าที่ถูกต้องเท่านั้นโปรดบอกฉัน

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

สมอลล์ทอล์ค, 37

เครดิตไปที่ mniip สำหรับอัลกอริทึม; รหัส Smalltalk ของรหัสของเขา:

อินพุตใน n; เอาต์พุตใน x:

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

หรือเป็นบล็อก

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

GameMaker Language, 51 ไบต์

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

Haskell: 99C

ไม่สามารถเอาชนะ @mniip ด้วยความฉลาดได้ ฉันเพิ่งไปกับการค้นหาแบบไบนารี

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

Ungolfed:

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

ใช้วิธีการของนิวตันค้นหารากของx^3 - Xขั้นตอนการอัพเดทx - (x^3 - C)/(3*x^2)โดยที่ x คือการเดาปัจจุบันและ C อินพุต (2*x+C/x^2) /3ทำคณิตศาสตร์ในนี้อัตราผลตอบแทนการแสดงออกขันง่ายของ จะต้องมีการระมัดระวังสำหรับจำนวนลบ

มีการใช้งานใน J จากขวาไปซ้าย:

1. | ใช้ทั้งสองข้อโต้แย้งส่งผ่าน
2. ^:_ ทำจนกระทั่งบรรจบกัน
3. (%*~@])คือC / x^2( *~ yเทียบเท่าy * y)
4. +:@] คือ 2 x
5. 3%~หารด้วยสาม สิ่งนี้ให้ผลบวกราก
6. *@[ * positive_root คูณค่าบวกกับรากของซี

ทดสอบการทำงาน:

   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 ไบต์

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

ตัวอย่างการใช้งาน:

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

ขอบคุณไปที่ @Mig สำหรับJavaScriptวิธีแก้ปัญหาซึ่งได้มาจาก มันทำงานได้อย่างน่าประหลาดใจอย่างรวดเร็วเนื่องจากการforวนซ้ำต้องหยุดซ้ำเพื่อหยุดการเปลี่ยนแปลง

C, 69 ไบต์

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

การใช้วิธีการของนิวตันอีกอย่างหนึ่ง ลองออนไลน์!

Stax , 10 ไบต์^CP437

╘♀┘A╕äO¶∩'

เรียกใช้และแก้ไขข้อบกพร่องออนไลน์!

คำอธิบาย

ใช้เวอร์ชันที่คลายการบีบอัดเพื่ออธิบาย

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

โซลูชั่น JAVA

public BigDecimal cubeRoot (หมายเลข 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);
}

Python Solution

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)