Número misto para uma fração imprópria

Neste desafio, você converterá um número misto em uma fração imprópria.

Como frações impróprias usam menos números, seu código precisará ser o mais curto possível.

Exemplos

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Especificação

Você pode assumir que o denominador da entrada nunca será 0. A entrada sempre estará no formato em x y/zque x, y, z são números inteiros não negativos arbitrários. Você não precisa simplificar a saída.

Este é o código-golfe, pelo que o código mais curto em bytes vence.

Japonês, 10 bytes

Woohoo, atualmente batendo CJam!

U*W+V+'/+W

Experimente online!

Como funciona

       // 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 primitivas do LabVIEW

CJam, 16 15 14 bytes

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

ou

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

Teste aqui.

Explicação

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.

A outra versão evita o uso de uma variável usando um deslocamento de pilha um pouco mais.

Mathematica, 58 bytes

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

Isso retorna o resultado simplificado. Se a saída de um número racional em vez de uma string estiver correta, podemos salvar 19 bytes:

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

PowerShell, 47 44 42 bytes

_{O riscado 44 ainda é regular 44;}

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

Golfou alguns bytes usando regex -split. Golf mais um par de graças ao TessellatingHeckler trocando o regex.

Ele $args-split'\D'pega nosso argumento de entrada e divide em caracteres que não são dígitos. Aqui, ele executa duas divisões, uma em espaço em branco e a outra no /personagem. Os resultados são armazenados nas três variáveis ​​usando uma atribuição simultânea. Em seguida, formulamos a saída da string como (o $lnúmero eft vezes o $denominator mais o $numerator) executado como um bloco de código, uma /barra e, em seguida, o $denominator novamente.

Java com pólo a laser de dez pés 1.03, 79 + 25 (importação) = 104 bytes

Requer import sj224.tflp.math.*;

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

Isso quase certamente funcionará com a 1.04 também, mas até agora só a testei com a 1.03, porque já havia um projeto java configurado com a 1.03 no caminho da compilação.

JavaScript (ES6), 44 41 bytes

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

Economizou 3 bytes graças a @ETHproductions !

Explicação

Muito simples.

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

Teste

O teste é sem atribuição de desestruturação para funcionar na maioria dos navegadores.

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>

Julia, 58 50 bytes

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

Esta é uma função anônima que aceita uma string e retorna um Rationalobjeto de tipo. Para chamá-lo, dê um nome, por exemplo f=s->....

Podemos tirar vantagem do fato de que a entrada pode ser manipulada levemente para ser uma expressão que é avaliada como racional. Em particular, um número inteiro mais um racional é um racional, e os racionais são indicados com barras duplas. Portanto, se nos transformarmos 4 1/2em 4+1//2, o resultado avaliado será 9//2.

Ungolfed:

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 caracteres

A entrada corresponde exatamente ao delimitador da matriz e à representação da fração inerente do Smalltalk. Se não fosse tão detalhado, poderia ter sido um candidato sério!

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

É uma pena que a simplificação não fosse um requisito, o Smalltalk faz isso automaticamente!

Bash + coreutils, 28

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

$@expande para todos os parâmetros da linha de comando, portanto, ${@/\// }expande para todos os parâmetros da linha de comando /substituídos por , que é colocado na dcpilha de. O resto é simples manipulação de pilha e aritmética.

Haskell , 74 67 63 bytes

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

Experimente online!

Explicação

Como H.PWiz descobriu, podemos usar o lexer de Haskell aqui para quebrar a corda em suas partes. (No começo eu estava usando span(>'/')) E Laikoni apontou que <$>funciona exatamente como mapSndem Data.Tuple.

O protetor de padrão divide nosso código nos três números que queremos usar lex. lexchama o lexer de haskell para interromper o primeiro token. Ele retorna uma lista com cada elemento representando uma maneira possível de analisar a sequência. Esses elementos são tuplas, com o primeiro elemento sendo o primeiro token e o restante da string sendo o segundo elemento. Agora, como o formato de entrada é muito regular, apenas teremos exatamente uma análise, para que possamos sempre fazer a primeira. A primeira coisa que fazemos é chamar lexna entrada

lex x

Em seguida, desembrulhámo-lo da lista, fornecendo uma

lex x!!0

O primeiro token será a parte inteira da fração mista, deixando a fração precedida por um espaço para análise. Então, como as tuplas são Functors, podemos usar (<$>)um alias para fmapaplicar lexao segundo elemento da tupla.

lex<$>lex x!!0

Isso consome o espaço e interrompe o próximo token, o numerador da nossa fração. Agora, vinculamos isso a uma correspondência de padrão usando <-. Nosso padrão é

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

aagarra a parte inteira da fração, nosso primeiro token. :_desembrulha a lista resultante do nosso segundo lex. cpega o segundo token que inserimos, que é o numerador da fração. Tudo o que resta está vinculado ao s:dque o divide em seu primeiro caractere, garantido pelo formato de a /e o restante, que será o denominador.

Agora que analisamos a entrada, fazemos o cálculo real:

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

Onde restá a função de leitura que ligamos anteriormente.

É importante observar que lexretorna uma lista vazia se falhar e não vazia se for bem-sucedida. Por que isso não é um Maybeeu não sei.

Javascript ES6, 62 bytes

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

Perl, 82 61 38 bytes

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

Provavelmente isso pode ser jogado mais.

Alterar

• Salva 16 bytes usando uma regex em splite 5 usando em <>vez de <STDIN>.
• Economizou outros 16 bytes graças a Dennis.

Mathematica, 51 bytes

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

Curiosamente, o Mathematica suporta isso com um built-in. Se a saída de um número for permitida, precisamos apenas de 28 bytes:

Interpreter@"ComputedNumber"

Java, 159 148 142 120 110 bytes

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;}

Economizou um monte de bytes graças ao FlagAsSpam.

ARBLE , 13 bytes

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

Experimente online!

05AB1E , 17 15 bytes

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

-2 bytes graças a @MagicOctopusUrn .

Experimente online ou verifique todos os casos de teste .

Explicação:

#`         # 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"

Com o formato flexível de entrada e saída, pegando os números inteiros na ordem x,z,ye emitindo o nominador e o denominador em linhas separadas, seria de 4 bytes (e foi por isso que adicionei a tag de análise ao desafio ..):

*+²»

Experimente online ou verifique todos os casos de teste .

Explicação:

*        # 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 bytes

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

Experimente online!

Stax , 1 byte

+

Execute e depure (embora não haja muito o que depurar)

A especificação do desafio diz "Você não precisa simplificar a saída". Supondo que seja permitido simplificar, há uma instrução interna no stax para fazer isso. A entrada é implicitamente interpretada como um número inteiro e um número racional. A +instrução amplia ambos para os racionais, adiciona e simplifica. O resultado é impresso implicitamente.

Perl 5 com -la -Mfeature = digamos, 32 bytes 25 bytes

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

Experimente online!

(-7 bytes graças a Dom Hastings)

$_é a entrada inteira x y/z, que avalia o valor xem contextos numéricos (como o *aqui). $'é a cadeia de caracteres pós-correspondência regex, que aqui contém o que vem depois /- então z,. Para obter o yvalor, usamos a -aflag que divide a entrada em espaços e as coloca na @Fmatriz. Então aqui, o @F = ("x", "y/z")que significa o $F[1]="y/z"que é avaliado em ycontextos numéricos (já que yé a sequência contígua inicial de dígitos com $F[1]).

Lua, 123 bytes

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)

Via Láctea 1.6.0 , 31 bytes

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

Acabou sendo muito mais longo do que eu pensava.

Explicação

'" "\="/"\=>;<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

Uso

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

Python 2.7, 88 bytes

a = input (). split ('/'); print int (a [-1]) * int (a [0] .split () [0]) + int (a [0] .split () [1 ]), '/', a [1]

Experimente online !

Você deve digitar a entrada entre aspas.

Provavelmente não é o melhor ...

C, 64

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

Lê a entrada de STDIN. Bastante auto-explicativo, eu acho.

Verifique , 120 bytes

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

Experimente online!

Talvez eu consiga salvar alguns bytes se não tentar reutilizar o loop de análise (a segunda linha). Dessa forma, eu poderia tornar o loop mais específico, evitar a enorme confusão de condicionais e usar o registro para outras coisas.

Ruby , 23 bytes

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

Experimente online!

C #, 112 bytes

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;}

Versão completa / formatada:

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 bytes

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

Experimente online!

Graças a ngn pelo ⊃⊥1∘↓truque

PHP, 65 bytes

Experimente online

Código

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

Explicação

$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 bytes

Um lambda de Stringpara String.

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

Experimente Online