Número mixto a una fracción impropia

19

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 por lo que el código más corto en bytes gana.

Downgoat
fuente
55
Debe agregar la etiqueta "análisis". Estoy seguro de que la mayoría de las respuestas gastarán más bytes en analizar la entrada y formatear la salida que en hacer los cálculos.
nimi
3
¿Puede la salida ser un tipo de número racional o tiene que ser una cadena?
Martin Ender
2
@AlexA .: ... pero una gran parte del desafío. Según su descripción, la etiqueta debe usarse en tales casos.
nimi
77
Puede x, yy zser negativo?
Dennis
2
Basado en el desafío que supongo que es, pero ¿es obligatorio el formato de entrada "xy / z", o puede ser el espacio una nueva línea y / o las x,y,zentradas separadas? La mayoría de las respuestas asumen que el formato de entrada es obligatorio x y/z, pero algunas no lo son, de ahí que esta pregunta tenga una respuesta definitiva.
Kevin Cruijssen

Respuestas:

1

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
ETHproducciones
fuente
Ayer pasé bastante tiempo tratando de descubrir cómo había obtenido 15 repeticiones de una respuesta, hasta que me di cuenta: ¡mi primera marca de verificación verde! \ o /
ETHproductions
7

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.

Martin Ender
fuente
Realmente necesito comenzar a usar la conversión base en CJam más.
Esolanging Fruit
Una versión alternativa: '//~\S/1$b'/@esto es 13 bytes. Editar : oh, olvidé la entrada l.
Cromo
4

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[#," "->"+"]&
Martin Ender
fuente
4

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.

AdmBorkBork
fuente
Hola, creo que puedes hacer -split ' |/'para guardar un personaje con una expresión regular "emparejar esto o aquello", o usar -split '\D'para dividir cualquier cosa que no sea un dígito y s (h) tenga dos caracteres. Si @Downgoat está dispuesto a ser ligeramente flexible en el formato de salida, '{0}*{2}+{1};{2}'-f($args-split'\D')|iexes de 40 bytes y tiene una salida mucho más fría porque ¡los números están incluso uno encima del otro!
TessellatingHeckler
1
@TessellatingHeckler Gracias por la ayuda de expresiones regulares. Le he pedido a Downgoat que me dé su opinión. Pero $l,$n,$d=$args-split'\D';+$l*$d+$n;$des más corto aún en 37, y lógicamente sigue el mismo patrón que aquí.
AdmBorkBork
Oh si, solo matemáticas! (Eso sería suficiente para superar una respuesta de Perl, también)
TessellatingHeckler
3

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.

SuperJedi224
fuente
3

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.

usuario81655
fuente
¡Agradable! Se puede utilizar [p,q,r]=en lugar de p=, a continuación, reemplace p[0], p[1]y p[2]con p, qy r, respectivamente. Después de este cambio, obtengo 41:m=>([p,q,r]=m.match(/\d+/g),+q+p*r+"/"+r)
ETHproductions
@ETHproductions ¡Gracias por la sugerencia! De hecho, consideré usar una tarea de desestructuración, pero no funcionan en Chrome y no tenía Firefox a mano para probarlo. : P
user81655
Mi primer tachado 44! : D
user81655
En su m.split(/\W/g)lugar, puede usar para guardar un byte
Kritixi Lithos
2

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
Alex A.
fuente
2

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.


fuente
2

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.

Trauma digital
fuente
2

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é.

Asistente de trigo
fuente
1
67 bytes
H.PWiz
@ H.PWiz Ese es un gran uso de Lex.
Wheat Wizard
2
65 bytes: ¡ Pruébelo en línea!
Laikoni
2
Debería poder guardar otros 2 haciendo coincidir en el/
H.PWiz
1
59 bytes
H.PWiz
1

Javascript ES6, 62 bytes

p=prompt;b=p(a=+p()).split`/`;alert((+b[1]*a+ +b[0])+"/"+b[1])
SuperJedi224
fuente
1
¡Bastante agradable! Algunos consejos: puede usar [b,c]=en lugar de b=, luego usar ben lugar de b[0]y cen lugar de b[1]. Además, puede reorganizar la ecuación para que no necesite paréntesis: p=prompt;[b,c]=p(a=+p()).split/;alert(+b+c*a+"/"+c)
ETHproductions
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.
ASCIIThenANSI
fuente
Con shebang #!perl -paF/\D/(9 bytes), puede usar $_=$F[0]*$F[2]+$F[1]."/$F[2]".
Dennis
@ Dennis He añadido eso. ¡Gracias!
ASCIIThenANSI
La #!perlparte del shebang y el salto de línea no cuentan. Esto es solo 38 bytes.
Dennis
@ Dennis Oh, está bien. Lo corregiré ahora. (En el lado positivo, creo que esta es la segunda respuesta no esotérica más corta)
ASCIIThenANSI
1

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"
LegionMammal978
fuente
1

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.

SuperJedi224
fuente
@FlagAsSpam Hecho.
SuperJedi224
@FlagAsSpam ¡Pero entonces las variables quedarán sin declarar!
SuperJedi224
No tenga en cuenta la totalidad de lo que acabo de decir - un corto camino haciendo lo que estás haciendo esLong b=new Long(a[0]),c=new Long((a=a[1].split("/"))[0]),d=new Long(a[1]);
Addison Crump
1

ARBLE , 13 bytes

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

Pruébalo en línea!

Un taco
fuente
Estoy bastante seguro de que el formato de entrada "x y/z"es obligatorio para este desafío en particular, pero en caso de que le haya pedido a OP que lo verifique.
Kevin Cruijssen
1

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 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
Kevin Cruijssen
fuente
@MagicOctopusUrn Gracias, pero el formato de entrada es diferente al de la descripción del desafío. Aparentemente, el formato (como una sola cadena) 4 1/2es obligatorio para este desafío en particular. De lo contrario, habría usado mi versión de 4 bytes (o si la salida fuera obligatoria, pero de entrada flexible, usaría este 6 bytes *+'/²J)
Kevin Cruijssen
1
15 bytes
Urna de pulpo mágico
@MagicOctopusUrn Oh, ni siquiera sabía sobre " Empujar todos los elementos aen la pila " ... o.Ô ¡Exactamente lo que necesitaba para este desafío! E inteligente con la combinación de "/". ¡Gracias! :)
Kevin Cruijssen
Odio usar el comando "Insertar todos los elementos de un en la pila" porque es "` "y no puede ser domesticado por etiquetas de código en línea.
Urna mágica del pulpo
@MagicOctopusUrn sí, también es un poco molesto en los comentarios (es por eso que cité " Empujar todos los elementos aen la pila " en lugar de usar '`'..
Kevin Cruijssen
1

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!

xbarbie
fuente
return'%s/'%(int(a)*int(c)+int(b))+ces 2 bytes más corto
ovs
1

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.

recursivo
fuente
1

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]).

sundar - Restablece a Monica
fuente
No tiene que contar la -pbandera en su cuenta de bytes; en su lugar, cuenta el idioma como Perl 5 with -p flag, 32 bytes. Vea esta meta publicación para el consenso actual.
Giuseppe
Buen enfoque! Acabo de intentarlo y logré hacer una versión de 25 bytes: ¡ Pruébelo en línea! . ¡Usar $'fue la única diferencia real allí realmente!
Dom Hastings
La combinación del uso de expresiones regulares $'y -a- $F[n]para obtener partes de la cadena es una muy buena idea, ¡tengo que recordar eso! Gracias, actualicé la publicación.
Sundar - Restablecer Mónica
0

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)
Nikolai97
fuente
0

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>
Puertas de Zach
fuente
0

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 ...

Alex
fuente
76 bytes
Koishore Roy
0

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.

Trauma digital
fuente
0

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.

Fruta Esolanging
fuente
0

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();
        }
    }
}
TheLethalCoder
fuente
0

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
Francisco Hahn
fuente
0

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

Jakob
fuente