Мета цього коду гольфу - створити програму або функцію, яка обчислює та виводить корінь куба числа, який задається як введення.
Правила:

• Ніяких зовнішніх ресурсів
• Немає використання вбудованих функцій кореня куба.
• Немає використання методів / операторів, які можуть підняти число до потужності (що включає квадратний корінь, 4-й корінь тощо).
• Ваша функція / програма повинні мати можливість приймати числа з плаваючою комою та від’ємні числа як вхідні дані.
• Якщо корінь куба - це число з плаваючою комою, то округніть його на 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

Не один з найкращих багатослівних перекладів, оскільки ~на кінці є діадік-вилка та справа.

Хаскелл - 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

:+Оператор повинен читатися як «плюс I раз»

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)

Пітон - 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
Виведення: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використовуючи серії Тейлора / Маклауріна.

Проби:

⎕: 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 символах є відповідь J , я повинен бути дуже жахливим у APL ...

Ява, 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 ітерацій.

Ось незагорені:

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

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, лише з трюком множення та ділення, можна обробляти точність 4-х цифр.

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

Редагувати, 4 роки потому: Як запропонував Луїс Феліпе Де єсус Муноз, використання **коду коротше, але ця функція була недоступною ще в 2014 році, коли я писав цю відповідь. У будь-якому випадку, використовуючи його, ми голимо зайвого персонажа:

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

Javascript - 157 символів

Ця функція:

• Обробіть від’ємні числа.
• Обробіть плаваючі номери.
• Виконати швидко для будь-якого вхідного номера.
• Має максимальну точність, дозволену для чисел з плаваючою комою 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}

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

На основі методу Ньютона. Трохи модифікована версія відповіді Майкла :

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на отримання правильних значень, будь ласка, скажіть мені.

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

кредит йде на mniip для алгоритму; Версія його коду:

введення в n; вихід у х:

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

Безголівки:

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

загальнодоступний 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

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)