Bu kod golfünün amacı, girdi olarak verilen bir sayının küp kökünü hesaplayan ve çıkaran bir program veya işlev oluşturmaktır.
Kurallar:

• Harici kaynak yok
• Yerleşik küp kök işlevlerini kullanmaz.
• Bir sayıyı bir güce (kare kök, 4. kök vb. İçeren) yükseltebilecek yöntem / işleçler kullanılmaz.
• İşleviniz / programınız kayan noktalı sayıları ve negatif sayıları girdi olarak kabul edebilmelidir.
• Küp kökü bir kayan noktalı sayı ise, ondalık noktadan sonra 4 sayıya yuvarlayın.
• Bu bir kod golf, bayt en kısa kod kazanır.

Test senaryoları:

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

Negatif sayıları test etmek için yukarıdaki tüm test senaryolarını kullanabilirsiniz ( -27 --> -3, -64 --> -4...)

J: 16 karakter

Haskell cevabının gevşek çevirisi:

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

Test senaryoları:

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

Şöyle çalışır:

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

Kelimelerle:

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

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

En iyi kelime çevirilerinden biri değil, çünkü ikili bir çatal ve ~sonunda bir sağ var.

Haskell - 35

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

Örnek çalıştırmalar:

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

Dahası, içe aktarırsanız Data.Complex, karmaşık sayılar üzerinde bile çalışır, sayının köklerinden birini döndürür (3 vardır):

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

:+Operatör olarak okunması gereken 'artı ı kere'

SageMath, (69) 62 bayt

Bununla birlikte, size sonucu vereceğine asla inanmayın, tüm sayılardan rastgele gitmek çok zor:

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

eğer kesme konusunda ısrar etmediyseniz:

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

SageMath, 12 bayt, expizin verilirse

Her şey için çalışır: pozitif, negatif, sıfır, karmaşık, ...

exp(ln(x)/3)

Python - 62 bayt

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

Tam kayar nokta hassasiyetini değerlendirir. Kullanılan yöntem Halley yöntemidir . Her yineleme sonuncunun 3 katı rakamı doğru ürettiğinden, 99 yineleme biraz fazladır.

Giriş çıkış:

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, Tüm kökler için genel formülasyon
function f(n,p){for(i=x=99;i--;)x=x-(x-n/Math.pow(x,p-1))/p;return x}

Küp kökü için, sadece kullanın f(n,3), kare kök f(n,2), vb ... Örnek: f(1024,10)döndürür 2.

Newton yöntemine göre açıklama :

Bul:, f(x) = x^3 - n = 0çözüm n = x^3
Türetme:f'(x) = 3*x^2

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

Testler

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

Yinelemeli çözüm:

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

Perl, 92 bayt

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

• İşlev a, gereksiz kesir kısmı olmayan numaraya veya sağ uçta önemsiz sıfırlara sahip bir dize döndürür.

Sonuç:

              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

Oluşturan

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;

Hesaplama Newton'un yöntemine dayanmaktadır :

APL - 31

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

cbrt(x)=e^(ln(x)/3)Ancak, saf bir ⋆üs alma yerine e^xTaylor / Maclaurin serisini kullanarak hesapladığı gerçeğini kullanır .

Örnek çalışmalar:

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

16 karakterde bir J cevabı olduğunu görünce , APL'de gerçekten korkunç olmalıyım ...

Java, 207 182 181

Bazen golf oynadığımda iki biram var ve gerçekten çok kötü oynuyorum

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

Yinelemeli Newton'un Yaklaşım Yöntemi, 99 yineleme çalıştırır.

İşte golf edilmemiş:

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 bayt

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

JS 57 bayt

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

Bu algoritma topal ve bu sorunun ondalık noktadan sonraki 4 basamakla sınırlı olmasından faydalanıyor. Soruyu yeniden işleme koymak için sanal alanda önerdiğim algoritmanın değiştirilmiş bir sürümüdür. Sıfırdan sonsuzluğa kadar sayarken h*h*h<a, sadece 4 ondalık basamak hassasiyetini işlemek için bir çarpma ve bölme hilesi ile sayar.

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

Edit, 4 yıl sonra: Luis felipe De jesus Munoz tarafından önerildiği gibi **, kodu kullanarak daha kısadır, ancak bu özelliği 2014 yılında bu cevabı yazdığım zaman mevcut değildi. Her neyse, onu kullanarak ekstra bir karakter tıraş ediyoruz:

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

Javascript - 157 karakter

Bu işlev:

• Negatif sayıları kullanın.
• Yüzen işaretli sayıları kullanın.
• Herhangi bir giriş numarası için hızlı bir şekilde yürütün.
• Javascript kayan noktalı sayıları için izin verilen maksimum hassasiyete sahiptir.

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}

Açıklanamayan sürüm:

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

Newton'un yöntemine göre. Michael'ın cevabının biraz değiştirilmiş versiyonu :

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

Negatif sayılarla çalışır, kayan nokta sayılarını işleyebilir ve sonuç bir kayan nokta sayısı ise ondalık noktadan sonra sonucu 4 sayıya yuvarlar.

Çalışma demosu

Befunge 98 - Yapım aşamasında

Bu dil kayan nokta sayılarını desteklemez; bu onları taklit etmeye çalışır. Şu anda 0ondalık noktadan sonra başlamayan pozitif sayılar için çalışır (çoğunlukla). Ancak, yalnızca 2 ondalık basamağa çıkar.

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

Ondalık noktadan önce parçayı girerek, bunu çarparak 100000, sonra noktadan sonra parçayı girerek ve iki sayıyı toplayarak çalışır. İkinci satır, küp girilen sayıdan daha büyük olana kadar bir sayaç yapar. Sonra üçüncü satır ondalık sayıyı tamsayıdan ayıklar.

Birisi bana üçüncü satırın neden sadece 100doğru değerleri elde etmek için bölündüğünü söyleyebilirse, lütfen söyle.

ES'ler:

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

kredi algoritma için mniip'e gider; Kodunun smalltalk versiyonu:

n olarak giriş; x cinsinden çıktı:

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

veya bir blok olarak

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

GameMaker Dili, 51 bayt

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

Haskell: 99C

Akıllıca mniip yenemezsin. Ben sadece bir ikili arama ile gittim.

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

Newton yöntemini kullanarak x^3 - X, güncelleme adımının kökünü bulmak x - (x^3 - C)/(3*x^2), burada x geçerli tahmin ve C girişi. Bu konuda matematik yapmak gülünç derecede basit bir ifade verir (2*x+C/x^2) /3. Negatif sayılara dikkat edilmelidir.

J'de sağdan sola uygulanır:

1. | Her iki argümanın abslerini alın, aktar
2. ^:_ Yakınsamaya kadar yapın
3. (%*~@])eşittir C / x^2( *~ yeşittir y * y)
4. +:@] dır-dir 2 x
5. 3%~üçe böl. Bu pozitif kök verir
6. *@[ * positive_root pozitif kökü C işareti ile çarpar.

Test sürüşü:

   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 bayt

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

Örnek kullanım:

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

JavaScriptBunun türetildiği çözüm için @Mig'e teşekkürler . forDöngünün değişmeyi durdurmak için yinelemeye ihtiyacı olduğu göz önüne alındığında şaşırtıcı bir şekilde hızlı bir şekilde çalışır .

C, 69 bayt

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

Newton yönteminin başka bir uygulaması. Çevrimiçi deneyin!

Stax , 10 bayt ^CP437

╘♀┘A╕äO¶∩'

Çevrimiçi çalıştırın ve hata ayıklayın!

açıklama

Açıklamak için ambalajsız sürümü kullanır.

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 Çözümü

public BigDecimal cubeRoot (BigDecimal sayı) {

    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 Çözümü

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)