Gemischte Zahl zu einem falschen Bruch

In dieser Herausforderung wandeln Sie eine gemischte Zahl in einen falschen Bruch um.

Da unzulässige Brüche weniger Zahlen verwenden, muss Ihr Code so kurz wie möglich sein.

Beispiele

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Spezifikation

Sie können davon ausgehen, dass der Nenner der Eingabe niemals 0 ist. Die Eingabe hat immer das Format, x y/zin dem x, y, z beliebige nichtnegative Ganzzahlen sind. Sie müssen die Ausgabe nicht vereinfachen.

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes.

Japt, 10 Bytes

Woohoo, derzeit gegen CJam!

U*W+V+'/+W

Probieren Sie es online!

Wie es funktioniert

       // 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-Grundelemente

CJam, 16 15 14 Bytes

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

oder

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

Teste es hier.

Erläuterung

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.

Die andere Version vermeidet die Verwendung einer Variablen durch etwas mehr Stack-Shifting.

Mathematica, 58 Bytes

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

Dies gibt das vereinfachte Ergebnis zurück. Wenn die Ausgabe einer rationalen Zahl anstelle einer Zeichenfolge in Ordnung ist, können 19 Bytes eingespart werden:

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

PowerShell, 47 44 42 Bytes

_{Durchgestrichen 44 ist immer noch regulär 44; (}

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

Golf ein paar Bytes mit Regex -split. Ich habe dank TessellatingHeckler ein paar mehr Golf gespielt, indem ich den Regex getauscht habe.

Das $args-split'\D'nimmt unser Eingabeargument und teilt auf nicht-stellige Zeichen auf. Hier werden zwei Teilungen ausgeführt, eine im Leerzeichen und die andere im /Zeichen. Die Ergebnisse werden dann unter Verwendung einer gleichzeitigen Zuordnung in den drei Variablen gespeichert. Wir formulieren dann die String-Ausgabe als (die $lEFT-Zahl $dmultipliziert mit dem Enominator plus dem $nUmerator), die als Codeblock, /Schrägstrich und dann erneut als $dEnominator ausgeführt wird.

Java mit zehn Fuß Laser Pole 1.03, 79 + 25 (Import) = 104 Bytes

Benötigt import sj224.tflp.math.*;

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

Dies wird mit ziemlicher Sicherheit auch mit 1.04 funktionieren, aber bisher habe ich es nur mit 1.03 getestet, da ich zufällig bereits ein Java-Projekt mit 1.03 im Build-Pfad eingerichtet habe.

JavaScript (ES6), 44 41 Byte

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

3 Bytes gespart dank @ETHproductions !

Erläuterung

Sehr einfach.

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

Prüfung

Test ist ohne destrukturierende Zuordnung in den meisten Browsern zu arbeiten.

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," ","+"),"/","//")))

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und ein Typobjekt zurückgibt Rational. Um es zu nennen, geben Sie ihm einen Namen, z f=s->....

Wir können die Tatsache ausnutzen, dass die Eingabe leicht manipuliert werden kann, um einen Ausdruck zu erhalten, der als rational bewertet wird. Insbesondere ist eine Ganzzahl plus ein Rational ein Rational, und Rationalen werden mit doppelten Schrägstrichen bezeichnet. Also , wenn wir drehen 4 1/2in 4+1//2, wird das ausgewertete Ergebnis 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 Zeichen

Die Eingabe stimmt genau mit dem Array-Begrenzer und der inhärenten Bruchdarstellung von Smalltalk überein. Wenn es nur nicht so ausführlich wäre, könnte es ein ernsthafter Anwärter sein!

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

Es ist schade, dass Vereinfachung keine Voraussetzung war, Smalltalk macht es automatisch!

Bash + Coreutils, 28

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

$@Erweitert auf alle Befehlszeilenparameter, also ${@/\// }auf alle Befehlszeilenparameter mit /Ersetzt durch , die auf dcden Stapel gelegt werden. Der Rest ist einfache Stapelmanipulation und Arithmetik.

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

Probieren Sie es online!

Erläuterung

Wie H.PWiz herausgefunden hat, können wir hier Haskells Lexer verwenden, um die Saite in ihre Teile zu zerlegen . (Früher habe ich verwendet span(>'/')) Und Laikoni wies darauf hin, dass es <$>genauso funktioniert wie mapSndvon Data.Tuple.

Der Pattern Guard teilt unseren Code in die drei Zahlen auf, die wir verwenden möchten lex. lexruft haskells lexer auf, um das erste token abzubrechen. Es wird eine Liste zurückgegeben, wobei jedes Element eine mögliche Methode zum Parsen der Zeichenfolge darstellt. Diese Elemente sind Tupel, wobei das erste Element das erste Token und der Rest der Zeichenfolge das zweite Element ist. Da das Eingabeformat sehr regelmäßig ist, wird immer nur genau eine Analyse durchgeführt, sodass immer die erste durchgeführt werden kann. Als erstes rufen wir lexdie Eingabe auf

lex x

Dann packen wir es aus der Liste und erhalten ein 2-Tupel

lex x!!0

Der erste Token ist der gesamte Teil der gemischten Fraktion, wobei der Fraktion ein Leerzeichen vorangestellt bleibt, um das Parsen fortzusetzen. Dann , da Tupel Functorskönnen wir verwenden (<$>)einen Alias für fmapanwenden , lexum das zweite Element des Tupels.

lex<$>lex x!!0

Dies frisst sich durch den Raum und bricht das nächste Zeichen ab, den Zähler unseres Bruchs. Nun binden wir dies mit einem Pattern Match <-. Unser Muster ist

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

aschnappt den ganzen Teil der Fraktion, unser erstes Zeichen. :_packt die Liste aus, die sich aus unserer zweiten ergibt lex. cschnappt uns den zweiten Token, den wir geschrieben haben, das ist der Zähler des Bruchs. Alles, was übrig bleibt, ist gebunden, um s:des in sein erstes Zeichen aufzuteilen, was durch das Format a /und den Rest, der der Nenner sein wird , garantiert wird.

Nachdem wir die Eingabe analysiert haben, führen wir die eigentliche Berechnung durch:

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

Wo rist die Lesefunktion, die wir früher gebunden haben?

Es ist wichtig zu beachten, dass lexeine Liste leer zurückgegeben wird, wenn sie fehlschlägt, und nicht leer, wenn sie erfolgreich ist. Warum das Maybekein ist, weiß ich nicht.

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

Damit kann wohl mehr golfen werden.

Änderungen

• 16 Bytes durch Verwendung eines regulären Ausdrucks in splitund 5 durch Verwendung von <>anstelle von gespeichert <STDIN>.
• Dank Dennis wurden weitere 16 Bytes gespeichert.

Mathematica, 51 Bytes

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

Interessanterweise unterstützt Mathematica dies mit einem eingebauten. Wenn die Ausgabe einer Zahl erlaubt ist, benötigen wir nur 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;}

Dank FlagAsSpam wurden viele Bytes gespeichert.

ARBLE , 13 Bytes

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

Probieren Sie es online!

05AB1E , 17 15 Bytes

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

-2 Bytes dank @MagicOctopusUrn .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Mit dem flexiblen Eingabe- und Ausgabeformat, bei dem die ganzen Zahlen in der Reihenfolge genommen x,z,yund der Nominator und der Nenner in getrennten Zeilen ausgegeben werden, wären es 4 Bytes (weshalb ich der Herausforderung das Parsing- Tag hinzugefügt habe ):

*+²»

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Probieren Sie es online!

Stax , 1 Byte

+

Führen Sie es aus und debuggen Sie es (obwohl es nicht viel zu debuggen gibt)

Die Herausforderungsspezifikation besagt: "Sie müssen die Ausgabe nicht vereinfachen." Angenommen, es ist erlaubt zu vereinfachen, dann gibt es eine eingebaute Anweisung in stax, um dies zu tun. Die Eingabe wird implizit als Ganzzahl und als rationale Zahl interpretiert. Der +Befehl erweitert sich sowohl zu rationalen als auch zu addierenden und vereinfachten Befehlen. Das Ergebnis wird implizit gedruckt.

Perl 5 mit -la -Mfeature = 32 Bytes 25 Bytes

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

Probieren Sie es online!

(-7 Bytes dank Dom Hastings)

$_ist die gesamte Eingabe x y/z, die den Wert von xin numerischen Kontexten (wie *hier) auswertet . $'ist der regex post-match - String, der hier enthält alles , was danach kommt /- so, z. Um den yWert zu erhalten, verwenden wir das -aFlag, das die Eingabe auf Leerzeichen aufteilt und sie im @FArray platziert. Also hier, @F = ("x", "y/z")was bedeutet, $F[1]="y/z"dass yin numerischen Kontexten ausgewertet wird (da yist die anfängliche zusammenhängende Folge von Ziffern mit $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)

Milchstraße 1.6.0 , 31 Bytes

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

Es dauerte viel länger, als ich erwartet hatte.

Erläuterung

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

Verwendung

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

Probieren Sie es online !

Sie müssen die Eingabe in Anführungszeichen eingeben.

Wahrscheinlich nicht die beste ...

C 64

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

Liest die Eingabe von STDIN. Ziemlich selbsterklärend, denke ich.

Überprüfen Sie , 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

Probieren Sie es online!

Ich könnte in der Lage sein, einige Bytes zu sparen, indem ich nicht versuche, die Parsing-Schleife (die zweite Zeile) wiederzuverwenden. Auf diese Weise könnte ich die Schleife präzisieren, das große Durcheinander von Bedingungen vermeiden und das Register für andere Dinge verwenden.

Ruby , 23 Bytes

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

Probieren Sie es 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;}

Voll / Formatierte 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 Byte

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

Probieren Sie es online!

Danke an ngn für den ⊃⊥1∘↓Trick

PHP, 65 Bytes

Probieren Sie es online aus

Code

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

Erläuterung

$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

Ein Lambda von Stringbis String.

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

Probieren Sie es online