Liczba mieszana do niewłaściwej frakcji

W tym wyzwaniu zamienisz liczbę mieszaną na niewłaściwy ułamek.

Ponieważ niepoprawne ułamki używają mniejszej liczby, kod będzie musiał być jak najkrótszy.

Przykłady

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Specyfikacja

Możesz założyć, że mianownik wejścia nigdy nie będzie wynosił 0. Dane wejściowe zawsze będą miały format, w x y/zktórym x, y, z są dowolnymi liczbami całkowitymi nieujemnymi. Nie musisz upraszczać danych wyjściowych.

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach.

Japt, 10 bajtów

Woohoo, obecnie bije CJam!

U*W+V+'/+W

Wypróbuj online!

Jak to działa

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

CJam, 16 15 14 bajtów

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

lub

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

Sprawdź to tutaj.

Wyjaśnienie

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.

Druga wersja unika używania zmiennej poprzez nieco większe przesunięcie stosu.

Mathematica, 58 bajtów

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

Zwraca uproszczony wynik. Jeśli wyprowadzenie liczby wymiernej zamiast łańcucha jest w porządku, możemy zapisać 19 bajtów:

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

PowerShell, 47 44 42 bajtów

_{Przekreślone 44 jest nadal regularne 44; (}

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

Grał w golfa kilka bajtów za pomocą wyrażenia regularnego -split. Grał jeszcze w golfa dzięki TessellatingHeckler , zmieniając wyrażenie regularne.

$args-split'\D'Trwa nasz argumentu wejściowego i dzieli się na znaki nie-cyfrowych. Tutaj wykonuje dwa podziały, jeden na białych /znakach , a drugi na postaci. Wyniki są następnie zapisywane w trzech zmiennych przy jednoczesnym przypisaniu. Następnie formułujemy dane wyjściowe ciągu jako ( $lliczbę eft pomnożącą enominator $dplus $numerator) wykonaną jako blok kodu, /ukośnik, a następnie $dponownie enominator.

Java z dziesięciostopowym biegunem lasera 1,03, 79 + 25 (import) = 104 bajty

Wymaga import sj224.tflp.math.*;

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

To prawie na pewno zadziała również z wersją 1.04, ale do tej pory przetestowałem ją tylko z wersją 1.03, ponieważ miałem już skonfigurowany projekt Java z wersją 1.03 na ścieżce kompilacji.

JavaScript (ES6), 44 41 bajtów

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

Zaoszczędź 3 bajty dzięki @ETHproductions !

Wyjaśnienie

Bardzo prosty.

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

Test

Test nie ma przypisania destrukcyjnego do działania w większości przeglądarek.

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 bajtów

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

Jest to anonimowa funkcja, która przyjmuje ciąg znaków i zwraca Rationalobiekt typu. Aby to nazwać, nadaj mu nazwę, np f=s->....

Możemy skorzystać z faktu, że dane wejściowe można nieznacznie manipulować, aby były wyrażeniem, które można uznać za racjonalne. W szczególności liczba całkowita plus wartość wymierna jest wartością wymierną, a racjonalne są oznaczone podwójnymi ukośnikami. Więc jeśli się odwrócimy4 1/2 się 4+1//2, oceniana będzie wynik 9//2.

Nie golfowany:

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 znaków

Dane wejściowe dokładnie pasują do ogranicznika tablicy i nieodłącznej reprezentacji ułamkowej Smalltalk. Gdyby po prostu nie był tak gadatliwy, mógłby być poważnym przeciwnikiem!

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

Szkoda, że ​​uproszczenie nie było wymogiem, Smalltalk robi to automatycznie!

Bash + coreutils, 28

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

$@rozwija się do wszystkich parametrów wiersza poleceń, więc ${@/\// }rozwija się do wszystkich parametrów wiersza poleceń z /zastąpionymi przez , które są umieszczane na dcstosie. Reszta to prosta manipulacja stosami i arytmetyka.

Haskell , 74 67 63 bajtów

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

Wypróbuj online!

Wyjaśnienie

Jak się zorientował H.PWiz , możemy tutaj użyć leksyk Haskella, aby rozbić sznurek na części. (Wcześniej korzystałem span(>'/')) I Laikoni wskazał, że <$>działa tak samomapSnd od Data.Tuple.

Strażnik wzorów dzieli nasz kod na trzy liczby, których chcemy użyć lex. lexprzywołuje leksykon haskell, aby zerwać pierwszy token. Zwraca listę z każdym elementem reprezentującym możliwy sposób parsowania łańcucha. Te elementy są krotkami, przy czym pierwszy element jest pierwszym tokenem, a reszta ciągu jest drugim elementem. Ponieważ format wejściowy jest bardzo regularny, zawsze będziemy mieli tylko jedną analizę, więc zawsze możemy wziąć pierwszą. Pierwszą rzeczą, którą robimy, jest wywołanie lexna wejściu

lex x

Następnie odwijamy go z listy, dając nam 2-krotkę

lex x!!0

Pierwszy token będzie całą częścią mieszanej frakcji, pozostawiając frakcję poprzedzoną spacją, aby nadal analizować. Ponieważ krotki są Functors, możemy użyć (<$>)aliasu, fmapaby zastosować lexdo drugiego elementu krotki.

lex<$>lex x!!0

To zjada przestrzeń i odrywa następny token, licznik naszej frakcji. Teraz łączymy to z dopasowaniem wzorca za pomocą <-. Nasz wzór to

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

achwyta całą część frakcji, naszego pierwszego tokena. :_rozpakowuje listę wynikającą z naszego drugiego lex. cchwyta drugi żeton, który sprawdziliśmy, czyli licznik ułamka. Wszystko, co pozostaje, jest z tym związanes:d co dzieli go na pierwszy znak, co gwarantuje format to/ a reszta, która będzie mianownikiem.

Po przeanalizowaniu danych wejściowych wykonujemy obliczenia:

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

Gdzie r jest funkcja odczytu, którą związaliśmy wcześniej.

Należy zauważyć, że lexzwraca listę pustą, jeśli się nie powiedzie, i niepustą, jeśli się powiedzie. Dlaczego to nie jest Maybenie wiem.

JavaScript ES6, 62 bajty

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

Perl, 82 61 38 bajtów

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

To może być bardziej golfa.

Zmiany

• Zapisano 16 bajtów za pomocą wyrażenia regularnego spliti 5 za pomocą <>zamiast <STDIN>.
• Zaoszczędził kolejne 16 bajtów dzięki Dennisowi.

Mathematica, 51 bajtów

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

Co ciekawe, Mathematica obsługuje to za pomocą wbudowanego. Jeśli wypisywanie liczby jest dozwolone, potrzebujemy tylko 28 bajtów:

Interpreter@"ComputedNumber"

Java, 159 148 142 120 110 bajtów

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

Zaoszczędziłem sporo bajtów dzięki FlagAsSpam.

ARBLE , 13 bajtów

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

Wypróbuj online!

05AB1E , 17 15 bajtów

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

-2 bajty dzięki @MagicOctopusUrn .

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Przy elastycznym formacie wejściowym i wyjściowym, przyjmując liczby całkowite w kolejności x,z,yi wysyłając nominator i mianownik w oddzielnych liniach, byłoby to 4 bajty (dlatego dodałem tag parsowania do wyzwania ..):

*+²»

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

*        # 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 bajtów

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

Wypróbuj online!

Stax , 1 bajt

+

Uruchom i debuguj (chociaż nie ma wiele do debugowania)

Specyfikacja wyzwania mówi: „Nie musisz upraszczać wyników”. Zakładając, że można to uprościć, istnieje wbudowana instrukcja stax, aby to zrobić. Dane wejściowe są domyślnie interpretowane jako liczba całkowita i liczba wymierna. +Instrukcja poszerza zarówno wymiernych, dodaje i upraszcza. Wynik zostanie domyślnie wydrukowany.

Perl 5 z -la -Mfeature = powiedzmy 32 bajty 25 bajtów

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

Wypróbuj online!

(-7 bajtów dzięki Dom Hastings)

$_to całe wejście x y/z, które ocenia wartość xw kontekstach numerycznych (jak *tutaj). $'jest regex Pomeczowe ciąg, który zawiera co przychodzi tu po /- tak z. Aby uzyskać ywartość, używamy -aflagi, która dzieli dane wejściowe na spacje i umieszcza je w @Ftablicy. A więc tutaj, @F = ("x", "y/z")co oznacza, że $F[1]="y/z"wartość jest obliczana w ykontekście numerycznym (ponieważ yjest to początkowa ciągła sekwencja cyfr $F[1]).

Lua, 123 bajtów

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)

Droga Mleczna 1.6.0 , 31 bajtów

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

Skończyło się to znacznie dłużej, niż się spodziewałem.

Wyjaśnienie

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

Stosowanie

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

Wypróbuj online!

Musisz wpisać dane w cudzysłowie.

Prawdopodobnie nie najlepszy ...

C, 64

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

Odczytuje dane wejściowe ze STDIN. Myślę, że dość oczywiste.

Sprawdź , 120 bajtów

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

Wypróbuj online!

Być może uda mi się zapisać niektóre bajty, nie próbując ponownie użyć pętli analizowania (druga linia). W ten sposób mogłem sprecyzować pętlę, uniknąć ogromnego bałaganu warunkowego i mogłem wykorzystać rejestr do innych celów.

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