बार-बार पारस्परिक

Question

आपको एक फ़ंक्शन / प्रोग्राम बनाने की ज़रूरत है जो एक दशमलव को इनपुट के रूप में लेता है, और संख्या के आंशिक भाग के पारस्परिक बार-बार परिणाम का परिणाम देता है, जब तक कि संख्या एक पूर्णांक नहीं बन जाती।

विशेष रूप से, प्रक्रिया इस प्रकार है:

1. X को इनपुट होने दें

2. यदि x पूर्णांक है, तो इसे आउटपुट करें।

3. अन्यथा: $x \leftarrow \frac{1}{\mathrm{frac}(x)}$ । 2 पर वापस जाएं।

$\mathrm{frac}(x)$ की आंशिक घटक है$x$ , और बराबर होती है$x - \left\lfloor x \right\rfloor$ । $\left\lfloor x \right\rfloor$ एक्स के फर्श है, जो सबसे बड़ी पूर्णांक से कम है$x$ ।

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

0 = 0
0.1 = 1/10 -> 10
0.2 = 1/5 -> 5
0.3 = 3/10 -> 10/3 -> 1/3 -> 3
0.4 = 2/5 -> 5/2 -> 1/2 -> 2
0.5 = 1/2 -> 2
0.6 = 3/5 -> 5/3 -> 2/3 -> 3/2 -> 1/2 -> 2
0.7 = 7/10 -> 10/7 -> 3/7 -> 7/3 -> 1/3 -> 3
0.8 = 4/5 -> 5/4 -> 1/4 -> 4
0.9 = 9/10 -> 10/9 -> 1/9 -> 9
1 = 1
3.14 = 157/50 -> 7/50 -> 50/7 -> 1/7 -> 7
6.28 = 157/25 -> 7/25 -> 25/7 -> 4/7 -> 7/4 -> 3/4 -> 4/3 -> 1/3 -> 3

0.1: 0, 10, 5, 3, 2, 2, 2, 3, 4, 9, 1 के 0 से 1 के लिए सारांश

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट जीतती है।

स्पष्टीकरण:

• "बोनस अंक" बिना किसी राउंड-ऑफ त्रुटि के
• किसी भी गैर-नकारात्मक परिमेय संख्या (राउंड-ऑफ त्रुटि की अनदेखी) के लिए काम करना चाहिए
• आप कर सकते हैं, लेकिन उठाए गए कदमों का उत्पादन करने की जरूरत नहीं है
• आप एक दशमलव, अंश, या संख्याओं की जोड़ी के रूप में इनपुट ले सकते हैं, जो एक स्ट्रिंग में हो सकता है।

सभी मुद्दों के लिए क्षमा करें, यह इस वेबसाइट पर मेरा पहला प्रश्न है।

Comments

तथ्य यह है कि यह समाप्त होता है निरंतर अंश में एक दशमलव व्यक्त करने की संभावना से निकटता से संबंधित है।

— लीकेय नन

क्या हमें आउटपुट फ्लोट की उम्मीद है? वे कुछ सटीक मुद्दा पैदा करते हैं।

— लीकेय नन

क्या आप इस प्रक्रिया को थोड़ा और विस्तार दे सकते हैं? मैं अनिश्चित हूं कि "संख्या के भिन्नात्मक भाग का पारस्परिक" क्या होता है, और परीक्षण के मामले बहुत मदद नहीं करते हैं

— Ad Hoc Garf Hunter

क्या हम तर्कसंगत संख्या का प्रतिनिधित्व करने के लिए इनपुट के रूप में दो पूर्णांक ले सकते हैं?

— लीक नून

यह इनपुट के सरल निरंतर अंश के अंतिम तत्व के बराबर है।

— isaacg

Answer 1

जे, 18 बाइट्स

%@(-<.)^:(~:<.)^:_

J में, मुहावरे का u ^: v ^:_अर्थ है "क्रिया uको जारी रखें जबकि स्थिति vसही हो।

हमारे मामले में, समाप्त होने वाली स्थिति को हुक द्वारा परिभाषित किया गया है ~:<., जिसका अर्थ है "संख्या <.का फर्श ~:स्वयं संख्या के बराबर नहीं है" - इसलिए हम रोक देंगे जब मुख्य क्रिया uएक इंट वापस आती है।

uइस मामले में एक और हुक है -<.- संख्या माइनस इसकी मंजिल - जिसका वापसी मूल्य @पारस्परिक क्रिया में खिलाया जाता है %।

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

Comments

इसके अलावा 18, लेकिन वर्तमान में सहिष्णुता की वजह से कुछ अस्थायी बिंदु बाधाएं हैं _2{(%@-<.) ::]^:a::।

— कोल

%@|~&1^:(~:<.)^:_

— 19

Answer 2

पायथन 3 , 101 बाइट्स

lambda s:g(int(s.replace(".","")),10**s[::-1].index("."))
g=lambda a,b:a and(b%a and g(b%a,a)or b//a)

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

प्रारूप: स्ट्रिंग में दशमलव बिंदु होना चाहिए।

Comments

.replace(".","")-> .replace(*"._")1 बाइट

— बचाएं

Answer 3

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

Last@*ContinuedFraction@*Rationalize

डेमो

In[1]:= f = Last@*ContinuedFraction@*Rationalize

Out[1]= Last @* ContinuedFraction @* Rationalize

In[2]:= f[0]

Out[2]= 0

In[3]:= f[0.1]

Out[3]= 10

In[4]:= f[0.2]

Out[4]= 5

In[5]:= f[0.3]

Out[5]= 3

In[6]:= f[0.4]

Out[6]= 2

In[7]:= f[0.5]

Out[7]= 2

In[8]:= f[0.6]

Out[8]= 2

In[9]:= f[0.7]

Out[9]= 3

In[10]:= f[0.8]

Out[10]= 4

In[11]:= f[0.9]

Out[11]= 9

In[12]:= f[1]

Out[12]= 1

Comments

बिना क्या होता है Rationalize?

— ग्रेग मार्टिन

@GregMartin के बिना Rationalize, गणितज्ञ को लगता है कि निरंतर अंश के सभी शब्दों को उत्पन्न करने के लिए पर्याप्त सटीकता नहीं है। उदाहरण के लिए, ContinuedFraction[0.1]बस है {0}।

— एंडर्स कासोर्ग

Answer 4

पर्ल 6 , 42 बाइट्स

{($_,{1/($_-.floor)}...*.nude[1]==1)[*-1]}

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

nudeविधि रिटर्न न्यू merator और डी एक दो तत्व सूची के रूप में एक तर्कसंगत संख्या का नामजद करने। denominatorसीधे तरीके से कॉल करने की तुलना में इस तरह से इसे प्राप्त करना कम है ।

Answer 5

हास्केल , 47 बाइट्स

यह व्हीट विजार्ड के जवाबGHC.Real को हरा देता है क्योंकि हमें :%छोटे नाम रखने के साथ-साथ उपयोग करने वाले परिमेय पर पैटर्न मैच करने की अनुमति देता है

import GHC.Real
f(x:%1)=x
f x=f$1/(x-floor x%1)

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

fRationalइनपुट के रूप में एक संख्या लेता है , हालांकि ghc उन्हें एक निश्चित सटीकता के भीतर एक दशमलव प्रारूप में लिखने की अनुमति देता है।

Answer 6

हास्केल , 40 34 बाइट्स

संपादित करें:

• -6 बाइट्स: @WheatWizard ने बताया कि अंश को संभवतः दो अलग-अलग तर्क दिए जा सकते हैं।

(क्रिया के आयात के साथ हास्केल के उत्तर को देखने के बाद इसे पोस्ट करने का विरोध नहीं कर सके - अब मैं देख रहा हूं कि कुछ अन्य भाषा के उत्तर भी अनिवार्य रूप से इस पद्धति का उपयोग कर रहे हैं।)

!दो पूर्णांक तर्क (अंश का हर और भाजक); उन्हें छोटे शब्दों में होने की जरूरत नहीं है, लेकिन भाजक को सकारात्मक होना चाहिए) और पूर्णांक देता है। के रूप में बुलाओ 314!100।

n!d|m<-mod n d,m>0=d!m|0<1=div n d

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

• प्रकार के बेमेल को अनदेखा करना, का आंशिक भाग n/d( dसकारात्मक मानते हुए ) है mod n d/d, इसलिए mod n d==0, जब तक कि !प्रतिनिधित्व नहीं होता है d/mod n d।

Comments

34 बाइट्स? मुझे नहीं पता कि आप इस तरह के बोझिल आईओ पद्धति का उपयोग क्यों कर रहे हैं

— एड हॉक गारफ हंटर

@WheatWizard एचएम अच्छी तरह से, मैंने दो अलग-अलग तर्कों के बजाय एक जोड़ी होने के रूप में "जोड़ी" की व्याख्या की। मुझे लगता है कि यह एक अत्यधिक हास्केल केंद्रित व्याख्या है।

— अर्जन जोहान्सन

Answer 7

पायथन 3 + सिम्पी , 67 बाइट्स

from sympy import*
k=Rational(input())
while k%1:k=1/(k%1)
print(k)

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

Sympy Python के लिए एक प्रतीकात्मक गणित पैकेज है। क्योंकि यह प्रतीकात्मक है और द्विआधारी नहीं है, कोई फ़्लोटिंग पॉइंट गलतियाँ नहीं हैं।

Answer 8

PHP , 69 बाइट्स

for(;round(1e9*$a=&$argn)/1e9!=$o=round($a);)$a=1/($a-($a^0));echo$o;

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

PHP , 146 बाइट्स

for($f=.1;(0^$a=$argn*$f*=10)!=$a;);for(;1<$f;)($x=($m=max($a,$f))%$n=min($a,$f))?[$f=$n,$a=$x]:$f=!!$a=$m/$n;echo($o=max($a,$f))>1?$o:min($a,$f);

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

Answer 9

जेली , 8 बाइट्स

®İ$%1$©¿

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

फ्लोटिंग-पॉइंट अशुद्धि।

Comments

सौभाग्य यह 0.7 के लिए कर रहा है

— लीक नून

@LeakyNun इस किस्मत का मतलब या तो अनंत छोरों या अनंत छोरों से है ...

— एरिक द आउटग्राफर

Mफ्लोटिंग-पॉइंट अशुद्धियों को ठीक करने के लिए उपयोग करें : पी । यह जेली है लेकिन मनमाने ढंग से सटीक गणित के साथ। हालांकि 0.7 लूप को ठीक नहीं करता है।

— हायपरन्यूट्रिनो

@HyperNeutrino M, Jelly का पुराना संस्करण है।

— आउटगोल्फ जूल

5 बाइट्स

— caird coinheringaahing

Answer 10

जावास्क्रिप्ट ईएस 6, 25 बाइट्स

f=(a,b)=>a%b?f(b,a%b):a/b

कॉल f(a,b)के लिएa/b

Comments

अगर gcd(a,b)=1निकाल सकते हैं/b

— l4m2

Answer 11

हास्केल , 62 61 बाइट्स

import Data.Ratio
f x|denominator x==1=x|u<-x-floor x%1=f$1/u

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

Data.Ratioसटीक परिशुद्धता युक्तियुक्तकरण के लिए हास्केल के पुस्तकालय का उपयोग करता है । यदि केवल निर्मित नाम इतने लंबे नहीं थे।

Comments

@ H.PWiz अच्छा लगा! मैं के साथ मैच पैटर्न की कोशिश कर रहा था Data.Ratio। मैंने कभी नहीं सुना GHC.Real। बेझिझक पोस्ट करें कि अपने जवाब के रूप में।

— तदर्थ गार्फ हंटर

पोस्ट किया गया

— H.PWiz

Answer 12

एपीएल (डायलॉग क्लासिक) , 18 बाइट्स

{1e¯9>t←1|⍵:⍵⋄∇÷t}

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

एपीएल नार, 18 वर्ण

यूरेल परीक्षण के लिए -1 बाइट

f←{1e¯9>t←1|⍵:⍵⋄∇÷t}
v←0 .1 .2 .3 .4 .5 .6 .7 .8 .9 1 3.14
⎕←v,¨f¨v
  0 0  0.1 10  0.2 5  0.3 3  0.4 2  0.5 2  0.6 2  0.7 3  0.8 4  0.9 9  1 1  3.14 7 

Comments

⍵-⌊⍵→ 1|⍵एक बाइट के लिए

— उरियेल

@ युरील धन्यवाद ... तो बाइट्स जे समाधान के रूप में हैं

— रोजलूपी

Answer 13

स्मालटाक, 33 बाइट्स

[(y:=x\\1)>0]whileTrue:[x:=1/y].x

Answer 14

स्टैक्स , 8 बाइट्स

ç▄é⌠á◙àù

इसे चलाएं और डीबग करें

बिना किसी त्रुटि के "बोनस अंक"। कोई फ़्लोटिंग पॉइंट अंकगणित का उपयोग नहीं किया गया। यह (अंत में) स्टैक्स के अंतर्निहित तर्कसंगत प्रकार का उपयोग करता है।

Answer 15

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

x=>(y=(x+'').slice(2),p=(a,b)=>b?a%b?p(b,a%b):a/b:0,p(10**y.length,y))

यदि हम इनपुट प्रकार को स्ट्रिंग में बदल सकते हैं, तो यह 5 बाइट्स बचा सकता है।

Comments

यह संख्याओं के लिए काम नहीं करेगा = = 10.

— झबरा

@ शैगी को सहायक संख्या> 1 की आवश्यकता है?

— tsh

हां, यह किसी भी तर्कसंगत संख्या (राउंड-ऑफ त्रुटि की अनदेखी) के लिए काम करना चाहिए।

— सोलोमन उको