प्लास्टिक नंबर को अनुमानित करें

24

चुनौती

प्लास्टिक संख्या सुनहरे अनुपात से संबंधित एक नंबर, कई दिलचस्प गणितीय गुणों के साथ है। जैसे, कई दृष्टिकोण हैं जिनका उपयोग संख्या की गणना करने के लिए किया जा सकता है।

इस चुनौती के प्रयोजनों के लिए संख्या को ठीक से निर्दिष्ट करने के लिए, हम निम्नलिखित परिभाषा का उपयोग करेंगे (हालाँकि इसके समकक्ष परिभाषाएँ बहुत हैं, और आप किसी भी परिभाषा का उपयोग तब तक कर सकते हैं जब तक आप एक ही संख्या में आते हैं):

प्लास्टिक नंबर एक वास्तविक संख्या ρ है जैसे कि ρ ρ = ρ +1।

आपका चुनौती एक कार्यक्रम या समारोह जो एक पूर्णांक लेता है लिखना है एक्स इनपुट के रूप में (के साथ एक्स > 1), और करने के लिए एक सन्निकटन का उत्पादन ρ , आउटपुट के रूप में ऐसी है कि बड़े का मूल्य एक्स हो जाता है, करीब उत्पादन के लिए हो जाता है ρ ( सबसे परिमित कई अपवाद के साथ, इस उद्देश्य के लिए "करीब" के रूप में एक ही मूल्य की गिनती में रह), और किसी भी सकारात्मक संख्या के लिए δ , वहाँ कुछ इनपुट है एक्स आपके प्रोग्राम है जो भीतर एक निर्गम कि के उत्पादन δ की ρ ।

स्पष्टीकरण

  • यदि आप एक ऐसी विधि के माध्यम से आउटपुट कर रहे हैं जो स्वाभाविक रूप से स्ट्रिंग्स (जैसे मानक आउटपुट स्ट्रीम) को आउटपुट करता है, तो आप आउटपुट को दशमलव (जैसे 1.3247179572) या दो पूर्णांकों के अनुपात के रूप में /उनके बीच के चरित्र के रूप में प्रारूपित कर सकते हैं।
  • यदि आप अपनी प्रोग्रामिंग भाषा के भीतर एक मूल्य के रूप में आउटपुट कर रहे हैं (उदाहरण के लिए फ़ंक्शन से लौट रहे हैं), तो यह निश्चित-बिंदु, फ़्लोटिंग-पॉइंट या तर्कसंगत प्रकार का होना चाहिए। (विशेष रूप से, आप उन डेटा प्रकारों का उपयोग नहीं कर सकते हैं जो संख्याओं को प्रतीकात्मक रूप से संग्रहीत करते हैं, जब तक कि उनका उपयोग केवल दो पूर्णांकों के अनुपात को रखने के लिए नहीं किया जाता है। इसलिए यदि आप गणितज्ञ या इसी तरह की भाषा का उपयोग कर रहे हैं, तो आपको अतिरिक्त शामिल करने की आवश्यकता होगी। कोड वास्तव में आउटपुट के अंकों को उत्पन्न करता है।)
  • आपका उत्तर आपकी भाषा के एक काल्पनिक संस्करण में काम करना चाहिए जिसमें पूर्णांक मनमाने ढंग से बड़े हो सकते हैं, और मेमोरी (स्टैक सहित) असीमित है। आप यह नहीं मान सकते हैं कि आपकी भाषा में फ़्लोटिंग-पॉइंट अंकगणितीय मनमाने ढंग से सटीक है, लेकिन इसके बजाय इसकी वास्तविक सटीकता का उपयोग करना चाहिए (जिसका अर्थ है कि फ़्लोटिंग-पॉइंट संख्या को आउटपुट करना केवल उन भाषाओं में संभव होने जा रहा है, जहाँ फ़्लोटिंग-पॉइंट संख्या की सटीकता हो सकती है रनटाइम पर नियंत्रित)।
  • x का कोई भी अर्थ हो सकता है जो आप चाहते हैं (इसलिए जब तक यह अधिक सटीक आउटपुट देता है)। मैं कल्पना करता हूं कि अधिकांश प्रस्तुतियाँ उत्पादन के अंकों की संख्या को नियंत्रित करने के लिए, या आपके प्रोग्राम द्वारा उपयोग किए गए एल्गोरिदम की पुनरावृत्तियों की संख्या को प्लास्टिक नंबर पर परिवर्तित करने के लिए नियंत्रित करेंगी, लेकिन अन्य अर्थ स्वीकार्य हैं।

परीक्षण का मामला

यहाँ प्लास्टिक नंबर के पहले कुछ अंक दिए गए हैं:

1.32471795724474602596090885

OEIS पर अधिक अंक उपलब्ध हैं ।

विजय की स्थिति

कोड-गोल्फ के लिए हमेशा की तरह , कम बेहतर है, बाइट्स में मापा जाता है। हालांकि, जवाब देने के लिए स्वतंत्र महसूस करें भले ही वे जीतें नहीं, इसलिए जब तक वे मौजूदा उत्तरों में कुछ जोड़ते हैं (उदाहरण के लिए एक अलग भाषा, या एक अलग एल्गोरिथ्म)।

code-golf  math  number 
1
हम्म, (cbrt (108 + 12 * sqrt (69)) + cbrt (108-12 * sqrt (69)) / 6 यह `ड्रेक सन्निकटन 'का उपयोग करने के लिए एक अच्छा समय जैसा लगता है: sqrt (69) - 8। कुछ बिट .ly/2rCqedX ^ _ ^
— DrQuarius
2
क्या हम यह भी मान सकते हैं कि रिकर्सन / स्टैक की गहराई असीमित है?
— xnor
दूसरे बिंदु को स्पष्ट करने के लिए, क्या हम मनमाने ढंग से सटीक पुस्तकालयों (जैसे पायथन में mpmath) का उपयोग कर सकते हैं? वे एक सहायक डेटा प्रकार का उपयोग करते हैं, लेकिन क्या आप इसे "प्रतीकात्मक" चीजों को संग्रहीत करने के रूप में गिनते हैं?
— बैटमैन
1
खैर, बहुत कम से कम मुझे उम्मीद है कि मैं ρ को अभिसिंचित करने के लिए उत्तर दूंगा । इसके अलावा, एक "ईमानदार" समाधान आसानी से परीक्षण में विफल हो सकता है x> y -> | ρx - ρ | > | ρy - ρ | (x, y) जोड़े की एक परिमित संख्या के लिए । यदि यह स्वीकार्य नहीं है, तो मुझे लगता है कि इसे कल्पना में अधिक स्पष्ट किया जाना चाहिए।
— डेनिस
6
बहुत से उत्तरदाता ρ तक एक x अंक सन्निकटन की गणना के जाल (?) में गिर गए हैं, समस्या यह है कि संभवतः असीम रूप से कई x हैं जैसे कि (x + 1) -digit सन्निकटन कोई x अंक सन्निकटन से बेहतर नहीं है। आपको शायद स्पष्ट करना चाहिए कि क्या आपने इसे अनुमति दी है। यदि आप नहीं करते हैं, तो "करीब" को "सख्ती से करीब" से बदलें; यदि आप करते हैं, "कम से कम करीब" या कुछ और। आप शिथिल आवश्यकता पर भी विचार कर सकते हैं कि अनुक्रम ρ में परिवर्तित हो जाता है, जो अतिरिक्त रूप से xnor के उत्तर की अनुमति देगा।
— एंडर्स कासोर्ग

जवाबों:

10

पायथन 2 , 49 बाइट्स

n=x=input()
while n**3/x/x<n+x:n+=1
print n,'/',x

इसे ऑनलाइन आज़माएं!

विचार व्यक्त करने के लिए है ρके साथ ρ³=ρ+1के रूप में एक अंश n/xजिसका हर xइनपुट सटीकता पैरामीटर है। हम (n/x)³=n/x+1प्राप्त करने के लिए डिनोमिनेटर लेते हैं और साफ करते हैं n³=x²(x+n)।

चूंकि nआरएचएस की तुलना में एलएचएस तेजी से बढ़ता है , हम समानता बिंदु nको सबसे छोटे के साथ अनुमानित कर सकते हैं n³≥x²(x+n)। कोड nतब तक गिना जाता है जब तक कि यह मामला न हो, xजिस पर शुरू करना छोटा है।

एक छोटी बाइट सेव x²को लिखने के लिए दोनों पक्षों को विभाजित करना है n³/x²≥x+n( whileस्थिति में नकारात्मक )। यह कोड में फर्श विभाजन है, लेकिन खोए हुए आंशिक भाग नगण्य है।

इसके बजाय एक ही लंबाई विकल्प xअंश के रूप में डालता है :

पायथन 2 , 49 बाइट्स

n=x=input()
while x**3/n/n<n+x:n-=1
print x,'/',n

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत
हालांकि यह आउटपुट ρ (∀ε> 0 ₀x∀ ≥x ₀ x₀ | f (x - ρ। <Ε) में परिवर्तित हो जाता है, लेकिन यह संतुष्ट नहीं करता है "x का मान जितना बड़ा होता है, आउटपुट उतना ही करीब ρ तक पहुंच जाता है। (सबसे सूक्ष्म रूप से कई अपवादों के साथ) "(₀x∀ ≥x ₀ x most | f (x + 1) - ρ | <| f (x) - ρ |) |
— एंडर्स कासोर्ग
इस समस्या को 2**input()केवल के बजाय का उपयोग करके ठीक किया जा सकता है input(); फिर, प्रत्येक सन्निकटन पहले की तरह कम से कम सटीक होगा।
10

गणितज्ञ, 20 बाइट्स

#^3-#-1&~Root~1~N~#&

मैथेमेटिका का बिलियन Rootफ़ंक्शन एक बहुपद समीकरण का समाधान देता है f[x] == 0।

व्याख्या

#^3-#-1&~Root~1~N~#&
                   &  (* Function *)
#^3-#-1&              (* A pure-function polynomial, x^3-x-1 *)
        ~Root~1       (* Find the first root *)
               ~N~#   (* approximate to (input) digits *)

नमूना I / O

In[1]:= f=#^3-#-1&~Root~1~N~#&;
        f[1]

Out[1]= 1.

In[2]:= f[9]

Out[2]= 1.32471796

In[3]:= f[100]

Out[3]= 1.324717957244746025960908854478097340734404056901733364534015050302827851245547594054699347981787280
— जंगहवान मिन
स्रोत
PS: Root[x^3-x-1,1]~N~#&ठीक काम करता है (यह बताने के बावजूद कि यह xवैरिएबल है) एक ही बाइट काउंट के लिए।
— ग्रेग मार्टिन
@AndersKaseorg: मैंने उस नियम को बदल दिया क्योंकि यह स्पष्ट रूप से टूट गया था। कोई मान्य उत्तर अमान्य नहीं था, लेकिन कुछ उत्तर (जैसे यह) मान्य हो गए।
6

गणितज्ञ, 27 बाइट्स

x/.Solve[x^3==x+1>2,x]~N~#&

मार्टिन से -1 बाइट
, ओव से बाइट

इनपुट

[27]

उत्पादन

{} 1.32471795724474602596090885

— J42161217
स्रोत
Solve[x^3==x+1>2,x]~N~#&24 बाइट्स के लिए
— ov
1
इसका परिणाम {{x -> 1.32...}}हालांकि है। आप ऐस के साथ जांचना चाहते हैं कि क्या यह एक वैध आउटपुट प्रारूप है।
— मार्टिन एंडर
ठीक है .. सभी तय मुझे लगता है
— J42161217
यह {1.32...}वास्तव में अभी भी है , लेकिन यह प्रारूप शायद कम विवादास्पद है।
— मार्टिन एंडर
1
मैंने चुनौती को थोड़ा और सामान्य कर दिया ताकि यह मान्य हो जाए, यह "पहले एक्स अंक" समाधानों को अस्वीकार करने के लिए नहीं था। तो यह अब मान्य है, भले ही यह पहले नहीं था।
6

sed , 67 60 (59 + 1) बाइट्स

s,^,1/1/1 ,
:;s,(1*/(1*)/(1*).*)1$,\2\3/\1,
t
s,(/1*).*,\1,

इसे ऑनलाइन आज़माएं!

-Eध्वज के लिए +1 (BRE के बजाय ERE)। इनपुट और आउटपुट दोनों समान हैं: x = 5 के लिए इनपुट 11111 उदाहरण के लिए आउटपुट दो यूनरी संख्याओं का एक अंश है: उपरोक्त 11111 इनपुट पैदावार आउटपुट 11111/1111 (दशमलव में 5/4)।

Padovan अनुक्रम के लगातार तत्वों के बीच एक अंश के रूप में प्लास्टिक की संख्या को अनुमानित करता है ।

— जुगनू
स्रोत
1
FWIW को bकमांड के बाद आपको स्पेस की आवश्यकता नहीं है , लेकिन आप खाली लेबल ( :और bबिना किसी तर्क के) का उपयोग करके इसे छोटा बना सकते हैं । tio.run/#%23K05N@f@/-
— जॉर्डन
ओह उत्कृष्ट। और मैं tइसके बजाय का उपयोग करके एक और 4 बाइट्स बचा सकता हूं b, इसलिए यह एक बहुत अच्छा बचत है। धन्यवाद :)
— FireFly
5

गणितज्ञ, 27 बाइट्स

Nest[(1+#)^(1/3)&,1,#]~N~#&

नेस्टेड क्यूबिक रेडिकल फॉर्म 1 (1 + un (1 + ... (1 + ...)) के छंटे हुए सन्निकटन का उपयोग करता है । जबकि आउटपुट में हमेशा x-1 दशमलव स्थान होंगे, परिणाम वास्तव में उससे कम सटीक होता है, क्योंकि अभिव्यक्ति प्रति अंकों में एक अंक से अधिक धीरे-धीरे परिवर्तित होती है ( एक्स का उपयोग नेस्टेड रेडिकल की संख्या के रूप में भी किया जाता है)। उदाहरण के लिए x = 100 देता है

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

ओवरलाइन वाला हिस्सा सही है।

— मार्टिन एंडर
स्रोत
मैं इस एल्गोरिथ्म को लिखने की योजना बना रहा था dc, लेकिन स्तब्ध हो गया क्योंकि यह पता चला कि इसमें घन रूट ऑपरेशन नहीं है, और संख्या को बढ़ाकर raising या तो काम नहीं करता है :-( कम से कम आप हमेशा पर भरोसा कर सकते हैं मैथेमेटिका के पास उपयुक्त
3
@ ais523 वास्तव में है, CubeRootलेकिन कोई भी उस के लिए बाइट्स नहीं मिला है।
— मार्टिन एंडर
4

ऑक्टेव , 50 बाइट्स

@(n)char(digits(n)*0+vpasolve(sym('r^3-r-1'))(1));

इसे ऑनलाइन आज़माएं!

nआउटपुट के अंकों की वांछित संख्या के साथ एक अनाम फ़ंक्शन को परिभाषित करता है ।

यह उत्तर दुर्व्यवहार करता digitsहै जो चर सटीक अंकगणित में अंकों की संख्या के लिए वर्तमान सेटिंग लौटाता है। इसका मतलब है कि हम इसे 'बहुत सारे आउटपुट तर्क' के बारे में त्रुटियों के बिना एक अनाम फ़ंक्शन में उपयोग कर सकते हैं।

इसके अलावा, यह वास्तव में सीधा है: vpasolveचर-परिशुद्धता अंकगणितीय हल के लिए कम है, के अंतिम कॉल द्वारा सटीक सेट के साथ digits। चूंकि vpaओक्टेव में एक प्रतीकात्मक डेटा प्रकार है, जो प्रति युक्ति पर प्रतिबंध है, हम char(...)स्ट्रिंग उत्पादन प्राप्त करने के लिए पूरे फ़ंक्शन को लपेटते हैं । ध्यान दें कि, solveऔर vpasolve, f==0निहित है, इसलिए r^3==r+1इसे बदल दिया गया हैr^3-r-1 (==0)

— Sanchises
स्रोत
मैंने जाकर प्रश्न को बदल दिया ताकि यह इस तरह से उत्तर न दे (इसका मतलब यह नहीं था)।
@ ais523 अधिसूचना के लिए धन्यवाद!
— १०:
4

MATL ( 27 28 बाइट्स)

7BG:"t@)y@Q)+h]tG3+)yG2+)/

मेरा पहला समाधान (27 बाइट्स)

इसे ऑनलाइन आज़माएं!

यह निश्चित रूप से इष्टतम नहीं है, मुझे अभी भी MATL की आदत है।

स्पष्टीकरण:

मैं इनपुट + 3 तक Padovan अनुक्रम बनाता हूं, फिर अंतिम दो संख्याओं के अनुपात का पता लगाता हूं ।

7B     % Turn 7 into binary to give 1 1 1 
G:"    % For k=1:input do...
t@)    % Existing sequence member k
y@1+)  % Existing sequence member k+1
+h     % Add them together and concatenate to the sequence array
]      % End loop
tG3+)  % Final sequence member
yG2+)  % Second last sequence member
/      % Divide to approximate ρ

उचित अंश आउटपुट (35 बाइट्स) (28 बाइट्स, @ सेंचुरीज़):

हालाँकि, पहला समाधान डिफ़ॉल्ट MATL सेटिंग्स की फ़्लोटिंग पॉइंट सीमा होने के कारण मनमानी परिशुद्धता की आवश्यकता को पूरा नहीं करता है। इसलिए इस सटीकता का विस्तार करने के लिए कई बाइट्स जोड़ने के बजाय, यह उचित अंश मार्ग लेने के लिए सरल है और अंतिम दो पूर्णांकों के एक हिस्से को (N-1) वें और एन वें तत्वों को काटकर अलग किए गए पडोवन अनुक्रम में लिखें।

उदाहरण के लिए "114/86"

7BG: "टी @) y @ 1 +) + h] tg3 +) वी '/' YcyG2 +) VYc

7BG:"t@tQh)sh]tJ)V47hyJq)Vh&

उपयोगकर्ता @ शिष्टाचार के सौजन्य से :)

इसे ऑनलाइन आज़माएं!

गैर-पुनरावृत्त मूल्यांकन:

विशेष रूप से, 'सटीक' संस्करण के लिए मेरा सबसे छोटा कोड है (23 बाइट्स):

1-1h69X^12**108+1I/^6/s

इसे ऑनलाइन आज़माएं!

... लेकिन मनमाना परिशुद्धता नहीं देता। मुझे आश्चर्य है कि क्या कोई भी नियमों को पूरा करने के लिए इसे समायोजित कर सकता है (इनपुट आदि का उपयोग करें) और फिर भी 5 बाइट्स से कम जोड़ें? : पी

— DrQuarius
स्रोत
1
1+को छोटा किया जा सकता है Q। यह ध्यान में रखते हुए, आप @)y@1+)+बस के साथ बदल सकते हैं @tQh)s। इसके अलावा, आप Jएक सरणी के अंत को इंगित करने के लिए उपयोग कर सकते हैं ; और अंत में, Matl, सामान्य सरणियों और चरित्र सरणियों बीच भेद नहीं करता तो आप बदल सकते हैं Ycद्वारा h(आप की अतिरिक्त कार्यक्षमता की जरूरत नहीं है Yc)। यह सिर्फ 28 बाइट्स देता है: 7BG:"t@tQh)sh]tJ)V47hyJq)Vh&( &अति सूक्ष्म उत्पादन को रोकने के लिए नोटिस , और '/'47 की जगह )।
— सांचीस
1
के लिए कुडोस 7Bहालांकि, ज्यादा बेहतर भोलेपन से दबाव डालने के बजाएlllv
— Sanchises
1
@DQuQuarius नवीनतम संस्करण हमेशा इस GitHub लिंक में
— लुइस मेंडू
1
@DrQuarius नहीं, यह व्यवहार पुराने MATL युक्ति में मौजूद है जिसका मैं आमतौर पर उपयोग करता हूं। आपको वास्तव में तालिका 3 की जांच करनी चाहिए। न केवल Jडिफ़ॉल्ट रूप से क्लिपबोर्ड होता है 1j, बल्कि क्लिपबोर्ड Lमें कई उपयोगी अनुक्रमण कार्य भी होते हैं (ध्यान दें कि MATL में 1jबराबर होता endहै)।
— सांचेस
1
इसके अलावा, चिंता न करें, मैं एक मैकेनिकल इंजीनियर हूं। मुझे लगता है कि MATL (AB) का वैज्ञानिक वातावरण के बाहर बहुत कम उपयोग होता है, इसलिए मुझे लगता है कि MATL (AB) / ऑक्टेव के अधिकांश गोल्फर सीएस के बाहर के हैं।
— Sanchises
4

एम , 15 14 बाइट्स

²×3’
*3Ḥ‘÷Ç
Ç¡

इसे ऑनलाइन आज़माएं!

कलन विधि

यह तर्कसंगत और न्यूटन की विधि का उपयोग करता है। विशेष रूप से, के लिए इनपुट एक्स , पहले एक्स के साथ शुरू मूल्य पुनरावृत्तियों एक्स लागू होते हैं।

हम बहुपद p (t) = t t - t - 1 की एक विशिष्ट जड़ खोजने की कोशिश कर रहे हैं । न्यूटन की विधि एक प्रारंभिक मूल्य टी 0 - पर्याप्त रूप से ρ के करीब ले जाकर प्राप्त करती है - और पुन:
t n + 1 = t n - p (t n ) / p '(t n ) द्वारा अनुक्रम को परिभाषित करते हुए ।

चूँकि p '(t) = 3t² -1 , हम
t n + 1 = t n - (t n ³ - t n - 1) / (3t n 1 - 1) = (3t n t - t n - t n 1 + t n + 1) / (3t n ) - 1) = (2t n 1 + 1) / (3t n 1 - 1) ।

ध्यान दें कि प्रारंभिक सन्निकटन x x के बढ़ने के साथ उत्तरोत्तर बदतर होता जाता है । जबकि x = 3 के लिए आउटपुट x = 2 के आउटपुट की तुलना में थोड़ा कम सटीक है , क्योंकि न्यूटन की विधि ρ से चतुष्कोणीय रूप से परिवर्तित होती है , यह x के बड़े मूल्यों के लिए कोई समस्या नहीं होनी चाहिए ।

यह काम किस प्रकार करता है

Ç¡    Main link. Argument: x

Ç¡    Call the second helper link x times, which initial argument x.


*3Ḥ‘÷Ç  Second helper link. Argument: t

*3      Compute t³.
  Ḥ     Unhalve; yield 2t³.
   ‘    Increment; yield 2t³+1.
     Ç  Call the first helper link with argument t.
    ÷   Divide the left result by the right one.


²×3’    First helper link. Argument: t

²       Compute t².
 ×3     Compute 3t².
   ’    Decrement; yield 3t²-1.
— डेनिस
स्रोत
बहुत बुरा आप उपयोग नहीं कर सकते हैं µ¡...
— आउटगॉल्फ
1

चारकोल , 28 बाइट्स

ＡＩθθＡθνＷ‹∕∕Ｘν³θθ⁺νθＡ⁺ν¹νＩ∕νθ

इसे ऑनलाइन आज़माएं! क्रिया मोड से लिंक करें। इसके अलावा, मैं स्पष्ट रूप से गड़बड़ कर दिया Divideऔर IntDivide: |
पायथन और जावास्क्रिप्ट के उत्तर के समान विधि का उपयोग करता है।

— ASCII-केवल
स्रोत
1

न्यूस्टैक , 14 बाइट्स

¹Fᵢ{E2x³⁺÷3x²⁻

विभाजन:

¹                Add arbitrary number 1 to the stack.
 Fᵢ{             Define for loop with a user's input amount of itterations.
    E            Define new edit for element 0 (element 0 being the 1 added. earlier).
     2x³⁺÷3x²⁻   update x to equal (2x^3+1)/(3x^2-1). (x = element 0).

यह काम किस प्रकार करता है:

सूत्र (2x 3 +1) / (3x 2 -1) समीकरण x 3 = 1 + 1 के लिए न्यूटन की विधि के सरलीकरण से आता है । आप इसे यहाँ पा सकते हैं । इस प्रक्रिया को बार-बार दोहराने से अनंत बार प्लास्टिक नंबर में परिवर्तित हो जाता है। यह अभिसरण की दर बल्कि प्रति गति लगभग 2.6 दशमलव पर त्वरित है।

INPUT ITERATION >> VALUE
0 >> 1
1 >> 1.5
2 >> 1.3478260869565217
3 >> 1.325200398950907
4 >> 1.3247181739990537
5 >> 1.3247179572447898
6 >> 1.324717957244746    <- 16 decimal precision in 6 iterations!
...
100 >> 1.324717957244746

पडोवन अनुक्रम विकल्प, 27 25 17 बाइट्स

¹Fᵢ{[ƨ2+ƨ3]ℲƤƨ/ƨ2

विभाजन:

¹                  Append first element of Padovan sequence.
 Fᵢ{       Ⅎ       Define for loop of user's input amount of iterations.
    [ƨ2+ƨ3]        Append sum second and third to last elements.
            Ƥƨ/ƨ2  Print ratio of last two elements.

बेहतर प्रिंट रणनीति चुनकर -2 बाइट्स

-8 बाइट्स इंडेक्स स्टैक का बेहतर तरीका चुनकर

यह काम किस प्रकार करता है:

जैसे-जैसे पडोवन क्रम जारी रहता है, अंतिम दो तत्वों का अनुपात प्लास्टिक संख्या में परिवर्तित हो जाता है।

INPUT ITERATION >> VALUE
0 >> 1
1 >> 2
...
10 >> 1.3157894736842106
...
89 >> 1.324717957244746    <- 16 decimal precision in 89 iterations
...
100> > 1.324717957244746
— Graviton
स्रोत
0

क्लोजर, 46 बाइट्स

#(nth(iterate(fn[i](Math/pow(inc i)(/ 3)))1)%)

पुनरावृत्त घन-मूल सूत्र का उपयोग करता है। यह थोड़ा और दिलचस्प है लेकिन अब:

(def f #(apply comp(repeat %(fn[i](Math/pow(inc i)(/ 3))))))

((f 10)1)
1.3247179361449652
— NikoNyrh
स्रोत
"आप यह नहीं मान सकते हैं कि आपकी भाषा में फ़्लोटिंग-पॉइंट अंकगणितीय मनमाने ढंग से सटीक है, लेकिन इसके बजाय इसकी वास्तविक सटीकता का उपयोग करना चाहिए (जिसका अर्थ है कि फ़्लोटिंग-पॉइंट संख्या को आउटपुट करना केवल उन भाषाओं में संभव होने जा रहा है जहाँ फ़्लोटिंग-पॉइंट संख्याओं की सटीकता हो सकती है रनटाइम पर नियंत्रित किया जा) "।
— ऐन्डर्स Kaseorg
ऊह मैंने नोटिस नहीं किया कि, क्या एक बमर है। और BigDecimal के साथ क्यूबिक रूट को लागू करना काफी मुश्किल है।
— निकोनिरह
0

जावास्क्रिप्ट, 36 बाइट्स

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x

शीर्ष अजगर जवाब के रूप में ही काम करता है। किसी console.logको शामिल नहीं किया गया था क्योंकि यदि आप f(x)कंसोल में चलते हैं तो यह अपने आप लॉग इन हो जाएगा।

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x
console.log(f(300))
स्निपेट का विस्तार करें

— थॉमस डब्ल्यू
स्रोत
0

> <> , 38 + 3 = 41 बाइट्स

11\n;
?!\}2,:01{::::}**-+0(?$-{+{1-:}

कार्यक्रम शुरू होने पर स्टैक पर मौजूद इनपुट की अपेक्षा करता है, इसलिए -vध्वज के लिए +3 बाइट्स ।

इसे ऑनलाइन आज़माएं!

प्रभावी रूप से उत्पादन मूल्य पर संकीर्ण करने के लिए एक द्विआधारी खोज करता है। बढ़ने xसे प्रदर्शन करने के लिए पुनरावृत्तियों की संख्या बढ़ जाती है।

संपादित करें: 1 बाइट, पिछले संस्करण को बचाने के लिए परिकलित गणना थोड़ा:

11\n;
?!\}2,:0{::::}**$-1-0)?$-{+{1-:}
— सोक
स्रोत
0

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

:Prompt X //Prompt for input, 3 bytes
:While X  //While X, 3 bytes
:³√(1+Y→Y //Calculate cube root of 1+Y and store to Y, 7 bytes
:DS<(X,0  //Decrement X and skip next command (which doesn't do anything), 5 bytes
:End      //End While loop, 2 bytes
:Y        //Display Y, 1 byte

इस पुनरावर्ती सूत्र का उपयोग करता है ।

दिलचस्प है, संख्या को हार्ड-कोडिंग करना और इसे गोल करना एक ही बाइट-काउंट देता है:

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

:Prompt X    //Prompt for input, 3 bytes
:.5√(3       //Store √(3)/2 to Ans, 5 bytes
:Ansֿ¹cosh(3ֿ¹coshֿ¹(3Ans //Store the plastic number to Ans, 9 bytes
:round(Ans,X //Round the plastic number X decimal digits, 4 bytes

इस त्रिकोणमितीय सूत्र का उपयोग करता है ।

— स्कॉट मिलनर
स्रोत
मुझे नहीं लगता कि आप यहां TI-BASIC की झांकियों का उपयोग कर सकते हैं:Your answer must work in a hypothetical variant of your language in which integers can be arbitrarily large, and memory (including stack) is unlimited. You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).
— lirtosiast
0

सी # , 317 बाइट्स

using m=System.Math;a=x=>{if(a==0)return "1/1";var d=a(x-1).Split('/');var b=int.Parse(d[0]);var c=int.Parse(d[1]);return string.Format("{0}/{1}",(2*m.Pow(b,3)+m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)),(3*m.Pow(b,2)*c-m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)));};

यह एक अंश के रूप में परिणाम देता है।

व्याख्या

यह बहुपद p ^ 3-p-1 = 0 की जड़ को खोजने के लिए x पुनरावृत्तियों के साथ न्यूटन की विधि का उपयोग करता है। सूत्र x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))) है, और x_0 एक प्रारंभिक बिंदु है।

बहुपद व्युत्पन्न 3p ^ 2-1 है, और x_ (n-1) = b / c कहते हैं। फिर, उपरोक्त सूत्र का उपयोग करके, हम प्राप्त करते हैं कि x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3)। यह भी कहते हैं, कि हम 1 से शुरू करते हैं, यह तब होगा, जब x = 2, क्योंकि x> 1, और एक पूर्णांक है। सुव्यवस्थित, और टिप्पणी कोड:

using System;
string PlasticNumber(int x)
{
    if (x == 2) 
        return "1/1";                 

//If x=2, we return our starting value, but we need to return it as a fraction

    var d = PlasticNumber(x - 1).Split('/');
    var b = System.Convert.ToInt32(d[0]);
    var c = int.Parse(d[1]);

//We parse the previous value of the fraction, and put it into two variables

    return string.Format("{0}/{1}", 
        (2 * Math.Pow(b, 3) + Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)),
        (3 * Math.Pow(b, 2) * c - Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)));

//We return the result as a fraction, but it's important not to return it in
  scientific notation, because that will cause issues in the parsing process 

}
— होर्वाथ डेविड
स्रोत
0

Axiom, 96 बाइट्स

h(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);r:=solve(x^3-x=1,10.^-n);digits(j);rhs(r.1))

परिणाम

(31) -> [h(i) for i in 0..10]
   (31)
   [1.0, 1.3, 1.33, 1.325, 1.3247, 1.32472, 1.324718, 1.324718, 1.32471796,
    1.324717957, 1.3247179572]
                                                         Type: List Float

आप कैसे देख सकते हैं कि h (2) 1.32 होना चाहिए न कि 1.33 इसलिए पिछले अंकों में कुछ त्रुटि है

फिर यह 110 बाइट्स में से एक होगा

g(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);x:=sqrt(23./108);r:=(.5+x)^(1/3)+(.5-x)^(1/3);digits(j);r)

यह III प्रकार के समाधान के लिए सूत्र का उपयोग करता है x ^ 3-3 * p * x-2 * q = 0 के मामले में q ^ 2-p ^ 3> = 0 जो m = sqrt (q ^ 2- है) p ^ 3) और x = (q + m) ^ (1/3) + (qm) ^ (1/3)

हमारे मामले में r ^ 3-r-1 = 0 को r ^ 3-3 * (1/3) r-2 * (1/2) = 0 इसलिए p = 1/3 q = 1/2 लिखा जा सकता है। m = 1 / 4-1 / 27 = 23/108 x = (0.5 + m) ^ (1/3) + (0.5-m) ^ (1/3)

यह वह है जो प्रारंभ बिंदु r = 1 के साथ न्यूटन पुनरावृत्ति का उपयोग करता है

f(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);e:=10^-n;r:=1.;repeat(v:=(r^3-r-1)/(3*r^2-1);abs(v)<e=>break;r:=r-v);digits(j);r)

यह फ़ंक्शन में बदलता है, n + 1 अंक के एक obj प्राप्त करने के लिए अंकों का मान फ्लोट बिंदु को बढ़ाता है। अंत में अंकों () मान को वापस पूर्ववर्ती मूल्य पर सौंपा गया है।

— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.