分数混合不正确

在此挑战中，您将把带分数转换成不正确的分数。

由于不正确的分数使用较少的数字，因此您的代码将需要尽可能短。

例子

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

规格

您可以假设输入的分母永远不会为0。输入将始终采用x y/zx，y，z为任意非负整数的格式。您无需简化输出。

这是代码高尔夫球，因此以字节为单位的最短代码获胜。

Japt，10个字节

Woohoo，目前击败CJam！

U*W+V+'/+W

在线尝试！

怎么运行的

       // Implicit: [U,V,W] = eval(input). This automatically discards the slash.
U*W+V  // Calculate the new numerator: (whole part * denominator) + numerator.
+'/+W  // Add the slash and the denominator.
       // Implicit: output last expression

LabVIEW，29个LabVIEW原语

CJam，16 15 14字节

l'/']er~:Xb'/X

要么

l'/']er~_@b'/@

在这里测试。

说明

l      e# Read input.
'/']er e# Replace the "/" with a "]".
~      e# Evaluate the string as code. If the input was "i n/d", this pushes [i n] d.
:X     e# Store the denominator in X.
b      e# Treat [i n] as base-d digits. This effectively computes i*d + n.
'/     e# Push a slash.
X      e# Push the denominator.

另一个版本通过使用更多的堆栈移位来避免使用变量。

Mathematica，58个字节

ToExpression@StringReplace[#," "->"+"]~ToString~InputForm&

这将返回简化的结果。如果输出有理数而不是字符串是可以的，那么我们可以节省19个字节：

ToExpression@StringReplace[#," "->"+"]&

PowerShell，47 44 42字节

_{划掉44仍然是常规44;（}

$l,$n,$d=$args-split'\D';"$(+$l*$d+$n)/$d"

使用正则表达式打了几个字节-split。通过交换正则表达式，多亏了TessellatingHeckler来打高尔夫球。

在$args-split'\D'采用我们的输入参数和分割非数字字符。在这里，它执行两个拆分，一个拆分为空白，另一个拆分为/字符。然后使用同时赋值将结果存储在三个变量中。然后，我们将输出的字符串表示为（代码的eft $l数乘以$d分隔符加上$n分子），并作为代码块，/斜杠，然后是$d分隔符再次执行。

带有十英尺激光极点的 Java 1.03,79 + 25（导入）= 104字节

需要 import sj224.tflp.math.*;

String m(String[]a){return ""+new BigRational(a[0]).add(new BigRational(a[1]));}

这几乎肯定也可以在1.04上使用，但是到目前为止，我只在1.03上进行过测试，因为我已经在构建路径中碰巧将Java项目设置为1.03。

JavaScript（ES6），44 41字节

m=>([x,y,z]=m.match(/\d+/g),+y+x*z+"/"+z)

@ETHproductions节省了3个字节！

说明

很简单的。

m=>
  ([x,y,z]=m.match(/\d+/g), // x, y and z = numbers from input
    +y+x*z                  // numerator
    +"/"+z                  // denominator
  )

测试

测试不会破坏大多数浏览器的工作分配。

var solution = m=>+(p=m.match(/\d+/g))[1]+p[0]*p[2]+"/"+p[2]

<input type="text" id="input" value="11 23/44" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

朱莉娅58 58字节

s->eval(parse((r=replace)(r(s," ","+"),"/","//")))

这是一个匿名函数，它接受一个字符串并返回一个Rational类型对象。要给它起个名字，例如f=s->...。

我们可以利用这样一个事实，即可以对输入进行微调以使其成为评估有理数的表达式。特别是，整数加有理数是有理数，并且用双斜杠表示有理数。因此，如果转4 1/2成4+1//2，评估结果将为9//2。

取消高尔夫：

function f(s::AbstractString)
    # Replace the space in the input with a plus
    r1 = replace(s, " ", "+")

    # Replace the / with //
    r2 = replace(r1, "/", "//")

    # Parse the resulting expression as a rational
    return eval(parse(r2))
end

Smalltalk – 76个字符

输入与Smalltalk的数组定界符和固有分数表示形式完全匹配。如果不是那么冗长，那可能是一个认真的竞争者！

Compiler evaluate:'|p|p:=0.#(',FileStream stdin nextLine,')do:[:q|p:=p+q].p'

太简单了，不是必须的，Smalltalk会自动做到！

Bash + coreutils，28岁

dc<<<${@/\// }sarla*+n47Plap

$@扩展为所有命令行参数，因此${@/\// }扩展为所有/替换为的命令行参数，该参数放在dc的堆栈中。其余的是简单的堆栈操作和算术运算。

Haskell，74 67 63字节

r=read
f x|(a,(c,s:d):_)<-lex<$>lex x!!0=show(r a*r d+r c)++s:d

在线尝试！

说明

正如H.PWiz指出的那样，我们可以在这里使用Haskell的词法分析器将字符串分解成一部分。（我以前span(>'/')用过。）Laikoni指出了它的<$>运作就像mapSnd从Data.Tuple。

模式卫士将我们的代码分成我们要使用的三个数字lex。 lex调用haskell的词法分析器中断第一个令牌。它返回一个列表，其中每个元素代表解析字符串的一种可能方法。这些元素是元组，第一个元素是第一个标记，字符串的其余部分是第二个元素。现在，由于输入格式非常规则，因此我们只会有一个解析，所以我们总是可以采用第一个解析。我们要做的第一件事是lex在输入上调用

lex x

然后我们从列表中解开它，给我们一个2元组

lex x!!0

第一个标记将是混合分数的整个部分，而分数之前会留有空格以供解析。然后，由于元组是，Functors我们可以使用(<$>)别名将fmap其应用于lex元组的第二个元素。

lex<$>lex x!!0

它吞噬了空间并打破了下一个标记，即分数的分子。现在，我们使用将其绑定到模式匹配<-。我们的模式是

(a,(c,s:d):_)

a抓住分数的整个部分，我们的第一个令牌。:_解开由我们第二个清单产生的清单lex。 c抓取我们词法化的第二个标记，即分数的分子。剩下的所有内容都将绑定s:d到它的第一个字符，并由格式保证为a /，其余部分为分母。

既然我们已经解析了输入，就可以进行实际的计算了：

show(r a*r d+r c)++s:d

r我们前面绑定的读取函数在哪里。

重要的是要注意，lex如果失败，则返回列表，如果成功，则返回非空。为什么这不是Maybe我不知道的。

Javascript ES6，62个字节

p=prompt;b=p(a=+p()).split`/`;alert((+b[1]*a+ +b[0])+"/"+b[1])

Perl，82 61 38字节

#!perl -paF/\D/
$_=$F[0]*$F[2]+$F[1]."/$F[2]"

这可能打得更多。

变化

• 在中使用正则表达式可节省16个字节split，而使用<>代替可节省5个字节<STDIN>。
• 感谢Dennis，又节省了16个字节。

Mathematica，51个字节

Interpreter["ComputedNumber"]@#~ToString~InputForm&

有趣的是，Mathematica内置了对此功能的支持。如果允许输出数字，那么我们只需要28个字节：

Interpreter@"ComputedNumber"

Java中，159个 148 142 120 110字节

String m(String[]a){Long b=new Long(a[0]),d=new Long((a=a[1].split("/"))[1]);return b*d+new Long(a[0])+"/"+d;}

感谢FlagAsSpam，节省了一堆字节。

ARBLE，13个字节

a*c+b.."/"..c

在线尝试！

05AB1E，17 15 字节

#`'/¡R`Š©*+®'/ý

-2个字节，感谢@MagicOctopusUrn。

在线尝试或验证所有测试用例。

说明：

#`         # Split input by spaces and push all items to the stack
           #  i.e. "4 1/2" → "4" and "1/2"
  '/¡      # Push the second item by "/"
           #  i.e. "1/2" → [1,2]
     R`    # Revert the list, and also push all items to the stack
           #  i.e. [1,2] → [2,1] → 2 and 1
Š          # Triple-swap the stack
           #  [4,2,1] → [1,4,2]
 ©         # Store the 2 in the register
  *        # Multiple the top two items
           #  4 and 2 → 8
   +       # Add the top two items
           #  1 and 8 → 9
®          # Push the 2 from the register to the stack again
 '/ý       # Join the two items by "/"
           #  9 and 2 → "9/2"

使用灵活的输入和输出格式，按顺序取整数x,z,y并在分隔的行上输出分母和分母将是4个字节（这就是为什么我向该挑战添加了解析 -tag的原因。）：

*+²»

在线尝试或验证所有测试用例。

说明：

*        # Multiply the first two inputs (x and z)
         #  i.e. 4 and 2 → 8
 +       # Add the third input (y)
         #  i.e. 8 and 1 → 9
  ²      # Take the second input again (z)
   »     # Join the stack by newlines and implicitly print it

Python 3中，78 76个字节

def f(s):a,b=s.split();b,c=b.split('/');return'%s/'%(int(a)*int(c)+int(b))+c

在线尝试！

Stax，1个字节

+

运行并调试（尽管调试的东西不多）

挑战规范说：“您不需要简化输出。” 假设允许简化，那么stax中有一个内置指令可以做到这一点。输入被隐式解释为整数和有理数。该+指令将范围扩大到有理，增加和简化。结果被隐式打印。

具有-la -Mfeature = say的Perl 5，32 字节 25字节

m|/|;say$_*$'+$F[1],"/$'"

在线尝试！

（由于Dom Hastings，-7个字节）

$_是整个输入x y/z，它x在数字上下文（如此*处）中评估的值。$'是正则表达式的匹配后字符串，这里包含后面的所有内容/-因此，z。为了获得该y值，我们使用了-a将输入分割为空格并将其放置在@F数组中的标志。因此，这里的@F = ("x", "y/z")表示在数字上下文中$F[1]="y/z"求值y（因为y带有的初始连续数字序列$F[1]）。

Lua，123字节

m=io.read()z=string x=z.find c=z.sub b=tonumber s=x(m," ")f=x(m,"/")d=c(m,f+1)print(b(c(m,1,s))*b(d)+b(c(m,s,f-1)).."/"..d)

银河1.6.0，31字节

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

最终比我想象的要长得多。

说明

'" "\="/"\=>;<A;A;:>*;A+"/"+<+!

'                                # read input from the command line
 " "  "/"               "/"      # push a string to the stack
    \    \                       # split the STOS at the TOS
     =    =                      # dump the TOS to the stack
           >       >             # rotate the stack rightward
            ;  ; ;   ;           # swap the TOS and STOS
             <              <    # rotate the stack leftward
              A A     A          # push the integer representation of the TOS
                  :              # duplicate the TOS
                    *            # multiply the STOS by the TOS
                       +   + +   # add the TOS and STOS
                              !  # output the TOS

用法

./mw <path-to-code> -i <input>

Python 2.7，88字节

a = input（）。split（'/'）; print int（a [-1]）* int（a [0] .split（）[0]）+ int（a [0] .split（）[1 ]），'/'，a [1]

在线尝试！

您必须以引号输入输入。

可能不是最好的...

C，64

main(i,d,n){scanf("%d %d/%d",&i,&n,&d);printf("%d/%d",i*d+n,d);}

从STDIN读取输入。我认为，这很不言自明。

检查，120字节

>]+>:>32r#v
#d@0+\)  ##:>4;:>5'=:>48-\R-?
dd)R>32-#v
#>15-#v  #?
47r@>@   #v
#dd#v #?
r@>@     #v
    #\d@\: @*@+pd"/"op

在线尝试！

通过不尝试重用解析循环（第二行），我也许可以节省一些字节。这样，我可以使循环更具体，避免造成太多的条件混乱，并且可以将寄存器用于其他用途。

红宝石，23个字节

->x{eval x.split*?++?r}

在线尝试！

C＃，112字节

s=>{string[]a=s.Split(),b=a[1].Split('/');int o=int.Parse(b[1]);return int.Parse(a[0])*o+int.Parse(b[0])+"/"+o;}

完整/格式化版本：

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<string, string> f = s =>
            {
                string[] a = s.Split(), b = a[1].Split('/');
                int o = int.Parse(b[1]);
                return int.Parse(a[0]) * o + int.Parse(b[0]) + "/" + o;
            };

            Console.WriteLine(f("4 1/2"));
            Console.WriteLine(f("12 2/4"));
            Console.WriteLine(f("0 0/2"));
            Console.WriteLine(f("11 23/44"));

            Console.ReadLine();
        }
    }
}

APL（Dyalog Unicode），31个字节

∊∘(⍕¨⊃,⍨'/',⍨⊃⊥1∘↓)¯1⌽#⍎¨∊∘⎕D⊆⊢

在线尝试！

感谢ngn的⊃⊥1∘↓把戏

PHP，65字节

在线尝试

码

<?=(($a=preg_split("/[\s,\/]/",$argv))[0]*$a[2]+$a[1])."/".$a[2];

说明

$a=preg_split("/[\s,\/]/",$argv); # Split the string on "/" and " "
(($a)[0]*$a[2]+$a[1]) # as always denominator*whole number + numerator 
."/"                  # echo an slash
.$a[2];               # echo de denominator

Java 10，87个字节

从String到的Lambda String。

s->{var p=s.split(" |/");return new Long(p[0])*new Long(p[2])+new Long(p[1])+"/"+p[2];}

在线试用