30

स्टर्न-Brocot अनुक्रम एक Fibonnaci की तरह अनुक्रम जो के रूप में निर्माण किया जा सकता इस प्रकार है:

के साथ अनुक्रम प्रारंभ s(1) = s(2) = 1
काउंटर सेट करें n = 1
s(n) + s(n+1)अनुक्रम में जोड़ें
s(n+1)अनुक्रम में जोड़ें
वृद्धि n, चरण 3 पर वापस लौटें

यह इसके बराबर है:

$s (n) = \ start {case} 1 & \ textrm {अगर} n = 1 \ s (\ frac n 2) & \ textrm {if} n \ textrm {सम है}} \ s (\ frac {n-1) } 2) + s (\ frac {n + 1} 2) & \ textrm {अन्यथा} \ अंत {मामले}}$

अन्य गुणों के बीच, स्टर्न-ब्रोकोट अनुक्रम का उपयोग हर संभव सकारात्मक तर्कसंगत संख्या उत्पन्न करने के लिए किया जा सकता है। हर तर्कसंगत संख्या ठीक एक बार उत्पन्न होगी, और यह हमेशा अपनी सरलतम शर्तों में दिखाई देगी; उदाहरण के लिए, 1/3अनुक्रम में 4 वाँ परिमेय संख्या है, लेकिन समतुल्य संख्याएँ 2/6, 3/9आदि बिल्कुल नहीं दिखाई देंगी।

हम nth रेशनल नंबर को परिभाषित कर सकते हैं r(n) = s(n) / s(n+1), जहाँ s(n)nth स्टर्न-ब्रोकोट नंबर है, जैसा कि ऊपर वर्णित है।

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

ऊपर वर्णित एल्गोरिदम 1-अनुक्रमित हैं; यदि आपकी प्रविष्टि 0-अनुक्रमित है, तो कृपया अपने उत्तर में बताएं
वर्णित एल्गोरिदम केवल दृष्टांत उद्देश्यों के लिए हैं, आउटपुट को किसी भी तरह से प्राप्त किया जा सकता है जो आपको पसंद है (हार्ड-कोडिंग के अलावा)
इनपुट STDIN, फ़ंक्शन मापदंडों या किसी अन्य उचित इनपुट तंत्र के माध्यम से हो सकता है
Ouptut STDOUT, कंसोल, फ़ंक्शन रिटर्न मान या किसी अन्य उचित आउटपुट स्ट्रीम के लिए हो सकता है
आउटपुट के रूप में एक स्ट्रिंग के रूप में होना चाहिए a/b, जहां aऔर bस्टर्न-Brocot अनुक्रम में प्रासंगिक प्रविष्टियां होती हैं। आउटपुट से पहले अंश का मूल्यांकन अनुमन्य नहीं है। उदाहरण के लिए, इनपुट के लिए 12, आउटपुट होना चाहिए 2/5, नहीं 0.4।
मानक खामियों को अस्वीकार कर दिया जाता है

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

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

यहां परीक्षण के मामले 1-अनुक्रमित हैं।

OEIS प्रविष्टि: A002487
उत्कृष्ट क्रमिक वीडियो अनुक्रम की चर्चा करते हुए: अनंत अंश

— सोक
स्रोत

क्या आउटपुट Trues के बजाय s का उपयोग कर सकता है 1?

— लोवजो

1

@Lovjo नहीं, True/2एक वैध अंश नहीं है (जहाँ तक मेरा संबंध है)। एक तरफ के रूप में, Trueहमेशा नहीं है 1- कुछ भाषाएं -1बिटवाइन ऑपरेटरों को लागू करते समय संभावित गलतियों से बचने के लिए उपयोग करती हैं । [उद्धरण वांछित]

— सोक

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

3ẋḶŒpḄċ
’Ç”/⁸Ç

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

ओह, ऐसा लगता है कि मैं @ डेनिस द्वारा स्वीकृत उत्तर को हरा सकता हूं, और उसी भाषा में। यह OEIS से एक सूत्र का उपयोग करके काम करता है: हाइपरबिनरी में व्यक्त करने के तरीकों की संख्या (संख्या शून्य से 1) (यानी 0 के साथ बाइनरी, अंक के रूप में 2)। अधिकांश जेली कार्यक्रमों (जो एक पूर्ण कार्यक्रम या एक फ़ंक्शन के रूप में काम करते हैं) के विपरीत, यह एक केवल एक पूर्ण कार्यक्रम के रूप में काम करता है (क्योंकि यह स्टडआउट के आउटपुट का हिस्सा भेजता है, और बाकी को लौटाता है; जब एक पूर्ण कार्यक्रम के रूप में उपयोग किया जाता है रिटर्न वैल्यू; स्पष्ट रूप से स्टडआउट के लिए भेजा जाता है, इसलिए सभी आउटपुट एक ही स्थान पर हैं, लेकिन यह फ़ंक्शन सबमिशन के लिए काम नहीं करेगा)।

कार्यक्रम का यह संस्करण बहुत ही अक्षम है। आप एक बहुत तेज प्रोग्राम बना सकते हैं जो 2 placing तक सभी इनपुट के लिए काम करता है , पहली पंक्ति के बाद n लगाकर ẋ; कार्यक्रम में O ( n × 3ⁿ) प्रदर्शन है, इसलिए n छोटा रखना यहां काफी महत्वपूर्ण है। लिखा सेट के रूप में कार्यक्रम n इनपुट, जो स्पष्ट रूप से बड़ा पर्याप्त है के बराबर है, लेकिन यह भी स्पष्ट रूप से बहुत बड़ी लगभग सभी मामलों में (लेकिन हे, यह बाइट्स बचाता है)।

व्याख्या

मेरे जेली स्पष्टीकरण में हमेशा की तरह, ब्रेसेस में पाठ (जैसे {the input}) कुछ दिखाता है जो मूल कार्यक्रम में लापता ऑपरेंड के कारण जेली द्वारा स्वचालित रूप से भरा जाता है।

हेल्पर फ़ंक्शन ( एन वें भाजक की गणना करता है, अर्थात एन + 1 वां अंश):

3ẋḶŒpḄċ
3ẋ       3, repeated a number of times equal to {the argument}
  Ḷ      Map 3 to [0, 1, 2]
   Œp    Take the cartesian product of that list
     Ḅ   Convert binary (or in this case hyperbinary) to a number
      ċ  Count number of occurrences of {the argument} in the resulting list

पहले पांच बाइट मूल रूप से दिए गए लंबाई तक सभी संभव हाइपरबिनरी नंबर उत्पन्न कर रहे हैं, उदाहरण के लिए इनपुट 3 के साथ, का आउटपुट Ḷ[[0,1,2], [0,1,2], [0,1,2 है ]] इसलिए कार्टेसियन उत्पाद [[0,0,0], [0,0,1], [0,0,2], [0,1,0],…, [2,2,1], [2,2,2]]। Ḅमूल रूप से सिर्फ अंतिम प्रविष्टि को 1 से गुणा करता है, 2 से प्रवेशात्मक प्रवेश, 4 से एंटेपेनट्यूट प्रवेश, आदि, और फिर जोड़ता है; हालांकि यह आम तौर पर बाइनरी को दशमलव में बदलने के लिए उपयोग किया जाता है, यह अंक 2 को ठीक से संभाल सकता है, और इस प्रकार हाइपरबिनरी के लिए भी काम करता है। फिर हम परिणामी सूची में दिखाई देने वाली संख्या को गिनते हैं, ताकि अनुक्रम में एक उपयुक्त प्रविष्टि मिल सके। (सौभाग्य से, अंश और हर एक ही क्रम का अनुसरण करते हैं)।

मुख्य कार्यक्रम (अंश और हर के लिए पूछता है, और आउटपुट स्वरूप):

’Ç”/⁸Ç
’Ç      Helper function (Ç), run on {the input} minus 1 (‘)
  ”/    {Output that to stdout}; start again with the constant '/'
    ⁸Ç  {Output that to stdout}; then run the helper function (Ç) on the input (⁸)

किसी तरह मैं उन प्रोग्रामों को लिखता रहता हूं जो I / O को संभालने के लिए लगभग बाइट्स लेते हैं क्योंकि वे वास्तविक समस्या को हल करने के लिए करते हैं ...

अच्छा दु: ख, आप इसे अक्षम होने के बारे में मजाक नहीं कर रहे थे - टीआईओ 12 पर पूरा करने के लिए 20s लगते हैं, और 13 बार पूरी तरह से बाहर! स्वीकार किए जाते हैं, भले ही मैं सभी परीक्षण मामलों को सत्यापित नहीं कर सकता।

— सोक

11

CJam (20 बाइट्स)

1_{_@_2$%2*-+}ri*'/\

ऑनलाइन डेमो । ध्यान दें कि यह 0-अनुक्रमित है। इसे 1-अनुक्रमित करने के लिए, प्रारंभिक 1_द्वारा प्रतिस्थापित करें T1।

विच्छेदन

यह मोशे न्यूमैन की वजह से चरित्र चित्रण का उपयोग करता है

अंश a(n+1)/a(n+2)पिछले अंश से उत्पन्न किया जा सकता a(n)/a(n+1) = xहै1/(2*floor(x) + 1 - x)

अगर x = s/tमिलता है तो हम

  1 / (2 * floor(s/t) + 1 - s/t)
= t / (2 * t * floor(s/t) + t - s)
= t / (2 * (s - s%t) + t - s)
= t / (s + t - 2 * (s % t))

अब, अगर हम यह मान लेते हैं sऔर tफिर नकल करते हैं

  gcd(t, s + t - 2 * (s % t))
= gcd(t, s - 2 * (s % t))
= gcd(t, -(s % t))
= 1

इसलिए a(n+2) = a(n) + a(n+1) - 2 * (a(n) % a(n+1))पूरी तरह से काम करता है।

1_           e# s=1, t=1
{            e# Loop...
  _@_2$%2*-+ e#   s, t = t, s + t - 2 * (s % t)
}
ri*          e# ...n times
'/\          e# Separate s and t with a /

— पीटर टेलर
स्रोत

यहाँ कार्यप्रणाली से प्यार करो, ज़बरदस्त जवाब!

— सोक

यदि आप OEIS प्रविष्टि को और नीचे स्क्रॉल करते हैं, तो आप पाएंगे कि माइक स्टे ने पहले ही वह फॉर्मूला प्रस्तुत कर दिया है।

— नील

11

हास्केल, 78 77 65 58 बाइट्स

बेशर्मी से अनुकूलित दृष्टिकोण की चोरी हमें देता है:

(s#t)0=show s++'/':show t
(s#t)n=t#(s+t-2*mod s t)$n-1
1#1

एक infix फ़ंक्शन का उपयोग करके कुछ बाइट्स को गोल्फ के लिए @nimi के लिए धन्यवाद!

(फिर भी) 0-आधारित अनुक्रमण का उपयोग करता है।

पुराना तरीका:

s=(!!)(1:1:f 0)
f n=s n+s(n+1):s(n+1):(f$n+1)
r n=show(s n)++'/':(show.s$n+1)

धिक्कार है उत्पादन प्रारूप ... और अनुक्रमणिका संचालक। संपादित करें: और पूर्वता।

मजेदार तथ्य: यदि विषम सूची एक चीज थी, तो अंतिम पंक्ति हो सकती है:

r n=show>>=[s!!n,'/',s!!(n+1)]

— ThreeFx
स्रोत

बाइंड करने के लिए गार्ड का उपयोग s!!nकरना एक बाइट से कम होना चाहिए:f n|x<-s!!n=x:x+x+1:f$n+1

— लकोनी

@ लिकोनी s!!n+1नहीं है, (s!!n)+1लेकिन s!!(n+1)यही वजह है कि मैं ऐसा नहीं कर सकता: /

— थ्री एफएक्स

वास्तव में, यह स्पष्ट होना चाहिए था। इसके बस ... इतने सारे s!!nवहाँ!

— लकोनी

1

आप उपयोग कर सकते हैं ++'/':(show.s$n+1)में rएक बाइट को बचाने के लिए।

— nimi

1

एक एक इन्फ़िक्स समारोह पर स्विच करें: (s#t)0=show..., (s#t)n=t#(s+t-2*mod s t)$n-1, r=1#1। आप भी छोड़ सकते हैं r, यानी अंतिम पंक्ति बस है 1#1।

— nimi

6

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

L‘Hị⁸Sṭ
1Ç¡ṫ-j”/

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

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

1Ç¡ṫ-j”/  Main link. Argument: n

1         Set the return value to 1.
 Ç¡       Apply the helper link n times.
   ṫ-     Tail -1; extract the last two items.
     j”/  Join, separating by a slash.


L‘Hị⁸Sṭ   Helper link. Argument: A (array)

L         Get the length of A.
 ‘        Add 1 to compute the next index.
  H       Halve.
   ị⁸     Retrieve the item(s) of A at those indices.
          If the index in non-integer, ị floors and ceils the index, then retrieves
          the items at both indices.
    S     Compute the sum of the retrieved item(s).
     ṭ    Tack; append the result to A.

— डेनिस
स्रोत

5

05AB1E , 34 33 25 23 बाइट्स

XX‚¹GÂ2£DO¸s¦ìì¨}R2£'/ý

व्याख्या

XX‚                        # push [1,1]
   ¹G           }          # input-1 times do
     Â                     # bifurcate
      2£                   # take first 2 elements of reversed list
        DO¸                # duplicate and sum 1st copy, s(n)+s(n+1)
           s¦              # cut away the first element of 2nd copy, s(n)
             ìì            # prepend both to list
               ¨           # remove last item in list
                 R2£       # reverse and take the first 2 elements
                    '/ý    # format output
                           # implicitly print

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

अदनान की बदौलत 2 बाइट बच गईं।

— Emigna
स्रोत

यह भी ?: काम करता है XX‚¹GÂ2£DO¸s¦ìì¨}R2£'/ý।

— अदनान

@ अदनान तथ्य मैं भूल गया कि ýएक सूची को प्रारूपित कर सकते हैं। अच्छा लगा।

— एमिगा

4

MATL , 20 बाइट्स

FT+"@:qtPXnosV47]xhh

यह OEIS पृष्ठ में दिए गए द्विपद गुणांक के संदर्भ में लक्षण वर्णन का उपयोग करता है ।

एल्गोरिथ्म सभी नंबरों के लिए सिद्धांत रूप में काम करता है, लेकिन व्यवहार में यह MATL की संख्यात्मक परिशुद्धता द्वारा सीमित है, और इसलिए यह बड़ी प्रविष्टियों के लिए काम नहीं करता है। परिणाम 20कम से कम तक के इनपुट के लिए सटीक है ।

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

व्याख्या

FT+      % Implicitly take input n. Add [0 1] element-wise. Gives [n n+1]
"        % For each k in [n n+1]
  @:q    %   Push range [0 1 ... k-1]
  tP     %   Duplicate and flip: push [k-1 ... 1 0]
  Xn     %   Binomial coefficient, element-wise. Gives an array
  os     %   Number of odd entries in that array
  V      %   Convert from number to string
  47     %   Push 47, which is ASCII for '\'
]        % End for each
x        % Remove second 47
hh       % Concatenate horizontally twice. Automatically transforms 47 into '\'
         % Implicitly display

— लुइस मेंडो
स्रोत

4

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

x,s=input(),[1,1]
for i in range(x):s+=s[i]+s[i+1],s[i+1]
print`s[x-1]`+"/"+`s[x]`

यह सबमिशन 1-अनुक्रमित है।

पुनरावर्ती फ़ंक्शन का उपयोग करना, 85 बाइट्स:

s=lambda x:int(x<1)or x%2 and s(x/2)or s(-~x/2)+s(~-x/2)
lambda x:`s(x)`+"/"+`s(x+1)`

यदि एक आउटपुट जैसा True/2स्वीकार्य है, तो यहां 81 बाइट्स में से एक है:

s=lambda x:x<1 or x%2 and s(x/2)or s(-~x/2)+s(~-x/2)
lambda x:`s(x)`+"/"+`s(x+1)`

— Loovjo
स्रोत

3

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

f=(i,n=0,d=1)=>i?f(i-1,d,n+d-n%d*2):n+'/'+d

1 अनुक्रमित; n=10-अनुक्रमित के लिए परिवर्तन । लिंक किए गए OEIS पृष्ठ में पिछले दो शब्दों के संदर्भ में प्रत्येक पद के लिए एक उपयोगी पुनरावृत्ति संबंध है; मैंने इसे पिछले भाग के संदर्भ में प्रत्येक अंश के लिए एक पुनरावृत्ति के रूप में व्याख्यायित किया। दुर्भाग्य से हमारे पास इनलाइन TeX नहीं है, इसलिए आपको यह पता लगाने के लिए कि यह प्रारूप कैसा है, आपको इसे किसी अन्य साइट पर पेस्ट करना होगा:

\frac{a}{b} \Rightarrow \frac{b}{a + b - 2 (a mod b)}

$\frac{a}{b} \Rightarrow \frac{b}{a + b - 2(a \bmod b)}$

— नील
स्रोत

3

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

f=lambda n:1/n or f(n/2)+n%2*f(-~n/2)
lambda n:`f(n)`+'/'+`f(n+1)`

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

— XNOR
स्रोत

3

सी (जीसीसी), 79 बाइट्स

0-आधारित अनुक्रमण का उपयोग करता है।

s(n){return!n?:n%2?s(n/2):s(-~n/2)+s(~-n/2);}r(n){printf("%d/%d",s(n),s(n+1));}

Ideone

— betseg
स्रोत

1

x?:yएक gcc एक्सटेंशन है।

— रिसी

3

दरअसल, 18 बाइट्स

11,`│;a%τ@-+`nk'/j

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

यह समाधान पीटर के सूत्र का उपयोग करता है और इसी तरह 0-अनुक्रमित है। एक बाइट के लिए लीक नन को धन्यवाद।

स्पष्टीकरण:

11,`│;a%τ@-+`nk'/j
11                  push 1, 1
  ,`│;a%τ@-+`n      do the following n times (where n is the input):
                      stack: [t s]
    │                 duplicate the entire stack ([t s t s])
     ;                dupe t ([t t s t s])
      a               invert the stack ([s t s t t])
       %              s % t ([s%t s t t])
        τ             multiply by 2 ([2*(s%t) s t t])
         @-           subtract from s ([s-2*(s%t) s t])
           +          add to t ([t+s-2*(s%t) t])
                      in effect, this is s,t = t,s+t-2*(s%t)
              k'/j  push as a list, join with "/"

— मेगो
स्रोत

एक विवादास्पद बाइट

— लीके नन

@LeakyNun ओपी से स्पष्टीकरण मिलने तक मैं उस सुधार पर रोक लगाऊंगा।

— मेगो

2

MATL , 32 30 बाइट्स

1i:"tt@TF-)sw@)v]tGq)V47bG)Vhh

यह एक प्रत्यक्ष दृष्टिकोण का उपयोग करता है: अनुक्रम के पर्याप्त सदस्य उत्पन्न करता है, दो वांछितों को चुनता है और आउटपुट को प्रारूपित करता है।

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

— लुइस मेंडो
स्रोत

2

आर, 93 बाइट्स

f=function(n)ifelse(n<3,1,ifelse(n%%2,f(n/2-1/2)+f(n/2+1/2),f(n/2)))
g=function(n)f(n)/f(n+1)

वास्तव में सबसे सरल कार्यान्वयन। इसे थोड़ा गोल्फ पर काम करना।

— user5957401
स्रोत

2

एम 4, 131 बाइट्स

define(s,`ifelse($1,1,1,eval($1%2),0,`s(eval($1/2))',`eval(s(eval(($1-1)/2))+s(eval(($1+1)/2)))')')define(r,`s($1)/s(eval($1+1))')

को परिभाषित करता है एक मैक्रो rकि इस तरह की r(n)कल्पना के अनुसार मूल्यांकन करता है। वास्तव में बिलकुल नहीं, मैं सिर्फ फॉर्मूला कोडित करता हूं।

— प्रोग्राम मैन
स्रोत

2

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

यह 0-अनुक्रमित है और पीटर टेलर के सूत्र का उपयोग करता है। गोल्फ सुझाव का स्वागत करते हैं।

->n{s=t=1;n.times{s,t=t,s+t-2*(s%t)};"#{s}/#{t}"}

— Sherlock9
स्रोत

1

> <> , 34 + 2 = 36 बाइट्स

पीटर टेलर के उत्कृष्ट उत्तर को देखने के बाद, मैंने अपना परीक्षण उत्तर (जो बहुत ही भद्दी पुनरावृत्ति का उपयोग करते हुए, 82 बाइट्स को शर्मिंदा करने वाला था) लिखा।

&01\$n"/"on;
&?!\:@}:{:@+@%2*-&1-:

यह इनपुट को स्टैक पर मौजूद होने की उम्मीद करता है, इसलिए -vध्वज के लिए +2 बाइट्स । इसे ऑनलाइन आज़माएं!

— सोक
स्रोत

1

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

function f(i)S=[1 1];for(j=1:i/2)S=[S S(j)+S(j+1) (j+1)];end;printf("%d/%d",S(i),S(i+1));end

— dcsohl
स्रोत

1

सी #, 91 90 बाइट्स

n=>{Func<int,int>s=_=>_;s=m=>1==m?m:s(m/2)+(0==m%2?0:s(m/2+1));return$"{s(n)}/{s(n+1)}";};

कास्ट करता है Func<int, string>। यह पुनरावर्ती कार्यान्वयन है।

Ungolfed:

n => 
{
    Func<int,int> s = _ => _; // s needs to be set to use recursively. _=>_ is the same byte count as null and looks cooler.
    s = m =>
        1 == m ? m               // s(1) = 1
        : s(m/2) + (0 == m%2 ? 0 // s(m) = s(m/2) for even
        : s(m/2+1));             // s(m) = s(m/2) + s(m/2+1) for odd
    return $"{s(n)}/{s(n+1)}";
};

संपादित करें: -1 बाइट। C # को बाहर निकालता है returnऔर $प्रक्षेपित तारों के बीच और स्थान की आवश्यकता नहीं होती है ।

— दूध
स्रोत

1

अजगर 2, 59 बाइट्स

s,t=1,1;exec"s,t=t,s+t-2*(s%t);"*input();print'%d/%d'%(s,t)

पीटर के सूत्र का उपयोग करता है और इसी तरह 0-अनुक्रमित है।

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

— मेगो
स्रोत

1

जे, 29 बाइट्स

([,'/',])&":&([:+/2|]!&i.-)>:

प्रयोग

एन के बड़े मूल्यों के लिए एक प्रत्यय की आवश्यकता होती है, xजो विस्तारित पूर्णांक के उपयोग को दर्शाता है।

   f =: ([,'/',])&":&([:+/2|]!&i.-)>:
   f 1
1/1
   f 10
3/5
   f 50
7/12
   f 100x
7/19
   f 1000x
11/39

— मील की दूरी पर
स्रोत

100"बड़े मूल्य" के रूप में गिना जाता है?

— dcsohl

1

@dcsohl इस विधि में, द्विपद गुणांक की गणना की जाती है, और n = 100 के लिए, सबसे बड़ा एक गणना C (72, 28) = 75553695443676829680> 2 ^ 64 है और फ्लोटिंग पॉइंट वैल्यू से बचने के लिए विस्तारित पूर्णांक की आवश्यकता होगी।

— मील

1

गणितज्ञ, 108 106 101 बाइट्स

(s={1,1};n=1;a=AppendTo;t=ToString;Do[a[s,s[[n]]+s[[++n]]];a[s,s[[n]]],#];t@s[[n-1]]<>"/"<>t@s[[n]])&

— numbermaniac
स्रोत

1

आर , 84 बाइट्स

function(n,K=c(1,1)){for(i in 1:n)K=c(K,K[i]+K[i+1],K[i+1])
paste0(K[i],"/",K[i+1])}

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

पुराने आर कार्यान्वयन विनिर्देशों का पालन नहीं करता है, एक स्ट्रिंग के बजाय एक चल बिन्दु लौटने, तो यहाँ एक है कि करता है।

— ग्यूसेप
स्रोत

स्टर्न-ब्रोकोट अनुक्रम के अनुसार एनटी तर्कसंगत संख्या का उत्पादन

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

व्याख्या

CJam (20 बाइट्स)

विच्छेदन

हास्केल, 78 77 65 58 बाइट्स

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

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

05AB1E , 34 33 25 23 बाइट्स

MATL , 20 बाइट्स

व्याख्या

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

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

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

सी (जीसीसी), 79 बाइट्स

दरअसल, 18 बाइट्स

MATL , 32 30 बाइट्स

आर, 93 बाइट्स

एम 4, 131 बाइट्स

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

> <> , 34 + 2 = 36 बाइट्स

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

सी #, 91 90 बाइट्स

अजगर 2, 59 बाइट्स

जे, 29 बाइट्स

प्रयोग

गणितज्ञ, 108 106 101 बाइट्स

आर , 84 बाइट्स