किसी संख्या की घनमूल की गणना करें

12

इस कोड गोल्फ का लक्ष्य एक प्रोग्राम या फ़ंक्शन बनाना है जो इनपुट के रूप में दिए गए नंबर की क्यूब रूट की गणना और आउटपुट करता है।
नियम:

  • कोई बाहरी संसाधन नहीं
  • निर्मित घन रूट कार्यों का कोई उपयोग नहीं।
  • विधियों / ऑपरेटरों का कोई उपयोग नहीं जो एक संख्या को एक शक्ति तक बढ़ा सकते हैं (जिसमें वर्गमूल, 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...)

code-golf  math 
— ProgramFOX
स्रोत
लानत है, अगर आपने सटीक घन के साथ केवल संख्या की अनुमति दी है, तो मेरे पास एक अच्छा गोल्फ होगा
— यो '
1
अपने परीक्षण के मामलों को देखते हुए मुझे लगता है कि कार्यक्रम को केवल वास्तविक संख्या से निपटने की आवश्यकता है?
— user12205 12
@ace जटिल है और मैं अपने कोड में 2 अक्षर बदलता हूं;)
— यो '
2
दशमलव बिंदु एक मजबूत आवश्यकता के बाद 4 अंको तक घूम रहा है? या यह कुछ ऐसा हो सकता है जैसे "आपको दशमलव बिंदु के बाद 4 से अधिक अंक दिखाने की आवश्यकता नहीं है"?
— विक्टर स्टैफुसा
Exp (ln (x) / 3) (और इसके कई क्लोन) का उपयोग करके मेरे उत्तर के संदर्भ में कृपया स्पष्ट करें कि क्या Exp की अनुमति है। मुझे लगता है कि pow (x, 1/3) नहीं है (भले ही यह तकनीकी रूप से क्यूब रूट फ़ंक्शन नहीं है।)
— लेवल रिवर सेंट

जवाबों:

6

जे: 16 अक्षर

हास्केल उत्तर का ढीला अनुवाद:

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

परीक्षण के मामलों:

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

सबसे अच्छा वर्डी अनुवादों में से एक नहीं है, क्योंकि एक डाईएडिक कांटा और ~अंत में एक अधिकार है।

— जेम्स वुड
स्रोत
19

हास्केल - 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

:+'प्लस ऑपरेटर के रूप में पढ़ा जाना चाहिए मैं बार'

— mniip
स्रोत
1
यह एक योग्य है। मैं पिछले घंटे के लिए सामान्यीकृत एनटी रूट अल्गों को फिर से तैयार कर रहा हूं, और मैं अभी उसी परिणाम पर पहुंचा हूं। वाहवाही।
— प्राइमो
@primo मैंने तुरंत सभी n'th रूट सन्निकटन एल्गोरिदम को याद किया, और APL I में टेलर / मैकलॉरीन श्रृंखला पर देने के बाद मैंने इसका उपयोग किया।
— mniip
न्यूटन विधि का उपयोग करने से x=(2*x+n/x/x)/3, क्या आप बता सकते हैं कि आप इसका उपयोग क्यों कर सकते हैं x=(x+n/x/x)/2? यह धीमी गति से परिवर्तित होता है, लेकिन मैं यह नहीं समझा सकता कि यह क्यों परिवर्तित होता है ...
— माइकल एम।
@ मिचेल क्योंकि अगर आप लेते हैं x=cbrt(n), तो x=(x+n/x/x)/2सच है। तो क्या यह आपकी अभिव्यक्ति के लिए सही है
— mniip
@ मिचेल मुझे इस तरह मिला: codepad.org/gwMWniZB
— primo
7

सेजमैथ, (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)
— यो'
स्रोत
मेरा मानना ​​है कि आप एक ऑपरेटर का उपयोग कर रहे हैं जो एक संख्या को एक शक्ति तक बढ़ा सकता है।
— user12205
आह ठीक है, ठीक है, संपादित
— यो '
6
+1 स्मारकीय रूप से बेवकूफ एल्गोरिथ्म के लिए जो अभी भी आवश्यकताओं को पूरा करता है।
— मैकेनिकल घोंघा
@ मेकैनिकल मेल धन्यवाद। मुझे आशा है कि यह स्पष्ट है कि मैं जो कर रहा हूं वह एक प्रकार की मंदी है: डी हालांकि, अगर expअनुमति है, तो मैं 12 से नीचे हूं और बिल्कुल भी बेवकूफ नहीं हो रहा हूं :)
— यो '
exp"एक्सपोनेंशियल फंक्शन" के लिए जो छोटा है, उसे ध्यान में रखते हुए , "एक ऐसा फंक्शन जिसका मूल्य तर्क की शक्ति के लिए एक निरंतर उठाया जाता है, विशेष रूप से वह फ़ंक्शन जहां कॉन्स्टैंट ई है।", और "वहाँ विधियों / ऑपरेटरों का कोई उपयोग नहीं है" एक शक्ति के लिए एक संख्या बढ़ा सकते हैं ", expकी अनुमति नहीं है।
— mbomb007
5

पायथन - 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
— Primo
स्रोत
यह कैसे काम करता है?
— justhalf
1
@ अन्याय मुझे लगता है कि यह मूल रूप से न्यूटन की विधि है।
— यो '
Btw, विफल रहता है0
— यो '
विफल रहता है -2, इसके लिए क्षमा करें।
— यो '
3
@plg समस्या वर्णन किसी भी घातीय फ़ंक्शन के उपयोग को मना करता है, अन्यथा v**(1/.3)एक निश्चित विजेता होगा।
— प्रिमो
3

जावास्क्रिप्ट (55)

function f(n){for(i=x=99;i--;)x=(2*x+n/x/x)/3;return x}

BONUS, सभी जड़ों के लिए सामान्य सूत्रीकरण
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

Iterate:
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)
— माइकल एम।
स्रोत
एक पात्र छोटा:function f(n){for(i=x=99;i--;)x-=(x-n/x/x)/3;return x}
— कॉपी
47 बाइट्स तक कम किया जा सकता हैf=(n)=>eval('for(i=x=99;i--;)x=(2*x+n/x/x)/3')
— लुइस फेलिप डी जीसस मुनोज
2

PHP - 81 बाइट्स

Iterative समाधान:

$i=0;while(($y=abs($x=$argv[1]))-$i*$i*$i>1e-4)$i+=1e-5;@print $y/$x*round($i,4);
— राज़्वान
स्रोत
यदि यह शून्य के घनमूल की गणना करने का प्रयास करता है तो क्या होगा?
— विक्टर स्टैफुसा
यह सिर्फ "0" आउटपुट होगा (त्रुटि दमन ऑपरेटर के लिए धन्यवाद - "@")।
— रज़वां
1
0.0001द्वारा 1e-4और 0.00001द्वारा प्रतिस्थापित किया जा सकता है 1e.5।
— 13
इसके लिए PHP <7 ( PHP 7 में 0/0देता NANहै) की आवश्यकता होती है। $i=0;अनावश्यक है (-5 बाइट्स। यदि यह नहीं था, forतो एक बाइट बचाएगा।) के बाद की जगह की printआवश्यकता नहीं है (-1 बाइट)। -Rके साथ 3 बाइट बचा सकता है $argn।
— टाइटस
while(1e-4+$i*$i*$i<$y=abs($x=$argn))(-2 बाइट्स) के साथ परांठे की एक जोड़ी को बचाएं ।
— टाइटस
2

पर्ल, 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;

गणना न्यूटन की विधि पर आधारित है :

गणना

— हेइको ओबर्डिएक
स्रोत
2

एपीएल - ३१

(×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 उत्तर होने के कारण, मुझे एपीएल पर वास्तव में भयानक होना चाहिए ...

— mniip
स्रोत
2

जावा, 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);}}

Iterative Newton's Method of Approximation, 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 );
    }
}
— md_rasler
स्रोत
1
आप 6 argsचर को zकम करते हुए चर का नाम बदल सकते हैं । आप 3 चर को कम करने के लिए, लूप के शरीर में स्थान और घुंघराले ब्रेसिज़ को हटा सकते हैं। आप 6 वर्णों को कम 10000.0करके प्रतिस्थापित कर सकते हैं 1e4। कक्षा को सार्वजनिक करने की आवश्यकता नहीं है, इसलिए आप अधिक 7 वर्णों को कम कर सकते हैं। इस तरह यह घटकर 185 अक्षर रह जाएगा।
— विक्टर स्टैफुसा
क्या अंत में कलाकारों को वास्तव में आवश्यक है? यह मेरे लिए नहीं है।
— विक्टर स्टैफ़ुसा
@ विक्टर अच्छी आंख के लिए धन्यवाद, 10000.0 डबल के लिए ई नोटेशन का उपयोग एक शानदार अच्छा विचार था। प्रश्न के डिजाइन से, मुझे लगता है कि कामकाजी वर्ग के बजाय इसे एक विधि बनाना वैध है, जिससे आकार में काफी कमी आएगी। जावा के साथ, मुझे नहीं लगा कि मेरे पास एक मौका था, इसलिए मैंने कार्यात्मक के पक्ष में मिटा दिया।
— md_rasler
CodeGolf में आपका स्वागत है! यह कैसे काम करता है में एक उत्तर की व्याख्या जोड़ने के लिए मत भूलना!
— जस्टिन
@Quincunx, धन्यवाद, अनुशंसित परिवर्तन।
— md_rasler
2

टीआई-बेसिक, 26 24 बाइट्स

Input :1:For(I,1,9:2Ans/3+X/(3AnsAns:End
— Timtech
स्रोत
यह सीधे ^ऑपरेटर का उपयोग करता है , यह नहीं। यह नियमों द्वारा मना किया जाता है
— mniip
@ एमनिप: e^टीआई -83 श्रृंखला पर एक एकल ऑपरेटर है? मुझे याद नहीं है। किसी भी तरह से, यह नियमों की भावना का उल्लंघन है।
— मैकेनिकल घोंघा
@ मेकेनिस्सेल यह कोई फर्क नहीं पड़ता कि मैं कहूंगा। अधिकांश भाषाओं में आप कर सकते हैं exp(ln(x)/3)या e^(ln(x/3))यदि आप इन दोनों में से किसी को भी अनुमति देते हैं। लेकिन किसी तरह मैं नियमों के द्वारा अनुमत होने के exp(ln(x)/a)लिए बहुत अधिक समतुल्य समझता हूं x^(1/a): - /
— यो '
घातीय फ़ंक्शन: "एक फ़ंक्शन जिसका मान तर्क की शक्ति के लिए उठाया गया एक स्थिर है , विशेष रूप से फ़ंक्शन जहां स्थिर ई है।" ... "विधियों / ऑपरेटरों का उपयोग नहीं जो एक संख्या को एक शक्ति तक बढ़ा सकते हैं"
— mbomb007
@ Mbomb007 को पकड़ने के लिए धन्यवाद, मैंने 3 साल से अधिक समय पहले यह जवाब लिखा था और मैं इसे अब पालन करने के लिए ठीक कर दूंगा।
— टिमटेक
2

जेएस 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>
स्निपेट का विस्तार करें

— लुइस फेलिप डी जीसस मुनोज
स्रोत
2

जावास्क्रिप्ट: 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 साल बाद: जैसा कि लुइस 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}
— विक्टर स्टैफ़ुसा
स्रोत
1
इसके बजाय h*h*hआप h**31 बाइट कर सकते हैं और बचा सकते हैं
— लुइस फेलिप डी जीसस मुनोज
@LuisfelipeDejesusMunoz यह उत्तर 2014 से है। **ऑपरेटर 2015 में प्रस्तावित किया गया था और 2016 में ECMAScript 7 के हिस्से के रूप में स्वीकार किया गया था। इसलिए, उस समय जब मैंने लिखा था कि, **भाषा में कोई भी नहीं था ।
— विक्टर स्टैफुसा
1

जावास्क्रिप्ट - 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
}
— विक्टर स्टैफ़ुसा
स्रोत
1

PHP, 61

न्यूटन की विधि पर आधारित है। माइकल के उत्तर का थोड़ा संशोधित संस्करण :

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

यह नकारात्मक संख्याओं के साथ काम करता है, फ़्लोटिंग पॉइंट नंबरों को संभाल सकता है, और परिणाम को दशमलव बिंदु के बाद 4 नंबरों पर गोल करता है यदि परिणाम एक फ़्लोटिंग पॉइंट संख्या है।

वर्किंग डेमो

— अमल मुरली
स्रोत
आप के साथ दो बाइट्स बचा सकते हैं for($x=1;++$i<100;)...। लेकिन इनपुट के रूप में पूर्वनिर्धारित चर का उपयोग करना आमतौर पर पर आधारित है । बेहतर उपयोग $argv[1]या $argn।
— टाइटस
1

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
— जस्टिन
स्रोत
1

लघुतल, ३ 37

एल्गोरिथ्म के लिए श्रेय mniip को जाता है; उनके कोड का लघु संस्करण:

इनपुट एन में; एक्स में उत्पादन:

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]
— blabla999
स्रोत
1

गेममेकर भाषा, 51 बाइट्स

for(i=x=1;i++<99;1)x=(2*x+argument0/x/x)/3;return x
— Timtech
स्रोत
0

हास्केल: 99 सी

चतुराई में @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
— danmcardle
स्रोत
आप प्रत्येक कॉल के लिए एक बाइट को बचाने के लिए d(जैसे (l#h)x) के लिए एक infix ऑपरेटर का उपयोग कर सकते हैं । cतब बन जाता है id>>=(0#)।
— एगलैंगिंग फ्रूट
आप चारों ओर रिक्त स्थान निकाल सकते हैं c < x।
— एगलैंगिंग फ्रूट
आप उपयोग कर सकते हैं 1>0के बजाय True।
— एगलैंगिंग फ्रूट
0

ज २ 28

*@[*(3%~+:@]+(%*~@]))^:_&|&1

न्यूटन विधि का उपयोग करते हुए, x^3 - Xअपडेट स्टेप के मूल को खोजना है x - (x^3 - C)/(3*x^2), जहां x वर्तमान अनुमान है, और सी इनपुट। इस पर गणित करने से हास्यास्पद सरल अभिव्यक्ति मिलती है (2*x+C/x^2) /3। ऋणात्मक संख्याओं के लिए देखभाल की जानी चाहिए।

J में लागू किया गया, दाएं से बाएं

  1. | दोनों तर्कों से अनुपस्थित रहें, उन्हें पास करें
  2. ^:_ अभिसरण तक करें
  3. (%*~@])है C / x^2( *~ yके बराबर है y * y)
  4. +:@] है 2 x
  5. 3%~तीन से विभाजित करें। इससे पॉजिटिव रूट निकलता है
  6. *@[ * positive_root C के सिग्नम से पॉजिटिव रूट को गुणा करता है।

परीक्षण चालन: 

   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
— jpjacobs
स्रोत
0

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$

धन्यवाद JavaScriptसमाधान के लिए @Mig पर जाएं, जो इससे प्राप्त हुआ है। यह आश्चर्यजनक रूप से जल्दी से दिया गया है कि forलूप को बदलने से रोकने की आवश्यकता है।

— रॉबर्ट बेन्सन
स्रोत
0

स्टेक्स , 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
— वीजुन झोउ
स्रोत
0

जावा समाधान

सार्वजनिक BigDecimal घन (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);
}
— रामनाथन गणेशन
स्रोत
1
PPCG में आपका स्वागत है! यह एक कोड-गोल्फ चुनौती है, जिसका अर्थ है कि लक्ष्य को हल करना जितना संभव हो उतना कम कोड है (स्रोत फ़ाइल के बाइट्स में गिना जाता है)। आपको उस लक्ष्य के प्रति अपने समाधान के अनुकूलन की दिशा में कुछ प्रयास करने चाहिए और अपने उत्तर में बाइट की गिनती को शामिल करना चाहिए।
— मार्टिन एंडर
0

अजगर का हल

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)
— रामनाथन गणेशन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.