这个问题不必仅适用于终止小数-重复的小数也可以通过算法转换为分数。

您的任务是制作一个程序，该程序将重复的小数作为输入，并输出产生该小数扩展的相应分子和分母（以最低的条款）。大于1的分数应表示为不正确的分数，例如9/5。您可以假设输入为正。

重复的小数将以以下格式给出：

5.3.87

重复第二个点之后的所有内容，如下所示：

5.3878787878787...

您的程序将输出两个代表分子和分母的整数，并用斜杠分隔（如果不输出纯文本，则为您语言的等效形式）：

889/165

请注意，终止小数点在第二个点之后将没有任何内容，而没有非重复小数部分的小数点将在两个点之间没有任何内容。

测试用例

这些测试用例涵盖了所有必需的极端情况：

0..3 = 1/3
0.0.3 = 1/30
0.00.3 = 1/300
0.6875. = 11/16
1.8. = 9/5
2.. = 2/1
5..09 = 56/11
0.1.6 = 1/6
2..142857 = 15/7
0.01041.6 = 1/96
0.2.283950617 = 37/162
0.000000.1 = 1/9000000
0..9 = 1/1
0.0.9 = 1/10
0.24.9 = 1/4

如果您愿意，还可以假设没有整数部分的分数在第一个点的左侧没有任何内容。您可以使用以下可选测试用例进行测试：

.25. = 1/4
.1.6 = 1/6
..09 = 1/11
.. = 0/1

Dyalog APL（75 73 69 68个字符）

这是另一次和第五次尝试（很可能是我的最后一次尝试）；我花了整整一天的时间来尝试编写一些少于80个字符且完全符合规则的代码。这个挑战让我很开心！

最后，我得到了由75个字符组成的APL行，它与Dyalog APL一起使用（但由于使用了⍎ execute函数，因此不在联机解释器页面上），如下所示：

(N,D)÷D∨N←(⍎'0',1↓I/⍨2=+\P)+(⍎'0',I/⍨2>+\P)×D←D+0=D←⍎'0',⌽2↓⍕¯1+10⊥P←'.'=I← '1.2.3'

当然，我可以使它更短一些，但是在特殊情况下，缺少一，二或三个字段。我的代码甚至可以处理..输入的情况。

我知道APL很难阅读，而且由于人们喜欢理解一段代码的实际工作原理，因此这里有一些解释。基本上，我计算变量D的最终分母和变量N的最终分子。

APL是从右到左解析的。

• 首先，字符串存储在变量I（I←）中。
• 然后，将其映射到指示点在哪里的布尔向量，该向量称为P（P←'.'=）。例如，“ 1.2.3”将映射到0 1 0 1 0。
• 此向量是以10为底的数字（10⊥）；现在“ 1.2.3”是1010。
• 然后从该数字中减去1（使用1-⍨或¯1+，在这里我选择了第二个）。现在“ 1.2.3”是1009。
• 然后，该数字将转换为字符串（⍕），删除两个初始数字（2↓），这从我们的初始“ 1.2.3”示例中得出09；字符串反转（⌽）。
• 在这里，作为一种特殊情况，我在字符串前面添加了一个初始0字符；这让我伤心使用四个字符'0',，但我这样做是为了避免一个错误，当第二和三分之二的字段都为空。字符串将转换回数字（⍎），并将其存储在分母D中，除非最后两个字段均为空，因为在这种情况下D等于0。
• 如果D←D+0=代码段当前为空，则将D设置为1，现在D包含分母（但是在GCD除法之前）。
• 该分母乘以（×）与初始字符串I的内容直到第二个点，第二个点(⍎'0',I/⍨2>+\P)又从P再次开始（在我的示例中为0 1 0 1 0），通过对连续数字求和（使0 1 1 2在我的示例中为2），检查哪些值小于2（使布尔矢量1 1 1 0 0），并在I中采用相应的字符；在字符串前面添加另一个0以防止另一个陷阱（如果两个初始字段为空），则将整个整数转换为数字。
• 输入字符串的最后一部分用添加到的前一个乘积中(⍎'0',1↓I/⍨2=+\P)，再取P，再次进行累加，检查哪些值等于2（请参见前面的说明），取字符，除去第一个为点的字符，添加一个防止开头的0字符并转换为数字。
• 该乘积后加和的结果存储在分子中的N中。
• 最终，用D∨N计算GCD，两个数字均被该GCD除。

编辑：这是73个字符的修复程序：

(N,D)÷D∨N←(⍎'0',1↓P/I)+(⍎'0',I/⍨~P←2=+\P)×D←D+0=D←⍎'0',⌽2↓⍕¯1+10⊥P←'.'=I←

这种破解的思想是首先计算累积加法的值等于2的情况，将其存储以供以后使用，然后反转此按位掩码以获得第一种情况。因此，计算下一种情况需要较少的字符。

编辑：这是69个字符的另一个修复程序：

(N,D)÷D∨N←(⍎'0',1↓P/I)+(⍎'0',I/⍨~P←2=+\P)×D←⍎'1⌈0',⌽2↓⍕¯1+10⊥P←'.'=I←

破解的想法是将最复杂的特殊情况作为APL代码嵌入到要评估的字符串中（在字符串到数字的转换阶段）。

编辑：这是68个字符的另一个修复程序：

(N,D)÷D∨N←(⍎'0',1↓P/I)+(⍎'0',I/⍨~P←2=+\P)×D←⍎'1⌈0',⌽3↓⍕1-10⊥P←'.'=I←

本hack的想法是，以取代添加-1的值用于由操作从其减去1为该值该值从其减去1，然后在开始时除去后一个字符多种（其将是负号）。

编辑：外观变化：

(N,D)÷D∨N←(⍎'0',1↓P/I)+(⍎'0',I/⍨~P←2=+\P)×D←1⌈⍎'0',⌽3↓⍕1-10⊥P←'.'=I←

大小没有改善，但更满意地从要评估的代码中获得最大功能。

Perl 6（93 101 100 80 68 66字节）

$/=split ".",get;say ($0+($1+$2/(9 x$2.comb||1))/10**$1.comb).nude

大小增加了，无法处理任何事情，而不仅仅是失败。Mouq建议使用$/，因此现在正在使用，代码短了20个字节。Ayiko提议将/带，所以代码更短（12个字节）。然后Mouq提议将chars与comb（在数值上下文，它们是相同的，因为转化成数字后的字符列表的字符的数量）。

样本输出：

$ perl6 script.p6
5.3.87
889 165
$ perl6 script.p6
2.0.0
2 1
$ perl6 script.p6
0..3
1 3
$ perl6 script.p6
0.0.3
1 30
$ perl6 script.p6
0.0.0
0 1
$ perl6 script.p6
0.1.6
1 6
$ perl6 script.p6
0.01041.6
1 96
$ perl6 script.p6
0.2.283950617
37 162
$ perl6 script.p6
123.456.789
41111111 333000

J（85 90 89个字符）

我的原始函数比第二个短5个字符，但有几个错误：它没有将整数输出为“ n / 1”，并且对十二位数左右的数字给出了错误的答案。这是J中的更正函数，还结合了Eelvex的建议来保存字符：

f=:3 :0
'a t'=.|:(".@('0','x',~]),10x^#);._1'.',y
(,'/'&,)&":/(,%+.)&1+/a%*/\1,0 1-~}.t
)

它接收一个字符串并返回一个字符串。这是一个示例会话：

   f '..'
0/1
   f '0.0.0'
0/1
   f '3..'
3/1
   f '..052631578947368421'
1/19
   f '0.2.283950617'
37/162
   f '.0.103092783505154639175257731958762886597938144329896907216494845360824742268041237113402061855670'
1/97

C，171

相当长。可以进一步减少。不scanf，如果点之间没有任何数字，那真的无法处理。没有strtol。只是数字运算：

a,b,c,d,q;main(){while((q=getchar()-48)>-3)q<0?(d=b>0,b+=!b):d?(c=c*10+q,d*=10):(a=a*10+q,b*=10);for(a=a*--d+c,q=b*=d;q>1;a%q+b%q?--q:(a/=q,b/=q));printf("%d/%d\n",a,b);}

测试：

rfc <<< "2..142857"
15/7

DC（不完全通用，缩短为76个字符）

并不是很全面，但是请考虑一下我是用世界上最古老的东西之一做的：

5.3.87 dsaX10r^d1-rla*sasbdscX10r^dlc*rlb*rlb*la+snsdlnld[dSarLa%d0<a]dsax+dldr/rlnr/f

编辑：我编辑我的解决方案；它不是更通用，但更短：

sadsbX10r^sclaX10r^dd1-dsdlblc**rla*+dsnrld*dsd[dSarLa%d0<a]dsax+dldr/rlnr/f

用作：

5.3.87 sadsbX10r^sclaX10r^dd1-dsdlblc**rla*+dsnrld*dsd[dSarLa%d0<a]dsax+dldr/rlnr/f

• 不需要第一个字段：

  .1.3 sadsbX10r^sclaX10r^dd1-dsdlblc**rla*+dsnrld*dsd[dSarLa%d0<a]dsax+dldr/rlnr/f
  

  还可以

• 第二和口渴字段至少需要一位数字

JavaScript 203

太长了，但仍然很有趣。换行符，因为分号不可读。

s=prompt(b=1).split(".")
P=Math.pow
a=s[0]
c=s[1]
d=P(10,l=c.length)
f=(P(10,s[2].length)-1)*P(10,l)||1
e=s[2]=+s[2]
a=d*a+b*c;b*=d
a=f*a+b*e;b*=f
function g(a,b){return b?g(b,a%b):a}g=g(a,b);a/g+"/"+b/g

J（不同的方法）

基于完全不同的方法的另一种解决方案；这次完全笼统了；提交整数时，唯一缺少的是1分母：

   ".((({.~(i.&1)),'+'"_,((":@(10&^)@#,'%~',])@}.@#~~:/\),'+%',((,~(##'9'"_),'%x:0'"_)@}.@#~2:=+/\@]))(=&'.')) '.1.3'
2r15
   ".((({.~(i.&1)),'+'"_,((":@(10&^)@#,'%~',])@}.@#~~:/\),'+%',((,~(##'9'"_),'%x:0'"_)@}.@#~2:=+/\@]))(=&'.')) '.1.'
1r10
   ".((({.~(i.&1)),'+'"_,((":@(10&^)@#,'%~',])@}.@#~~:/\),'+%',((,~(##'9'"_),'%x:0'"_)@}.@#~2:=+/\@]))(=&'.')) '1..'
1
   ".((({.~(i.&1)),'+'"_,((":@(10&^)@#,'%~',])@}.@#~~:/\),'+%',((,~(##'9'"_),'%x:0'"_)@}.@#~2:=+/\@]))(=&'.')) '1..3'
4r3

GolfScript（67个字符）

`{'.'/1$=.10\,?@-).!+0@+~}+3,/1$4$*]-1%~;*+*+].~{.@\%.}do;{/}+/'/'@

注意：这支持空整数部分。

如果字符串为格式，'n.p.q'则该值是n + p/E + q/(DE) = ((nD + p)E + q)/DEwhere D = 10^(len p)和E = 10^(len q) - 1，除非是 when len q = 0，在这种情况下E = 1（以避免除以0）。

解剖：

           # Stack: 'n.p.q'
`{         # Combined with the }+ below this pulls the value into the block
           # Stack: idx 'n.p.q'
    '.'/   # Stack: idx ['n' 'p' 'q']
    1$=    # Stack: idx str   (where str is the indexed element of ['n' 'p' 'q'])
    .10\,? # Stack: idx str 10^(len str)
    @-)    # Stack: str 10^(len str)-idx+1
           #   If idx = 0 we don't care about the top value on the stack
           #   If idx = 1 we compute D = 10^(len 'p')
           #   If idx = 2 we compute E' = 10^(len 'q') - 1
    .!+    # Handle the special case E'=0; note that D is never 0
    0@+~   # Stack: 10^(len str)-idx+1 eval('0'+str) (GolfScript doesn't treat 011 as octal)
}+         # See above
3,/        # Run the block for idx = 0, 1, 2
           # Stack: _ n D p E q
1$4$*      # Stack: _ n D p E q D*E
]-1%~;     # Stack: D*E q E p D n
*+*+       # Stack: D*E q+E*(p+D*n)
].~        # Stack: [denom' num'] denom' num'
{.@\%.}do; # Stack: [denom' num'] gcd
{/}+/      # Stack: denom num
'/'@       # Stack: num '/' denom

在线演示，它使用每个测试输入模拟一次运行程序。

蟒蛇

没有图书馆-156个字符

_=lambda a,b:b and _(b,a%b)or a;a,b,c=raw_input().split('.');d,e=int(a+b+c)-bool(c)*int(a+b),
(10**len(c)-bool(c))*10**len(b);f=_(d,e);print'%i/%i'%(d/f,e/f)

使用fractions-127个字符

from fractions import*;a,b,c=raw_input().split('.');print Fraction(int(a+b+c)-bool(c)*int(a+b
),(10**len(c)-bool(c))*10**len(b))

Mathematica，143

与往常一样，Mathematica提供了许多高级功能来完成这项工作，但给它们起了冗长的名称。

x=StringTake;c=ToExpression;p=s~StringPosition~".";{o,t}=First/@p;u=StringLength@s-t;d=t-o-1;Rationalize@(c@x[s,t-1]+c@x[s,-u]/((10^u)-1)/10^d)

样本输出将在以后有时间时添加。

红宝石-112

x,y,z=gets.chop.split".";y||='0';z||='0';puts((y.to_i+Rational(z.to_i,10**z.length-1))/10**y.length+x.to_i).to_s

这是我对红宝石的第一个实验，请随时提出改进建议。

$ ruby20 % <<< '5.3.87'
889/165
$ ruby20 % <<< '0..3'
1/3
$ ruby20 % <<< '0.0.3'
1/30
$ ruby20 % <<< '0.00.3'
1/300
$ ruby20 % <<< '0.6875.0'
11/16
$ ruby20 % <<< '1.8.0'
9/5
$ ruby20 % <<< '2..'
2/1
$ ruby20 % <<< '..'
0/1

C 164

即使我从头开始，它也类似于猎户座的C解决方案。但是，我承认窃取了他的许多优化。它不是很短，但是可以处理.25。= 1/4和0.000000.1 = 1/9000000。

long a,b,c,d,e;main(){while((c=getchar()-48)>-3)c+2?a=a*10+c,b*=10:b?e=a,d=b:(b=1);
b>d?a-=e,b-=d:0;for(d=2;d<=a;)a%d+b%d?d++:(a/=d,b/=d);printf("%ld/%ld\n",a,b);}

不使用库的两个python答案。First处理first之前的可选输入而没有数字。是162个字符

_=lambda a,b:b and _(b,a%b)or a;i,t,r=raw_input().split(".");b=r!="";d=(10**len(r)-b)*10**len(t);n=int((i+t+r)or 0)-b*int((i+t)or 0);f=_(d,n);print "%i/%i"%(n,d)

第二个字符在第一个数字之前不会处理任何内容，但会正确处理所有必需的输入，并且为150个字符

_=lambda a,b:b and _(b,a%b)or a;i,t,r=raw_input().split(".");b=r!="";d=(10**len(r)-b)*10**len(t);n=int(i+t+r)-b*int(i+t);f=_(d,n);print "%i/%i"%(n,d)

哈斯克尔

import Data.Ratio
f n=case s '.' n of
    [x,y,z]->(r x)%1+(r y)%(10^(length y))+(r z)%((10^t-1)*(10^(length y)))
        where
            r ""=0
            r n=read n
            t = if length z==0 then 9 else length z
s _ []=[[]]
s n (x:xs) | x==n = []:(s n xs)
           | otherwise = let (l:ls)=s n xs in (x:l):ls

的JavaScript（EcmaScript的6）180 175

G=(a,d)=>d?G(d,a%d):a;P=a=>+("1e"+a);L=a=>a.length;f=prompt().split(".");B=P(L(b=f[1]));D=P(L(b)+L(c=f[2]))-P(L(b))||1;alert((m=(f[0]+b||0)*D+B*(c||0))/(g=G(m,n=B*D))+"/"+n/g)

虽然不是300赏金的明显赢家...这是我能想到的最短的奖赏：

• 与先前版本的更改：对逻辑进行了一些细微改动，并通过将Power P函数更改为+("1e"+a)而不是Math.pow(10,a)由此节省了更多字符来更改Power 函数...

Mathematica 175

f@i_:=
If[IntegerQ[g=FromDigits[Map[IntegerDigits@ToExpression@#&,StringSplit[i,"."]/.""-> {}]
/.{a_,b_,c_}:> {{Sequence@@Join[a,b],c},Length@a}]],HoldForm[Evaluate@g]/HoldForm@1,g]

大部分例程用于按摩输入。大约50个字符用于处理整数。

例子

f["7801.098.765"]

更多示例：

TableForm[
 Partition[{#, f[#]} & /@ {"19..87", "19.3.87", "5.3.87", "0.0.3", "0..3", "0.2.283950617", 
"123.456.789", "6666.7777.8888", "2.0.0","0.0.0"}, 5], TableSpacing -> {5, 5}]

在Mathematica中通常如何完成

FromDigits可以直接从重复的十进制小数中获得分数，只要输入形式特殊。整数显示为整数。

z={{{1, 9, {8, 7}}, 2}, {{1, 9, 3, {8, 7}}, 2}, {{5, 3, {8, 7}}, 1}, {{{3}}, -1}, {{{3}}, 0}, 
{{2, {2, 8, 3, 9, 5, 0, 6, 1, 7}}, 0}, {{1, 2, 3, 4, 5, 6, {7, 8, 9}}, 3}, 
{{6, 6, 6, 6, 7, 7, 7, 7, {8}}, 4}, {{2}, 1}, {{0}, 1}}

FromDigits/@z

J（96个字符）

我不使用斜杠符号作为分隔符（但是Mathematica中的解决方案也没有，因为它使用了更好的图形表示形式）。在J语言中，分数显示r为/：

   (((-.@]#[)((".@[%#@[(10x&^)@-{.@])+({.@](10x&^)@-#@[)*<:@{:@](".%<:@(10x&^)@#)@}.[)I.@])(=&'.')) '1..3'
4r3
   (((-.@]#[)((".@[%#@[(10x&^)@-{.@])+({.@](10x&^)@-#@[)*<:@{:@](".%<:@(10x&^)@#)@}.[)I.@])(=&'.')) '123.456.789'
41111111r333000

APL（不完全通用）

不完全通用（例如我的直流解决方案）；可与Dyalog APL一起使用（但不能在Dyalog APL的在线版本上使用，不确定为什么）：

(R,F)÷(F←D×N)∨R←(⍎C)+D×(⍎I/⍨2>+\P)×N←10*¯1++/≠\P⊣D←¯1+10*⍴C←1↓I/⍨2=+\P←'.'=I← '123.456.789'

第一个字段是可选的，但其他两个字段至少需要一个数字。

的JavaScript（189）

i=prompt().split(".");a=i[0];b=i[1];c=i[2];B=b.length;p=Math.pow;n=a+b+c-(a+b);d=p(10,B+c.length)-p(10,B);f=1;while(f){f=0;for(i=2;i<=n;i++)if(n%i==0&&d%i==0){n/=i;d/=i;f=1}};alert(n+"/"+d)

例：

输入：

5.3.87

输出：

889/165

C（写为420个字符；删除不必要的空格后较少）

注意，这里假设使用64位long（例如64位Linux）；0.2.283950617在使用32位的系统上，该测试用例将失败long。可以通过将类型long long更改为并相应地更改printf格式字符串来解决某些字符的问题。

#include <stdio.h>

long d[3], n[3], i;

int main(int c, char** v)
{
  while (c = *v[1]++)
    switch(c)
    {
    case '.':
      n[++i] = 1;
      break;
    default:
      d[i] = 10 * d[i] + c - '0';
      n[i] *= 10;
    }

  n[2] -= n[2] != 1;

  while (i--)
    d[2] += d[i] * n[i+1], n[i]*=n[i+1];

  i = d[2];
  *n = n[1];

  while (i)
    *d = i, i = *n%i, *n = *d;
  printf("%ld/%ld\n", d[2]/ *n, n[1]/ *n);
}

GTB，81

`_:s;_,1,l?_)-S;_,"."
s;A;,1,S;_,".")-1
s;_,1+S;_,"."),l?_)-S;_,"."))→_
x?A;+_)►Frac

例

?3.25.
            13/4