एक निरंतर अंश को सरल बनाएं

Question

निरंतर भिन्नताएं ऐसे भाव हैं जो आंशिक रूप से भिन्न का वर्णन करते हैं। उनका रेखांकन किया जा सकता है:

या उन्हें मूल्यों की सूची के रूप में दर्शाया जा सकता है: [a0; a1, a2, a3, ... an]

चुनौती:

एक आधार संख्या लें: और हर मान की एक सूची: और सरलीकृत तर्कसंगत अंश के लिए जारी अंश को सरल करें: अंश और भाजक को अलग से प्रिंट या प्रिंट करें।a0[a1, a2, a3, ... an]

उदाहरण:

• √19 : [4;2,1,3,1,2]: 170/39
• ℯ: [1;0,1,1,2,1,1]: 19/7
• π: [3;7,15,1,292,1]: 104348/33215
• ϕ: [1;1,1,1,1,1]: 13/8

उदाहरण कार्यान्वयन: (अजगर)

def foo(base, sequence):
    numerator = 1
    denominator = sequence[-1]
    for d in sequence[-2::-1]:
        temp = denominator
        denominator = d * denominator + numerator
        numerator = temp
    return numerator + base * denominator, denominator

जीतना:

बाइट्स में सबसे छोटा कोड: - कोई भी ऐसा निर्माण जो पूरी समस्या की अनुमति देता है -

Comments

आपको इस वाक्य को और अधिक स्पष्ट करना चाहिए, "और एक अंश तक जारी अंश को सरल करना"; जब तक कि आप का अर्थ है कि परिणाम के 2.002रूप में व्यक्त नहीं किया जा सकता है 2002/1000। यह तकनीकी रूप से एक "एकल अंश" है, आप शायद कहना चाहते हैं, "एक एकल अंश, अपने सबसे सरल रूप में।"

— मैजिक ऑक्टोपस उर्फ़

@carusocomputing बिंदु लिया .. हालांकि मैं के बारे में बहुत बुरा महसूस नहीं 2/4 (या समान) यह अभी भी एक भी अंश के लिए कई अंश संरचना सरल हो गया है के रूप में

— हारून

हम्म ... मुझे लगता है कि इसका फायदा उठाने का एक तरीका है, लेकिन 13 बाइट वाले गोल्फस्क्रिप्ट जवाब के साथ, मुझे जीतने के लिए शायद MATL का उपयोग करना होगा।

— मैजिक ऑक्टोपस उर्फ़

@carusocomputing मैं कहूंगा कि मैं इसके लिए जाऊंगा ... यदि आप 13 बाइट के जवाब को हरा सकते हैं, तो यह बहुत अच्छा होगा

— हारून

आप पीआई को पहले बंद कर सकते हैं - 355/113।

— थोरबजोरन रावन एंडरसन

Answer 1

जे, 8 5 बाइट्स

के रूप में ही इस , लेकिन एक निर्माण में परिमेय के लिए उपयोग करता है।

तर्क जम्मू विस्तारित परिशुद्धता परिमेय संख्याओं की सूची के रूप में {a0, a1, a2, a3, ...} है। परिणाम जे विस्तारित परिशुद्धता परिमेय संख्या के रूप में अंश है।

(+%)/

(+%) प्लस-के-पारस्परिक

/ कमी

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

-3 मील के लिए धन्यवाद ।

Comments

यदि आप इनपुट को विस्तारित पूर्णांक की सूची के रूप में लेते हैं, तो आप 3 बाइट्स बचा सकते हैं। आपने स्पष्टीकरण में एपीएल डिवीजन का भी इस्तेमाल किया।

— मील

@ मीलों धन्यवाद। उस से निर्मित निषेध के करीब नहीं जा सकते। बहुत खराब J में Dyalog APL की तरह हुक कंपोजिशन कैरेक्टर नहीं है ∘।

— अड्म

कोशिश जे ऑनलाइन लिंक टूट गया है

— चिले दस ब्रिंक

@ChieltenBrinke धन्यवाद। फिक्स्ड।

— अड्म

Answer 2

हास्केल, 37 36 18 बाइट्स

foldr1$(.(1/)).(+)

यह फ़ंक्शन Ratioइनपुट के रूप में हास्केल के प्रकार की अपेक्षा करता है। उपयोग उदाहरण:

Prelude Data.Ratio> ( foldr1$(.(1/)).(+) )  [4%1,2,1,3,1,2] 
170 % 39

नोट: Ratioइनपुट सूची में एक स्पष्ट ( 4%1) पर्याप्त है, प्रकार सिस्टम यह पता लगाता है कि दूसरों को Ratioभी होना है।

संपादित करें: @Lynn ने एक बाइट को बचाया। धन्यवाद!

संपादन II: हटा दिया import( मेटा पर इस चर्चा को देखें )।

Comments

ऊह, अच्छा किनारा मामला। फ़ंक्शन स्वयं बहुरूपी है, इसलिए इसकी आवश्यकता नहीं है import। हालाँकि, इसे कॉल करने के लिए, आपको इसे Ratioएस को फीड करना होगा, जिसकी आवश्यकता है import। मुझे importबाइट की गिनती में जोड़ना चाहिए या नहीं?

— nimi

यह मेटा के लिए एक अच्छा प्रश्न लगता है।

— मार्टिन एंडर

मैंने हास्केल का उपयोग कभी नहीं किया है, इसलिए अगर मैं गलत हूं तो मुझे सही करें, लेकिन अगर अजगर समान होगा: वस्तुओं के from fractions import Fractionसाथ संचालन करने के लिए Fraction, आयात विवरण भी गिना जाता है।

— एरॉन

.. हमारे पास वह पहले था ।

— nimi

@Aaron: समस्या यह है: फ़ंक्शन की परिभाषा को आयात की आवश्यकता नहीं है, क्योंकि यह बहुरूपी है। जब आप इसे कॉल करना चाहते हैं, तो आपको उस प्रकार की संख्या प्रदान करने की आवश्यकता होती है Ratioजो केवल निर्माण कर सकती है %, जिसके लिए आयात की आवश्यकता होती है। आमतौर पर हम केवल कार्य के लिए, ओवरहेड को कॉल करने के लिए बाइट्स की गिनती नहीं करते हैं।

— nimi

Answer 3

गोल्फस्क्रिप्ट , 13 बाइट्स

~]-1%{\-1?+}*

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

GolfScript की छिपी तर्कसंगतता के लिए याय । :)

व्याख्या

GolfScript का केवल "आधिकारिक" नंबर प्रकार पूर्णांक है। लेकिन घातांक ऑपरेटर अपने परिणाम को पूर्णांक में नहीं डालता है और रूबी (गोल्फस्क्रिप्ट इंटरप्रेटर की भाषा) में एक पूर्णांक घातांक का मूल परिणाम एक तर्कसंगत संख्या है। तो हम आसानी से -1 की शक्ति के लिए कुछ बढ़ाकर अंश प्राप्त कर सकते हैं। आसानी से, हम वैसे भी पारस्परिक चाहते हैं ...

~]     # Evaluate input and wrap all a_i in a list.
-1%    # Reverse the list so that a_n is at the start and a_0 at the end.
{      # Fold... (apply this block to each element from a_n-1 down to a_0, with
       # the previous result on the stack)
  \    #   Swap previous result with current a_i.
  -1?  #   Raise previous result to the power of -1, computing its reciprocal
       #   as a rational number.
  +    #   Add a_i.
}*

Answer 4

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

Fold[#2+1/#&]@*Reverse

अनिवार्य रूप से मेरे गोल्फस्क्रिप्ट उत्तर का एक बंदरगाह । यहाँ कुछ विकल्प दिए गए हैं:

24 बाइट्स के लिए, हम एक पुनरावर्ती संस्करण फ़ंक्शन लिख सकते हैं:

f@n_=n
n_~f~m__:=n+1/f@m

21 बाइट्स के लिए, हम "वेरिएडिक ऑपरेटर" को भी परिभाषित कर सकते हैं, लेकिन इसका कॉलिंग कन्वेंशन इतना अजीब होगा, कि मैं इसे गिनने में संकोच कर रहा हूं:

±n_=n
n_ ±m__:=n+1/±m

आपको इसे इनपुट मानों के अनुक्रम के साथ कॉल करना होगा , जैसे ±Sequence[3, 7, 15, 1, 292, 1]या ±##&[3, 7, 15, 1, 292, 1]।

और 21 बाइट्स के लिए भी, वहाँ (निषिद्ध) बिल्ट-इन होगा:

FromContinuedFraction

Answer 5

LabVIEW, 36 बराबर बाइट्स

ओपी के एल्गोरिथ्म का उपयोग करते हुए सीधे सीधे भोले कार्यान्वयन। क्या ऐसा करने का एक अच्छा तरीका है?

Comments

आपकी इलेक्ट्रिकल इंजीनियरिंग की डिग्री दिख रही है।

— मैजिक ऑक्टोपस उर्फ़

@ijustlovemath प्रॉप्स, लेकिन ..... प्रासंगिक

— आरोन

हाँ, यह सुनिश्चित करने के लिए एक विवादास्पद भाषा है। मैं LabVIEW को प्रोग्रामर्स की दुनिया के "आई हेट मैथ" के रूप में देखता हूं। समस्या स्वयं गणित नहीं है, लेकिन यह कैसे सिखाया जाता है (या अक्सर शिक्षण की कमी)।

— इग्लूवेवमथ

Answer 6

Dyalog एपीएल , 10 बाइट्स

तर्कसंगत के लिए बिल्ड-इन का उपयोग भी नहीं करता है।

{ ₀ , ₁ , ₁ , ₂ , ₃ , ...} को तर्क के रूप में लेता है, {भाजक, अंश} लौटाता है।

1(,÷∨)+∘÷/

1(,÷∨) 1-prepended- 1 के GCD द्वारा विभाजित और

+∘÷ प्लस-पारस्परिक-की

/ कमी

TryAPL ऑनलाइन!

Answer 7

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

a=d=0
b=c=1
for n in input():a,b=b,n*b+a;c,d=d,n*d+c
print b,d

यह दुर्भाग्य से गोल्फ के रूप में नहीं है ( छोटे के लिए @ xnor का जवाब देखें ), लेकिन यह इनपुट को उलटने की आवश्यकता के बिना अंश की गणना करता है। यह अभिसरण के लिए "मैजिक टेबल" दृष्टिकोण का उपयोग करता है - पिछले दो अंशों को देखते हुए a/cऔर b/d, अगला अंश है (n*b+a)/(n*c+d)।

उदाहरण के लिए, पी के लिए:

          3    7    15     1      292        1

  0   1   3   22   333   355   103993   104348
  1   0   1    7   106   113    33102    33215

हम देख सकते हैं कि 15*22 + 3 = 333, 15*7 + 1 = 106, 1*333 + 22 = 355, 1*106 + 7 = 113, आदि

Answer 8

एम, 5 बाइट्स

Ṛİ+¥/

इनपुट मूल्यों की एक सूची है [a0, a1, ..., aN]और यह एक तर्कसंगत संख्या को आउटपुट करता है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें।

व्याख्या

Ṛİ+¥/  Input: list A
Ṛ      Reverse A
    /  Reduce A from left to right using
   ¥     A dyadic chain
 İ         Take the reciprocal of the left value
  +        Add the reciprocal to the right value
       Return and print implicitly

Comments

यह क्या है? कुछ नई जेली बोली?

— आदम

@ मीलों वास्तव में 9 बाइट्स क्षमा करें :(

— हारून

@ Adám यह गणित और प्रतीक के लिए जेली का एक पुराना कांटा है। यहाँ इसका गितुब रेपो है ।

— मील

@Aaron M जेली के समान कोड पेज का उपयोग करता है , और इसे प्रत्येक वर्ण के लिए बाइट का उपयोग करके एन्कोड किया जा सकता है।

— मील

@ मीलों ठीक है, जोड़ा ।

— एडम

Answer 9

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

foldr(\h(n,d)->(h*n+d,n))(1,0)

पुनरावर्ती जा रहा n/dहै h+(1/(n/d)), जो बराबर है h+d/nया करने के लिए अद्यतन करने के लिए जा रहा प्रत्येक परत जोड़ता है (h*n+d)/n। अंश को टपल के रूप में संग्रहीत किया जाता है (num,denom)। (1,0)Flips का प्रारंभिक अंश 0/1जो है 0।

Answer 10

पायथन, 50 बाइट्स

f=lambda l,n=1,d=0:l and f(l,l.pop()*n+d,n)or(n,d)

सूची के अंत से जारी रखा अंश पीछे की ओर जा रहा है, बार-बार अंश को अद्यतन करने बनाता है n/dपिछले तत्व पर xके रूप में n/d -> 1+1/(n/d) == (x*n+d)/n।

Answer 11

 आम लिस्प, 54

कुछ हद तक वर्बोज़ फोल्ड-राइट:

(lambda(s)(reduce(lambda(a r)(+(/ r)a))s :from-end t))

टेस्ट

PASS  NAME  ACTUAL               EXPECTED
===============================================
T     √19   170/39               170/39              
T     ℯ     19/7                 19/7                
T     π     104348/33215         104348/33215        
T     ϕ     13/8                 13/8                

Answer 12

जूलिया (53 बाइट्स)

यह जूलिया का उपयोग करने का मेरा पहला मौका है, अगर मैंने एक पुनरावृत्त को अनदेखा किया तो मैं कुछ और बाइट्स खो सकता था, मुझे बताएं। यहां एक ऐसे व्यक्ति को संकेत दिया गया है जो यह नहीं जानता कि इस विशिष्ट चुनौती के लिए कौन सी भाषा चुनें: https://en.wikipedia.org/wiki/Rational_data_type

f(x,c)=(a=0;for b in x[end:-1:1];a=1//(b+a);end;a+c;)

• इनपुट सरणी को उल्टा करें।
• तर्कसंगत विभाजन के साथ इसके माध्यम से Iterate करें।
• दशमलव परिणाम में c जोड़ें।

Comments

आप ∘एक फ़ंक्शन के बजाय एक ऑपरेटर (जैसे ) को परिभाषित करके दो बाइट्स बचा सकते हैं

— Tasos Papastylianou

इसके अलावा, थोड़ी देर के लिए लूप के लिए बदलें और पॉप:x∘c=(a=0;while x!=[];a=1//(pop!(x)+a);end;a+c;)

— टैसोस पापस्टीलियनौ

25: x->foldr((x,y)->x+1//y,x)(हास्केल समाधान के समान)। उपयोग:(x->foldr((x,y)->x+1//y,x))([4//1,2,1,3,1,2])

— फेंगयांग वांग

ओह ... रिवर्स फोल्डिंग फंक्शन? वह सुंदर है! मैं हालांकि उस के लिए क्रेडिट लेने के लायक नहीं है।

— मैजिक ऑक्टोपस उर्फ़

Answer 13

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

s=>eval('for(F=[1,0];s+"";)F=[s.pop()*F[0]+F[1],F[0]]')

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

var f =
s=>eval('for(F=[1,0];s+"";)F=[s.pop()*F[0]+F[1],F[0]]')

console.log(f([4, 2, 1, 3, 1, 2]));
console.log(f([1, 0, 1, 1, 2, 1, 1]));
console.log(f([3, 7, 15, 1, 292, 1]));
console.log(f([1, 1, 1, 1, 1, 1]));

Answer 14

CJam , 18 16 बाइट्स

XUq~W%{2$*+\}/]p

ऑनलाइन दुभाषिया ।

XU                  Push 1 and 0 to the stack
  q~W%              Push input, eval and reverse it
      {     }/      For each n in the reversed input...
       2$             Copy numerator
         *+           Calculate n*denominator + numerator
           \          Swap numerator and denominator
              ]p   Wrap in array and output

Answer 15

05AB1E , 19 17 बाइट्स

R¬V¦vyY*X+YUV}YX)

व्याख्या

संख्याओं की सूची के रूप में लिया गया इनपुट

                     # variable X is initialized as 1
R¬V¦                 # reverse the list, remove the first item and store it in variable Y
    v        }       # for each item N left in list
     yY*X+  V        # store N*Y+X in Y
          YU         # store Y in X
              YX)    # wrap X and Y in a list

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

Answer 16

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

a=>a.reduceRight(([n,d],v)=>[v*n+d,n],[1,0])

Answer 17

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

f=(s,n=1,d=s.pop())=>s+""?f(s,d,s.pop()*d+n):[d,n]

यह अरनॉल्ड के उत्तर के लिए धन्यवाद है, इसे देखने से पहले मैं 66 बाइट्स के लिए फंस गया था:

f=(b,s,i=s.length-1,n=1,d=s[i])=>i?f(b,s,--i,d,s[i]*d+n):[n+b*d,d]

उदाहरण:
कॉल: f([1, 0, 1, 1, 2, 1, 1])
आउटपुट:Array [ 19, 7 ]

Answer 18

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

{[R[&(1/*+*)]](@_).nude}

स्पष्टीकरण:

• 1 / * + *दो मापदंडों वाला एक लैम्ब्डा है ( *जो पहले के पारस्परिक लेता है, और दूसरा जोड़ता है। (एक चूहा लौटाता है )

• R[&(…)]का उपयोग करता है कि जैसे कि यह एक infix ऑपरेटर था और इसे उलट देता है।
  (इसे सही सहयोगी बनाने सहित)

• […](@_) वह लेता है और इनपुट को कम करने के लिए इसका उपयोग करता है।

• … .nudeरिटर्न न्यू merator और डी के नामजद करने चूहा ।

• { … }अंतर्निहित पैरामीटर के साथ इसे एक नंगे ब्लॉक लंबोदर बनाएं @_।

उपयोग:

say {[R[&(1/*+*)]](@_).nude}(3,7,15,1,292,1) #*/# (104348 33215)

my &code = {[R[&(1/*+*)]](@_).nude}; # stupid highlighter */

say code 4,2,1,3,1,2;    # (170 39)
say code 1,0,1,1,2,1,1;  # (19 7)
say code 1,1,1,1,1,1;    # (13 8)

Answer 19

जेफायर , 145 बाइट्स

input n as Integer
set a to Array(n)
for i from 1to n
input a[i]as Integer
next
set r to a[n]
for i from 1to n-1
set r to(/r)+a[n-i]
next
print r

Zephyr पहली प्रोग्रामिंग भाषा है जिसे मैंने कभी बनाया है। यह सहज होने के लिए डिज़ाइन किया गया था और स्वच्छ वाक्यविन्यास है - बल्कि संक्षिप्तता की कीमत पर। मैं इसके साथ गोल्फ क्यों कर रहा हूं, आप पूछें? क्योंकि, मैंने जो भी भाषा लिखी है, उसके विपरीत, इसमें एक अंतर्निहित Fractionप्रकार है। तुम भी /"उलटा" (एक सुविधा मैं पिप के लिए उधार लिया है) के लिए एक संचालक के रूप में डिवीजन ऑपरेटर का उपयोग कर सकते हैं ।

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

यहाँ एक उदाहरण चलाया गया है:

C:\Zephyr> python zephyr.py contfrac.zeph
6
1
1
1
1
1
1
13/8

Answer 20

रूबी, 34 बाइट्स

->a{a.reverse.inject{|b,i|i+1r/b}}

यह एक सही गुना (उलट कर और फिर बाईं ओर मोड़कर) करता है, प्रत्येक तत्व को चलने वाले कुल (सही करने के लिए तत्व) पर 1 जोड़ देता है। रूबी के पास तर्कसंगत प्रकार है, जो वास्तव में अच्छा है। और शाब्दिक तर्क एक संख्या के साथ प्रत्यय हैं r।

Answer 21

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

╣╩┼►

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

यह जितना छोटा है, यह बिल्ट-इन नहीं है। बिल्ट-इन तर्कसंगत तर्कसंगत हालांकि थोड़ी बहुत मदद करते हैं। Ascii के लिए पैक, कार्यक्रम है rksu+।

1. सरणी को उल्टा करें।
2. सरणी का उपयोग करके मोड़ो (a, b) => (a + 1/b)।

Answer 22

एपीएल (एनएआरएस), 15 + 1 चार्ट, 30 + 2 बाइट्स

{1=≢⍵:↑⍵⋄+∘÷/⍵}

एडम जे समाधान से Apl (Nars) में अनुवाद ... उस फ़ंक्शन के लिए अनुमत इनपुट पूर्णांक संख्याओं की सभी सूची होगी, जहां पहला तत्व प्रकार तर्कसंगत होगा। परीक्षा:

  f←{1=≢⍵:↑⍵⋄+∘÷/⍵}      
  f 4x 2 1 3 1 2
170r39 
  f 1x 0 1 1 2 1 1
19r7 
  f 3x 7 15 1 292 1
104348r33215 
  f 1x 1 1 1 1 1
13r8 
  f 3x 89 888 999 11 222 373 7282 9272 3839 2828 
158824716824887954093160207727r52744031585005490644982548907 
  f ,0x
0 
  f ,9x
9 

इसलिए यह फ़ंक्शन की लंबाई के रूप में 15 वर्ण और "x" के लिए 1 char है जो मुझे टाइप करना है और मुझे जो टाइप करना है उससे बाहर निकलें।