9

आपकी चुनौती एक अंश को उसके निरंतर भिन्न रूप में परिवर्तित करना है।

इनपुट : अंश किसी भी प्रारूप में इनपुट हो सकता है, जिसमें शामिल हैं (लेकिन प्रतिबंधित नहीं)

स्ट्रिंग: "7/16"
सूची: {16, १६}, ({, १६), [16, १६]
सरल आदेश दिया जोड़ी: 7 16
समारोह: f [7,16]

आउटपुट : 2 डी में एक निरंतर अंश, क्षैतिज अंश सलाखों के साथ अंश को हर से अलग करता है। केवल 1 के बराबर संख्या वाले अंशों को जारी रखना मान्य है। यह आवश्यक नहीं है कि गहराई के अनुसार फ़ॉन्ट का आकार अलग-अलग हो। एक अग्रणी शून्य (उचित भिन्न के लिए) वैकल्पिक है।

गहराई : आपका कोड कम से कम 8 स्तर की गहराई प्रदर्शित करने में सक्षम होना चाहिए।

जीत की कसौटी : सबसे छोटा कोड जीतता है। आपको इनपुट और आउटपुट दिखाने वाले कई परीक्षण मामलों को शामिल करना होगा।

परीक्षण उदाहरण (इनपुट आउटपुट के बाद)

5/4 पाँच चौथाई

5/3 पाँच तिहाई

5/7 पाँच सातवें

9/16 नौ सोलहवीं

89/150 अस्सी नौ दो सौ पचास पचास

code-golf rational-numbers

— DavidC
स्रोत

आपको कितना गहरा जाना चाहिए इसका क्या मापदंड है? उदाहरण के लिए, हम सिर्फ 0 + 89 / 250पिछले एक के लिए क्यों नहीं कर सकते ?

— दरवाज़े

मैं मान रहा था कि केवल स्वीकार्य अंश 1 था। मैं इसे जोड़ूंगा।

— डेविड

आह ठीक है, बहुत ज्यादा गणित की पृष्ठभूमि नहीं है :) विकिपीडिया ने मदद की। ऐसी भाषाओं के बारे में जो इस प्रारूप में चीजों को प्रदर्शित नहीं कर सकती हैं? क्या यह ठीक है अगर हम कुछ ऐसा करते हैं 0 + 1 / (1 + 1 / (1 + 1 / (2 + 1 / (3 + 1 / (1 + 1 / (1 + 1 / (2)))))))? कोष्ठक के बिना क्या? या अगर हम सिर्फ नीले नंबर प्रदर्शित करते हैं, जैसे 0 1 1 2 5 1 1 2?

— दरवाज़े

1

आपका अंकन गणितीय रूप से सही प्रतीत होता है। लेकिन चुनौती का मुख्य बिंदु स्तंभ और पंक्ति प्रारूप में अंश को प्रदर्शित करने का एक तरीका है (जिसे मैंने 2 डी के रूप में ऊपर संदर्भित किया है)।

— 23

5

गणितज्ञ, 40 36 वर्ण

f=If[⌊#⌋≠#,⌊#⌋+"1"/#0[1/(#-⌊#⌋)],#]&

उदाहरण:

f[89/150]

आउटपुट:

उत्पादन

— alephalpha
स्रोत

10

अजगर 2, 158 155 147 142

a,b=input()
c=[]
while b:c+=[a/b];a,b=b,a%b
n=len(c)
while b<n-1:print'  '*(n+b),'1\n',' '*4*b,c[b],'+','-'*(4*(n-b)-7);b+=1
print' '*4*b,c[b]

परीक्षा:

$ python cfrac.py
(89,150)
                 1
 0 + -------------------------
                   1
     1 + ---------------------
                     1
         1 + -----------------
                       1
             2 + -------------
                         1
                 5 + ---------
                           1
                     1 + -----
                             1
                         1 + -
                             2

अजगर 2, alt। संस्करण, 95

मूल रूप से ब्रेडबॉक्स के उत्तर का एक बंदरगाह। सुरक्षित उत्पादन।

a,b=input();i=2
while a%b:print'%*d\n%*d + ---'%(i+5,1,i,a/b);a,b=b,a%b;i+=5
print'%*d'%(i,a/b)

परीक्षा:

$ python cfrac2.py
(98,15)
      1
 6 + ---
           1
      1 + ---
                1
           1 + ---
                7

— शेन
स्रोत

1

+1 अच्छा विचार! हालांकि समस्याएँ हैं अगर 9 से अधिक संख्या का उत्पादन किया जाता है। जाँच करें, उदाहरण के लिए, 40,3इनपुट के रूप में।

— स्वेन होइनस्टीन

7

XSLT 1.0

मैंने सोचा कि HTML के साथ अंशों को प्रदर्शित करना अच्छा होगा, इसलिए यहां एक XSLT समाधान है।

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
                              xmlns:msxsl="urn:schemas-microsoft-com:xslt" >
  <xsl:template match="/f">
    <xsl:variable name="c" select="floor(@a div @b)"/>
    <xsl:variable name="next">
      <f a="{@b}" b="{@a mod @b}"/>
    </xsl:variable>
    <table>
      <tr>
        <td valign="top" rowspan="2" style="padding-top:12px">
          <xsl:value-of select="$c"/>+
        </td>
        <td align="center" style="border-bottom:1px solid black">1</td>
      </tr>
      <tr>
        <td>
          <xsl:apply-templates select="msxsl:node-set($next)"/>
        </td>
      </tr>
    </table>
  </xsl:template>
  <xsl:template match="/f[@a mod @b=0]">
    <xsl:value-of select="@a div @b"/>
  </xsl:template>
</xsl:stylesheet>

इसका परीक्षण करने के लिए, xslt को अंश के रूप में सहेजें। IE में निम्न फ़ाइल खोलें:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet  href="fraction.xslt" type="text/xsl"?>
<f a="89" b="150"/>

89/150

— डैंको डर्बीक
स्रोत

मैं इस समाधान को प्यार करता हूं। अच्छा काम!

— क्रंचर

4

रूबी, 175 (ASCII कला के साथ) या 47 (बिना)

ASCII कला के बिना, 47

n,d=eval gets
while d!=0
puts n/d
n,d=d,n%d
end

चूंकि रूबी वास्तव में इस तरह के ग्राफिक्स नहीं कर सकती है, मैं सिर्फ आपके उदाहरणों में नीले नंबर का उत्पादन करता हूं।

c:\a\ruby>cont
[5,4]
1
4

c:\a\ruby>cont
[5,3]
1
1
2

c:\a\ruby>cont
[5,7]
0
1
2
2

c:\a\ruby>cont
[9,16]
0
1
1
3
2

c:\a\ruby>cont
[89,150]
0
1
1
2
5
1
1
2

ASCII कला के साथ, 181 178 175

n,d=eval gets
a=[]
n,d=d,n%d,a.push(n/d)while d!=0
i=0
j=2*a.size-3
k=a.size-2
a.map{|x|puts' '*i+"#{x}+"+' '*k+?1
i+=2
k-=1
puts' '*i+?-*j
j-=2}rescue 0
puts' '*i+a.last.to_s

वाह, उस ASCII कला ने बहुत कोड लिया, और मैं भी बुराई कर रहा था और उपयोग कर रहा था rescue 0: P नमूना:

c:\a\ruby>cont
[89,150]
0+      1
  -------------
  1+     1
    -----------
    1+    1
      ---------
      2+   1
        -------
        5+  1
          -----
          1+ 1
            ---
            1+1
              -
              2

— Doorknob
स्रोत

@DavidCarraher ठीक है, तो यह काम करता है। संपादित

— दरवाज़े

आप आंशिक भागफल का उत्पादन करते हैं। यद्यपि वे एक निरंतर अंश तैयार करने के लिए आवश्यक हैं, वे केवल आवश्यकता का हिस्सा हैं।

— डेविड डे

@DavidCarraher मुझे लगता है कि मैं ASCII कला के कुछ प्रकार की कोशिश कर सकता हूँ ... वहाँ वास्तव में रूबी में ऐसा करने का एक तरीका नहीं है।

— दरवाज़े

@DavidCarraher ठीक है, मुझे छोड़ना होगा, लेकिन मैं जल्द ही अंश का ASCII प्रतिनिधित्व बनाने पर काम करूंगा।

— दरवाज़े

महान। मैं आपके प्रयास के परिणामों को देखने के लिए उत्सुक हूं।

— 23

4

सेज नोटबुक, 80

c=continued_fraction(n)
LatexExpr('{'+'+\\frac{1}{'.join(map(str,c))+'}'*len(c))

यहां nकुछ भी हो सकता है ऋषि एक तर्कसंगत / फ्लोटिंग पॉइंट नंबर द्वारा अनुमानित कर सकते हैं। डिफ़ॉल्ट सटीकता 53 बिट्स है, जब तक nकि ए Rational। होगा प्यार MathJax।

यहां छवि विवरण दर्ज करें

— boothby
स्रोत

4

C, 119 वर्ण

n,d,r;main(i){for(scanf("%d%d",&n,&d);r=n%d;n=d,d=r,i+=5)
printf("%*d\n%*d + ---\n",i+5,1,i,n/d);printf("%*d\n",i,n/d);}

यहाँ आउटपुट के कुछ उदाहरण दिए गए हैं:

$ echo 15 98 | ./cfrac
     1
0 + ---
          1
     6 + ---
               1
          1 + ---
                    1
               1 + ---
                    7
$ echo 98 15 | ./cfrac
     1
6 + ---
          1
     1 + ---
               1
          1 + ---
               7
$ echo 98 14 | ./cfrac
7

जबकि काट-छाँट की अंश रेखा यहाँ के कुछ उदाहरणों की तरह सुंदर नहीं दिखती है, मैं यह बताना चाहता हूं कि डेस्कटॉप कंप्यूटर के सर्वव्यापी होने से पहले के दिनों में निरंतर भिन्न स्वरूपण के लिए यह एक सामान्य तकनीक थी।

ठीक है, यहाँ एक बहुत लंबा संस्करण (247 अक्षर) है जो आउटपुट को पूर्ण-स्वरूपित करता है:

c,h,i,j,n,d,w[99];char s[99][99];main(r){for(scanf("%d%d",&n,&r);d=r;n=d)
h+=w[c++]=sprintf(s[c],"%d + ",n/d,r=n%d);for(;j+=w[i],i<c-1;puts(""))
for(printf("%*d\n%*s",j+(r=h-j)/2,1,j,s[i++]);--r;printf("-"));
s[i][w[i]-2]=0;printf("%*s\n",j-1,s[i]);}

इसके आउटपुट के कुछ उदाहरण:

$ echo 89 150 | ./cfr
                 1
0 + ---------------------------
                   1
    1 + -----------------------
                     1
        1 + -------------------
                       1
            2 + ---------------
                         1
                5 + -----------
                           1
                    1 + -------
                             1
                        1 + ---
                             2 
$ echo 151 8919829 | ./cfr
                 1
0 + ----------------------------
                     1
    59071 + --------------------
                       1
            1 + ----------------
                         1
                2 + ------------
                           1
                    1 + --------
                             1
                        1 + ----
                             21 
$ echo 293993561 26142953 | ./cfr
               1
11 + ---------------------
                 1
     4 + -----------------
                   1
         14 + ------------
                       1
              4410 + -----
                      104

— रोटी का डिब्बा
स्रोत

वाह, हमारे पास सीजी जीतने के लिए कम से कम संभावना वाली भाषाओं में एक विजेता हो सकता है! प्रभावशाली! :-)

— दरवाज़े

3

एपीएल (78)

{(v↑' '⍪⍉⍪⍕⍺),(' +'↑⍨v←⊃⍴x),x←('1'↑⍨⊃⌽⍴v)⍪v←'─'⍪⍕⍪⍵}/⊃{⍵≤1:⍺⋄a w←0⍵⊤⍺⋄a,⍵∇w}/⎕

उदाहरण:

      {(v↑' '⍪⍉⍪⍕⍺),(' +'↑⍨v←⊃⍴x),x←('1'↑⍨⊃⌽⍴v)⍪v←'─'⍪⍕⍪⍵}/⊃{⍵≤1:⍺⋄a w←0⍵⊤⍺⋄a,⍵∇w}/⎕
⎕:
      89 150
   1             
 0+───────────── 
     1           
   1+─────────── 
       1         
     1+───────── 
         1       
       2+─────── 
           1     
         5+───── 
             1   
           1+─── 
               1 
             1+─ 
               2

— मारीनस
स्रोत

2

गणितज्ञ, 77

Fold[#2+1/ToString[#1]&,First[#1],Rest[#1]]&[Reverse[ContinuedFraction[#1]]]&

बस इसके लिए गणितज्ञ सीखा। ऐसा करने के लिए आश्चर्यजनक रूप से लंबा कार्यक्रम लेता है।

— TwiNight
स्रोत

2

पर्ल 128 114 चर

($a,$b)=split;$_=" "x7;until($b<2){$==$a/$b;($a,$b)=($b,$a%$b);$_.="1\e[B\e[7D$= + ---------\e[B\e[4D"}$_.="$a\n"

लेकिन यह उपयोग कंसोल प्लेसमेंट के रूप में, आपको चलाने से पहले कंसोल को साफ़ करना होगा:

clear
perl -pe '($a,$b)=split;$_=" "x7;until($b<2){$==$a/$b;($a,$b)=($b,$a%$b);$_.=
"1\e[B\e[7D$= + ---------\e[B\e[4D"}$_.="$a\n"' <<<$'5 7 \n189 53 \n9 16 \n89 150 '

उत्पादन:

       1
 0 + ---------
          1
    1 + ---------
             1
       2 + ---------
                2
       1
 3 + ---------
          1
    1 + ---------
             1
       1 + ---------
                1
          3 + ---------
                   1
             3 + ---------
                      2
       1
 0 + ---------
          1
    1 + ---------
             1
       1 + ---------
                1
          3 + ---------
                   2
       1
 0 + ---------
          1
    1 + ---------
             1
       1 + ---------
                1
          2 + ---------
                   1
             5 + ---------
                      1
                1 + ---------
                         1
                   1 + ---------
                            2

पहली पोस्ट: 128 वर्ण

($a,$b)=split;$c=7;while($b>1){$==$a/$b;($a,$b)=($b,$a%$b);printf"%s1\n%${c}d + %s\n"," "x($c+=5),$=,"-"x9}printf" %${c}d\n",$=

Cut'n पेस्ट के लिए विभाजित :

perl -ne '($a,$b)=split;$c=7;while($b>1){$==$a/$b;($a,$b)=($b,$a%$b);printf
"%s1\n%${c}d + %s\n"," "x($c+=5),$=,"-"x9}printf" %${c}d\n",$a' \
    <<<$'5 7 \n189 53 \n9 16 \n89 150 '

प्रस्तुत करेगा:

            1
      0 + ---------
                 1
           1 + ---------
                      1
                2 + ---------
                      2
            1
      3 + ---------
                 1
           1 + ---------
                      1
                1 + ---------
                           1
                     3 + ---------
                                1
                          3 + ---------
                                2
            1
      0 + ---------
                 1
           1 + ---------
                      1
                1 + ---------
                           1
                     3 + ---------
                           2
            1
      0 + ---------
                 1
           1 + ---------
                      1
                1 + ---------
                           1
                     2 + ---------
                                1
                          5 + ---------
                                     1
                               1 + ---------
                                          1
                                    1 + ---------
                                          2

LaTeX का उपयोग कर रहा है:

perl -ne 'END{print "\\end{document}\n";};BEGIN{print "\\documentclass{article}\\pagestyle".
  "{empty}\\begin{document}\n";};($a,$b)=split;$c="";print "\$ $a / $b = ";while($b>1){$==$a
  /$b;($a,$b)=($b,$a%$b);printf"%s + \\frac{1}{",$=;$c.="}";}printf"%d%s\$\n\n",$a,$c'  \
   <<<$'5 7 \n189 53 \n9 16 \n89 150 ' >fracts.tex

pslatex fracts.tex 

dvips -f -ta4 <fracts.dvi |
  gs -sDEVICE=pnmraw -r600 -sOutputFile=- -q -dNOPAUSE - -c quit |
  pnmcrop |
  pnmscale .3 |
  pnmtopng >fracts.png

लेटेक्स पिक्चर

— एफ। हौरी
स्रोत

1

पर्ल: 140 , 133 121 चार्ट

($a,$b)=<STDIN>;while($b>1)
{$g=$i+++4;print" "x$g."1\n"." "x$i,int($a/$b)."+---\n";($a=$b)=($b,$a%$b)}
print" "x$g."$a\n"

उदाहरण:
#perl अंश। पीपी
5
7

   1
0+---
    1
 1+---
     1
  2+---
     2

— Arvinds
स्रोत

0

रेज़र लीफ फ़ॉयरफ़ॉक्स, 108 127

%r=(i,n,d)=>
    mn"#{n/d|0}"
    if i<8&&n%d
        mo"+"
        mfrac
            mn"1"
            me%r(i+1,d,n%d)
math%[a,b]=data;r(0,a,b)

~~शीघ्र वहाँ दर्द होता है ...~~ओह, तुम्हारा मतलब है मैं लेने के लिए? ठीक है, यह एक सूची है। वैसे भी, सौभाग्य यह चलाने के लिए हो रही है।

— Ry-
स्रोत

0

गेम मेकर लैंग्वेज (स्क्रिप्ट), 61 71

a=argument0;b=argument1;while b!=0{c+=string(a/b)a,b=b,a mod b}return c

के रूप में सभी uninitialized चर के साथ संकलन 0।

— Timtech
स्रोत

1

यह कुछ भी उत्पादन करता है? यह भी गलत लगता है; आप एक स्ट्रिंग को एक नंबर में जोड़ रहे हैं। क्या तुमने कोशिश की?

— दरवाज़े

@Doorknob तुम सही हो, मेरा मतलब था कि देने के लिए c।

— टिमटेक

यह अभी भी नहीं उत्पादन कुछ भी करता है ...

— दरवाज़े

@Doorknob हाँ, यह कुछ भी वापस नहीं करता है, और मेरे पास कुछ सिंटैक्स त्रुटियां थीं। इसे अब सही मूल्य वापस करना चाहिए।

— टिमटेक

0

सह-प्राइम के रूप में इनपुट संख्याओं को मानते हुए, इस प्रक्रिया फ़ंक्शन को अंश और हर के साथ कॉल करें। यह किसी भी गहराई तक जा सकता है जब तक यह निरंतर रूप नहीं पाता, कोई सीमा नहीं

JAVA (238 अक्षर) में लिखा

String space = "";
private void process(int n, int d) {
    System.out.println(space+(n/d)+" + 1");
    space += "    ";
    System.out.println(space+"------");
    if((n % d)==1)
        System.out.println(space+d);
    else
        process(d,(n % d));
}

प्रक्रिया (89,150);

प्रक्रिया (973,13421);

— अनुराग
स्रोत

0

के, 136

{-1@((!#j)#\:" "),'j:(,/{(x,"+ 1";(" ",(2*y)#"-"),"\t")}'[a;1+|!#a:$-1_i]),$*|i:*:'1_{(i;x 2;x[1]-(i:x[1]div x 2)*x@2)}\[{~0~*|x};1,x];}

।

k)f:{-1@((!#j)#\:" "),'j:(,/{(x,"+ 1";(" ",(2*y)#"-"),"\t")}'[a;1+|!#a:$-1_i]),$*|i:*:'1_{(i;x 2;x[1]-(i:x[1]div x 2)*x@2)}\[{~0~*|x};1,x];}
k)f[5 4]
1+ 1
  --
  4

k)f[5 3]
1+ 1
  ----
  1+ 1
    --
    2

k)f[5 7]
0+ 1
  ------
  1+ 1
    ----
    2+ 1
      --
      2

k)f[9 16]
0+ 1
  --------
  1+ 1
    ------
    1+ 1
      ----
      3+ 1
        --
        2

k)f[89 150]
0+ 1
  --------------
  1+ 1
    ------------
    1+ 1
      ----------
      2+ 1
        --------
        5+ 1
          ------
          1+ 1
            ----
            1+ 1
              --
              2

— tmartin
स्रोत

निरंतर अंश प्रदर्शित करें

गणितज्ञ, 40 36 वर्ण

अजगर 2, 158 155 147 142

अजगर 2, alt। संस्करण, 95

XSLT 1.0

रूबी, 175 (ASCII कला के साथ) या 47 (बिना)

ASCII कला के बिना, 47

ASCII कला के साथ, 181 178 175

सेज नोटबुक, 80

C, 119 वर्ण

एपीएल (78)

गणितज्ञ, 77

पर्ल 128 114 चर

पहली पोस्ट: 128 वर्ण

LaTeX का उपयोग कर रहा है:

पर्ल: 140 , 133 121 चार्ट

रेज़र लीफ फ़ॉयरफ़ॉक्स, 108 127

गेम मेकर लैंग्वेज (स्क्रिप्ट), 61 71

के, 136