Numero misto a una frazione impropria

In questa sfida convertirai un numero misto in una frazione impropria.

Poiché le frazioni improprie utilizzano un numero inferiore di numeri, il codice dovrà essere il più breve possibile.

Esempi

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

specificazione

Si può presumere che il denominatore dell'input non sarà mai 0. L'input sarà sempre nel formato in x y/zcui x, y, z sono numeri interi non negativi arbitrari. Non è necessario semplificare l'output.

Questo è code-golf, quindi vince il codice più breve in byte.

Japt, 10 byte

Woohoo, attualmente sta battendo CJam!

U*W+V+'/+W

Provalo online!

Come funziona

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

CJam, 16 15 14 byte

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

o

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

Provalo qui.

Spiegazione

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'altra versione evita di usare una variabile usando un po 'più di spostamento dello stack.

Mathematica, 58 byte

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

Questo restituisce il risultato semplificato. Se l'output di un numero razionale invece di una stringa va bene, possiamo salvare 19 byte:

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

PowerShell, 47 44 42 byte

_{Cancellato 44 è ancora regolare 44; (}

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

Golfato un paio di byte utilizzando regex -split. Giocato a golf un altro paio grazie a TessellatingHeckler scambiando il regex.

Il $args-split'\D'prende il nostro argomento di input e si divide in caratteri non-cifra. Qui esegue due divisioni, una su uno spazio bianco e l'altra sul /personaggio. I risultati vengono quindi memorizzati nelle tre variabili usando un'assegnazione simultanea. Formuliamo quindi l'output della stringa come (il $lnumero di $deft per l' enominatore più l' $numeratore) eseguito come un blocco di codice, una /barra e quindi $dnuovamente l' enominatore.

Java con palo laser a dieci piedi 1,03, 79 + 25 (importazione) = 104 byte

Richiede import sj224.tflp.math.*;

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

Questo funzionerà quasi sicuramente anche con 1.04, ma finora l'ho testato solo con 1.03 perché mi è già capitato di avere un progetto Java impostato con 1.03 nel percorso di compilazione.

JavaScript (ES6), 44 41 byte

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

Salvato 3 byte grazie a @ETHproductions !

Spiegazione

Molto semplice.

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

Test

Il test è senza compiti distruttivi per funzionare nella maggior parte dei browser.

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 byte

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

Questa è una funzione anonima che accetta una stringa e restituisce un Rationaloggetto type. Per chiamarlo, dagli un nome, ad es f=s->....

Possiamo trarre vantaggio dal fatto che l'input può essere leggermente manipolato per essere un'espressione che valuta un razionale. In particolare, un numero intero più un razionale è un razionale e i razionali sono indicati con doppie barre. Quindi, se ci trasformiamo 4 1/2in 4+1//2, il risultato valutato sarà 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 caratteri

L'input corrisponde esattamente al delimitatore di array e alla rappresentazione della frazione intrinseca di Smalltalk. Se non fosse stato così prolisso, avrebbe potuto essere un serio contendente!

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

Peccato che la semplificazione non fosse un requisito, Smalltalk lo fa automaticamente!

Bash + coreutils, 28

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

$@si espande a tutti i parametri della riga di comando, quindi si ${@/\// }espande a tutti i parametri della riga di comando con /sostituito con , che viene messo nello dcstack. Il resto è semplice manipolazione dello stack e aritmetica.

Haskell , 74 67 63 byte

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

Provalo online!

Spiegazione

Come ha capito H.PWiz , possiamo usare il lexer di Haskell qui per spezzare la corda nelle sue parti. (Prima span(>'/')usavo) E Laikoni ha sottolineato che <$>funziona proprio come mapSndda Data.Tuple.

Il pattern guard suddivide il nostro codice nei tre numeri che vogliamo usare lex. lexinvoca il lexer di haskell per interrompere il primo token. Restituisce un elenco con ogni elemento che rappresenta un modo possibile per analizzare la stringa. Questi elementi sono tuple con il primo elemento come primo token e il resto della stringa come secondo elemento. Dal momento che il formato di input è molto regolare avremo sempre e solo una analisi, quindi possiamo sempre prendere il primo. La prima cosa che facciamo è invocare lexl'input

lex x

Quindi lo scartiamo dalla sua lista dandoci una 2 tupla

lex x!!0

Il primo token sarà l'intera parte della frazione mista lasciando la frazione anteposta da uno spazio per analizzare ancora. Quindi, poiché le tuple sono Functors, possiamo usare (<$>)un alias per fmapapplicare lexal secondo elemento della tupla.

lex<$>lex x!!0

Questo mangia attraverso lo spazio e interrompe il token successivo, il numeratore della nostra frazione. Ora lo associamo a una corrispondenza di pattern usando <-. Il nostro modello è

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

aprende l'intera parte della frazione, il nostro primo token. :_scartare l'elenco risultante dal nostro secondo lex. cprende il secondo token che abbiamo lasciato, cioè il numeratore della frazione. Tutto ciò che rimane è legato al s:dquale lo divide nel suo primo carattere, garantito dal formato come a /e il resto che sarà il denominatore.

Ora che abbiamo analizzato l'input, eseguiamo il calcolo effettivo:

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

Dov'è rla funzione di lettura che abbiamo associato in precedenza.

È importante notare che lexrestituisce un elenco vuoto se fallisce e non vuoto se riesce. Perché questo non è un Maybenon lo so.

Javascript ES6, 62 byte

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

Perl, 82 61 38 byte

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

Questo probabilmente può essere giocato a golf di più.

I cambiamenti

• Salvati 16 byte usando un regex in splite 5 usando <>invece di <STDIN>.
• Salvati altri 16 byte grazie a Dennis.

Mathematica, 51 byte

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

È interessante notare che Mathematica supporta questo con un built-in. Se l'output di un numero è consentito, sono necessari solo 28 byte:

Interpreter@"ComputedNumber"

Java, 159 148 142 120 110 byte

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

Ho salvato un sacco di byte grazie a FlagAsSpam.

ARBLE , 13 byte

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

Provalo online!

05AB1E , 17 15 byte

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

-2 byte grazie a @MagicOctopusUrn .

Provalo online o verifica tutti i casi di test .

Spiegazione:

#`         # 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 il formato di input e output flessibile, prendendo gli interi nell'ordine x,z,ye producendo il nominatore e il denominatore su linee separate, sarebbero 4 byte (motivo per cui ho aggiunto il tag di analisi alla sfida ..):

*+²»

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

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

Provalo online!

Stax , 1 byte

+

Esegui e esegui il debug (anche se non c'è molto da eseguire il debug)

La specifica della sfida dice "Non è necessario semplificare l'output". Supponendo che sia permesso semplificare, quindi c'è un'istruzione integrata in Stax per farlo. L'input viene interpretato implicitamente come un numero intero e un numero razionale. L' +istruzione si estende sia ai razionali, aggiunge e semplifica. Il risultato viene stampato implicitamente.

Perl 5 con -la -Mfeature = dire, 32 byte 25 byte

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

Provalo online!

(-7 byte grazie a Dom Hastings)

$_è l'intero input x y/z, che valuta il valore di xin contesti numerici (come il *qui). $'è la stringa post-partita regex, che qui contiene tutto ciò che viene dopo /, quindi z. Per ottenere il yvalore, utilizziamo il -aflag che divide l'input negli spazi e li posiziona nella @Fmatrice. Quindi, qui, @F = ("x", "y/z")che significa $F[1]="y/z"che valuta in ycontesti numerici (poiché yè la sequenza contigua iniziale di cifre con $F[1]).

Lua, 123 byte

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)

Via Lattea 1.6.0 , 31 byte

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

Finì per essere molto più lungo di quanto pensassi.

Spiegazione

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

a = input (). split ('/'); print int (a [-1]) * int (a [0] .split () [0]) + int (a [0] .split () [1 ]), '/', un [1]

Provalo online !

Devi inserire l'input tra virgolette.

Probabilmente non il migliore ...

C, 64

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

Legge l'input da STDIN. Abbastanza autoesplicativo, credo.

Controllare , 120 byte

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

Provalo online!

Potrei essere in grado di salvare alcuni byte non provando a riutilizzare il ciclo di analisi (la seconda riga). In questo modo potrei rendere il ciclo più specifico, evitare l'enorme casino di condizionali e potrei usare il registro per altre cose.

Rubino , 23 byte

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

Provalo online!

C #, 112 byte

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

Versione completa / formattata:

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

Provalo online!

Grazie a ngn per il ⊃⊥1∘↓trucco

PHP, 65 byte

Provalo online

Codice

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

Spiegazione

$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 byte

Un lambda da Stringa String.

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

Provalo online