Número mixto a una fracción impropia

En este desafío, convertirás un número mixto en una fracción impropia.

Debido a que las fracciones impropias usan menos números, su código deberá ser lo más corto posible.

Ejemplos

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Especificación

Puede suponer que el denominador de la entrada nunca será 0. La entrada siempre estará en el formato x y/zdonde x, y, z son enteros arbitrarios no negativos. No necesita simplificar la salida.

Este es el código de golf, por lo que el código más corto en bytes gana.

Japt, 10 bytes

¡Woohoo, actualmente venciendo a CJam!

U*W+V+'/+W

Pruébalo en línea!

Cómo 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 de LabVIEW

CJam, 16 15 14 bytes

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

o

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

Pruébalo aquí.

Explicación

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.

La otra versión evita usar una variable al usar un poco más de cambio de pila.

Mathematica, 58 bytes

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

Esto devuelve el resultado simplificado. Si generar un número racional en lugar de una cadena está bien, podemos guardar 19 bytes:

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

PowerShell, 47 44 42 bytes

_{Tachado 44 sigue siendo regular 44; (}

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

Golfé un par de bytes usando regex -split. Golfé un par más gracias a TessellatingHeckler intercambiando la expresión regular.

La $args-split'\D'toma nuestro argumento de entrada y se divide en caracteres que no sean dígitos. Aquí realiza dos divisiones, una en el espacio en blanco y la otra en el /personaje. Los resultados se almacenan en las tres variables mediante una asignación simultánea. Luego formulamos el resultado de la cadena como (el $lnúmero eft multiplicado por el $denominador más el $numerador) ejecutado como un bloque de código, una /barra diagonal y luego el $denominador nuevamente.

Java con Ten Foot Laser Pole 1.03, 79 + 25 (importación) = 104 bytes

Requiere import sj224.tflp.math.*;

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

Esto casi seguro también funcionará con 1.04, pero hasta ahora solo lo he probado con 1.03 porque ya tenía un proyecto Java configurado con 1.03 en la ruta de compilación.

JavaScript (ES6), 44 41 bytes

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

¡ Ahorró 3 bytes gracias a @ETHproductions !

Explicación

Muy simple.

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

Prueba

La prueba es sin asignación de desestructuración para trabajar en la mayoría de los 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 es una función anónima que acepta una cadena y devuelve un Rationalobjeto de tipo. Para llamarlo, dale un nombre, por ejemplo f=s->....

Podemos aprovechar el hecho de que la entrada puede manipularse ligeramente para ser una expresión que se evalúa como racional. En particular, un número entero más un racional es un racional, y los racionales se denotan con barras dobles. Entonces, si nos convertimos 4 1/2en 4+1//2, el resultado evaluado será 9//2.

Sin golf:

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

La entrada coincide exactamente con el delimitador de matriz y la representación de fracción inherente de Smalltalk. Si simplemente no fuera tan detallado, ¡podría haber sido un contendiente serio!

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

Es una pena que la simplificación no fuera un requisito, Smalltalk lo hace automáticamente.

Bash + coreutils, 28

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

$@se expande a todos los parámetros de la línea de comandos, por lo que se ${@/\// }expande a todos los parámetros de la línea de comandos con /reemplazado por , que se coloca en dcla pila. El resto es simple manipulación de pila y 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

Pruébalo en línea!

Explicación

Como H.PWiz descubrió, podemos usar el lexer de Haskell aquí para dividir la cuerda en sus partes. (Anteriormente estaba usando span(>'/')) Y Laikoni señaló que <$>funciona igual que mapSnddesde Data.Tuple.

El protector de patrón divide nuestro código en los tres números que queremos usar lex. lexinvoca el lexer de Haskell para romper la primera ficha. Devuelve una lista con cada elemento que representa una forma posible de analizar la cadena. Estos elementos son tuplas con el primer elemento como el primer token y el resto de la cadena como el segundo elemento. Ahora, dado que el formato de entrada es muy regular, solo vamos a tener exactamente un análisis, por lo que siempre podemos tomar el primero. Lo primero que hacemos es invocar lexen la entrada

lex x

Luego lo desenvolvemos de su lista dándonos una tupla de 2

lex x!!0

La primera ficha será la parte completa de la fracción mixta, dejando la fracción antepuesta por un espacio para analizar aún. Entonces, dado que las tuplas son Functors, podemos usar (<$>)un alias para fmapaplicar lexal segundo elemento de la tupla.

lex<$>lex x!!0

Esto come a través del espacio y rompe la siguiente ficha, el numerador de nuestra fracción. Ahora vinculamos esto a una coincidencia de patrón usando <-. Nuestro patrón es

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

aagarra toda la parte de la fracción, nuestro primer token. :_desenvuelve la lista resultante de nuestro segundo lex. cagarra la segunda ficha que lexedimos, que es el numerador de la fracción. Todo lo que queda está vinculado a lo s:dque lo divide en su primer carácter, garantizado por el formato de ser un /y el resto que será el denominador.

Ahora que hemos analizado la entrada, hacemos el cálculo real:

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

¿Dónde restá la función de lectura que vinculamos anteriormente?

Es importante tener en cuenta que lexdevuelve una lista vacía si falla y no vacía si tiene éxito. Por qué esto no es un Maybeno lo sé.

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]"

Esto probablemente se puede jugar más al golf.

Cambios

• Se guardaron 16 bytes al usar una expresión regular splity 5 al usar en <>lugar de <STDIN>.
• Ahorró otros 16 bytes gracias a Dennis.

Mathematica, 51 bytes

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

Curiosamente, Mathematica admite esto con una función integrada. Si se permite emitir un número, entonces solo necesitamos 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;}

Guardado un montón de bytes gracias a FlagAsSpam.

ARBLE , 13 bytes

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

Pruébalo en línea!

05AB1E , 17 15 bytes

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

-2 bytes gracias a @MagicOctopusUrn .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Con un formato de entrada y salida flexible, tomar los enteros en el orden x,z,yy generar el nominador y el denominador en líneas separadas sería de 4 bytes (razón por la cual agregué la etiqueta de análisis al desafío ...):

*+²»

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Pruébalo en línea!

Stax , 1 byte

+

Ejecútelo y depúrelo (aunque no hay mucho que depurar)

La especificación de desafío dice "No es necesario simplificar la salida". Suponiendo que se permita simplificar, entonces hay una instrucción incorporada en stax para hacer esto. La entrada se interpreta implícitamente como un número entero y un número racional. La +instrucción se amplía a racionales, agrega y simplifica. El resultado se imprime implícitamente.

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

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

Pruébalo en línea!

(-7 bytes gracias a Dom Hastings)

$_es la entrada completa x y/z, que evalúa el valor de xen contextos numéricos (como el *aquí). $'es la cadena regex posterior al partido, que aquí contiene lo que viene después /, entonces z,. Para obtener el yvalor, usamos la -abandera que divide la entrada en espacios y los coloca en la @Fmatriz. Entonces, aquí, lo @F = ("x", "y/z")que significa $F[1]="y/z"que se evalúa en ycontextos numéricos (ya quey es la secuencia contigua inicial de dígitos con $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)

Vía Láctea 1.6.0 , 31 bytes

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

Terminé siendo mucho más largo de lo que pensé que sería.

Explicación

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

Pruébalo en línea !

Tienes que escribir la entrada entre comillas.

Probablemente no sea el mejor ...

C, 64

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

Lee la entrada de STDIN. Bastante autoexplicativo, creo.

Cheque , 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

Pruébalo en línea!

Es posible que pueda guardar algunos bytes al no intentar reutilizar el ciclo de análisis (la segunda línea). De esa forma, podría hacer que el ciclo sea más específico, evitar el gran desorden de condicionales y podría usar el registro para otras cosas.

Ruby , 23 bytes

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

Pruébalo en línea!

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

Versión completa / formateada:

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⊆⊢

Pruébalo en línea!

Gracias a ngn por el ⊃⊥1∘↓truco

PHP, 65 bytes

Pruébalo en línea

Código

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

Explicación

$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

Una lambda de Stringa String.

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

Pruébalo en línea