Nombre mixte à une fraction impropre

Dans ce défi, vous allez convertir un nombre mixte en une fraction incorrecte.

Parce que les fractions impropres utilisent moins de nombres, votre code devra être aussi court que possible.

Exemples

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

spécification

Vous pouvez supposer que le dénominateur de l'entrée ne sera jamais 0. L'entrée sera toujours au format x y/zoù x, y, z sont des entiers non négatifs arbitraires. Vous n'avez pas besoin de simplifier la sortie.

C'est le code-golf donc le code le plus court en octets gagne.

Japt, 10 octets

Woohoo, bat actuellement CJam!

U*W+V+'/+W

Essayez-le en ligne!

Comment ça fonctionne

       // 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 primitives LabVIEW

CJam, 16 15 14 octets

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

ou

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

Testez-le ici.

Explication

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.

L'autre version évite d'utiliser une variable en utilisant un peu plus de décalage de pile.

Mathematica, 58 octets

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

Cela renvoie le résultat simplifié. Si la sortie d'un nombre rationnel au lieu d'une chaîne est correcte, nous pouvons économiser 19 octets:

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

PowerShell, 47 44 42 octets

_{Biffé 44 est toujours régulier 44; (}

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

Golfé quelques octets en utilisant l'expression régulière -split. Golfé un couple de plus grâce à TessellatingHeckler en échangeant le regex.

Le $args-split'\D'prend notre argument d'entrée et se divise en caractères non numériques. Ici, il effectue deux divisions, l'une sur les espaces blancs, l'autre sur le /personnage. Les résultats sont ensuite stockés dans les trois variables à l'aide d'une affectation simultanée. Nous formulons ensuite la sortie de chaîne sous la forme (le $lnombre eft multiplié par l' $dénominateur plus l' $numérateur) exécutée sous forme de bloc de code, de /barre oblique, puis de $dnouveau l' énominateur.

Java avec Ten Foot Laser Pole 1.03, 79 + 25 (importation) = 104 octets

A besoin import sj224.tflp.math.*;

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

Cela fonctionnera presque certainement aussi avec 1.04, mais jusqu'à présent, je ne l'ai testé qu'avec 1.03 parce que j'avais déjà un projet java configuré avec 1.03 dans le chemin de construction.

JavaScript (ES6), 44 41 octets

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

Enregistré 3 octets grâce à @ETHproductions !

Explication

Très simple.

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

Tester

Le test est sans déstructuration assigné pour fonctionner dans la plupart des navigateurs.

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 octets

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

Il s'agit d'une fonction anonyme qui accepte une chaîne et renvoie un Rationalobjet type. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

Nous pouvons profiter du fait que l'entrée peut être légèrement manipulée pour être une expression qui s'évalue à un rationnel. En particulier, un entier plus un rationnel est un rationnel, et les rationnels sont indiqués par des doubles barres obliques. Donc , si nous nous tournons 4 1/2dans 4+1//2le résultat de cette évaluation sera 9//2.

Non 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 caractères

L'entrée correspond exactement au délimiteur de tableau et à la représentation de fraction inhérente de Smalltalk. Si ce n'était pas si verbeux, cela aurait pu être un concurrent sérieux!

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

C'est dommage que la simplification n'était pas une exigence, Smalltalk le fait automatiquement!

Bash + coreutils, 28

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

$@se développe à tous les paramètres de ligne de commande, se ${@/\// }développe donc à tous les paramètres de ligne de commande avec /remplacé par , qui est placé sur dcla pile de. Le reste est une simple manipulation de pile et arithmétique.

Haskell , 74 67 63 octets

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

Essayez-le en ligne!

Explication

Comme H.PWiz l'a compris, nous pouvons utiliser le lexer de Haskell ici pour diviser la chaîne en ses parties. ( Un peu plus tôt , j'utilisais span(>'/')) Et Laikoni fait remarquer que <$>fonctionne comme mapSndde Data.Tuple.

Le modèle de garde décompose notre code en trois chiffres que nous voulons utiliser lex. lexinvoque le lexer de haskell pour rompre le premier jeton. Il renvoie une liste avec chaque élément représentant une manière possible d'analyser la chaîne. Ces éléments sont des tuples, le premier élément étant le premier jeton et le reste de la chaîne étant le deuxième élément. Maintenant, comme le format d'entrée est très régulier, nous n'aurons jamais qu'une seule analyse, nous pouvons donc toujours prendre la première. La première chose que nous faisons est d'invoquer lexl'entrée

lex x

Ensuite, nous le déballons de sa liste en nous donnant un tuple 2

lex x!!0

Le premier jeton sera la partie entière de la fraction mixte, laissant la fraction ajoutée par un espace à analyser. Puis, puisque les tuples sont, Functorsnous pouvons utiliser (<$>)un alias pour fmapappliquer lexau deuxième élément du tuple.

lex<$>lex x!!0

Cela dévore l'espace et rompt le jeton suivant, le numérateur de notre fraction. Maintenant, nous lions ceci à une correspondance de modèle en utilisant <-. Notre modèle est

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

asaisit toute la partie de la fraction, notre premier jeton. :_déballe la liste issue de notre deuxième lex. csaisit le deuxième jeton que nous avons lexé, à savoir le numérateur de la fraction. Tout ce qui reste est lié à s:dce qui le divise en son premier caractère, garanti par le format comme un /et le reste qui sera le dénominateur.

Maintenant que nous avons analysé l'entrée, nous effectuons le calcul réel:

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

Où rest la fonction de lecture que nous avons liée plus tôt.

Il est important de noter que lexretourne une liste vide si elle échoue et non vide si elle réussit. Pourquoi ce n'est pas un Maybeje ne sais pas.

Javascript ES6, 62 octets

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

Perl, 82 61 38 octets

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

Cela peut probablement être joué plus.

Changements

• 16 octets enregistrés en utilisant une expression régulière dans split, et 5 en utilisant <>au lieu de <STDIN>.
• Sauvegardé encore 16 octets grâce à Dennis.

Mathematica, 51 octets

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

Fait intéressant, Mathematica prend en charge cela avec un intégré. Si la sortie d'un nombre est autorisée, nous n'avons besoin que de 28 octets:

Interpreter@"ComputedNumber"

Java, 159 148 142 120 110 110 octets

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

Enregistré un tas d'octets grâce à FlagAsSpam.

ARBLE , 13 octets

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

Essayez-le en ligne!

05AB1E , 17 15 octets

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

-2 octets grâce à @MagicOctopusUrn .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Avec un format d'entrée et de sortie flexible, en prenant les entiers dans l'ordre x,z,yet en sortant le nominateur et le dénominateur sur des lignes séparées, ce serait 4 octets (c'est pourquoi j'ai ajouté le -tag d' analyse au défi ..):

*+²»

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

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

Essayez-le en ligne!

Stax , 1 octet

+

Exécutez-le et déboguez-le (bien qu'il n'y ait pas grand-chose à déboguer)

La spécification de défi indique "Vous n'avez pas besoin de simplifier la sortie." En supposant qu'il soit autorisé de simplifier, il existe une instruction intégrée dans stax pour ce faire. L'entrée est interprétée implicitement comme un nombre entier et un nombre rationnel. L' +instruction s'élargit à la fois aux rationnels, ajoute et simplifie. Le résultat est implicitement imprimé.

Perl 5 avec -la -Mfeature = disons, 32 octets 25 octets

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

Essayez-le en ligne!

(-7 octets grâce à Dom Hastings)

$_est l'entrée entière x y/z, qui évalue la valeur de xdans des contextes numériques (comme *ici). $'est la chaîne post-correspondance regex, qui contient ici tout ce qui vient après /- donc z,. Pour obtenir la yvaleur, nous utilisons l' -aindicateur qui sépare l'entrée sur les espaces et les place dans le @Ftableau. Donc ici, @F = ("x", "y/z")ce qui signifie $F[1]="y/z"qui évalue dans ydes contextes numériques (puisque yc'est la séquence contiguë initiale de chiffres avec $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)

Milky Way 1.6.0, 31 bytes

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

Ended up being much longer than I thought it would be.

Explanation

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

Usage

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

Try it online!

You have to type the input in quotes.

Probably not the best ...

C, 64

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

Reads input from STDIN. Fairly self-explanatory, I think.

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

Try it online!

I might be able to save some bytes by not trying to reuse the parsing loop (the second line). That way I could make the loop more specific, avoid the huge mess of conditionals, and I could use the register for other things.

Ruby, 23 bytes

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

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

Full/Formatted Version:

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

Try it online!

Thanks to ngn for the ⊃⊥1∘↓ trick

PHP, 65 Bytes

Try it online

Code

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

Explanation

$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

A lambda from String to String.

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

Try It Online