Número misto para uma fração imprópria

19

Número misto para uma fração imprópria

Neste desafio, você converterá um número misto em uma fração imprópria.

Como frações impróprias usam menos números, seu código precisará ser o mais curto possível.


Exemplos

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Especificação

Você pode assumir que o denominador da entrada nunca será 0. A entrada sempre estará no formato em x y/zque x, y, z são números inteiros não negativos arbitrários. Você não precisa simplificar a saída.


Este é o pelo que o código mais curto em bytes vence.

Downgoat
fonte
5
Você deve adicionar a tag "parsing". Tenho certeza que a maioria das respostas gastará mais bytes na análise da entrada e na formatação da saída do que na matemática.
nimi
3
A saída pode ser um tipo de número racional ou precisa ser uma string?
Martin Ender
2
@AlexA .: ... mas uma grande parte do desafio. De acordo com a descrição, a tag deve ser usada nesses casos.
nimi
7
Pode x, ye zser negativo?
Dennis
2
Com base no desafio, presumo que seja, mas o formato de entrada "xy / z" é obrigatório ou o espaço pode ser uma nova linha e / ou x,y,zentradas separadas? A maioria das respostas pressupõe que o formato de entrada seja realmente obrigatório x y/z, mas algumas não são, portanto, essa pergunta tem uma resposta definitiva.
Kevin Cruijssen

Respostas:

1

Japonês, 10 bytes

Woohoo, atualmente batendo CJam!

U*W+V+'/+W

Experimente online!

Como 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
ETHproductions
fonte
Ontem, passei um bom tempo tentando descobrir como obtive 15 representantes de uma resposta, até que percebi: minha primeira marca de seleção verde! \ o /
ETHproductions
7

CJam, 16 15 14 bytes

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

ou

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

Teste aqui.

Explicação

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.

A outra versão evita o uso de uma variável usando um deslocamento de pilha um pouco mais.

Martin Ender
fonte
Eu realmente preciso começar a usar a conversão básica no CJam mais.
Esolanging Fruit
Uma versão alternativa:, '//~\S/1$b'/@isso é 13 bytes. Edit : oh eu esqueci a entrada l.
Cromo
4

Mathematica, 58 bytes

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

Isso retorna o resultado simplificado. Se a saída de um número racional em vez de uma string estiver correta, podemos salvar 19 bytes:

ToExpression@StringReplace[#," "->"+"]&
Martin Ender
fonte
4

PowerShell, 47 44 42 bytes

O riscado 44 ainda é regular 44;

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

Golfou alguns bytes usando regex -split. Golf mais um par de graças ao TessellatingHeckler trocando o regex.

Ele $args-split'\D'pega nosso argumento de entrada e divide em caracteres que não são dígitos. Aqui, ele executa duas divisões, uma em espaço em branco e a outra no /personagem. Os resultados são armazenados nas três variáveis ​​usando uma atribuição simultânea. Em seguida, formulamos a saída da string como (o $lnúmero eft vezes o $denominator mais o $numerator) executado como um bloco de código, uma /barra e, em seguida, o $denominator novamente.

AdmBorkBork
fonte
Olá, acho que você pode fazer -split ' |/'para salvar um caractere com uma regex "corresponder isso | ou aquele" ou usar -split '\D'para dividir em qualquer coisa que não seja um dígito e (h) tenha dois caracteres. Se o @Downgoat quiser ser um pouco flexível no formato de saída, '{0}*{2}+{1};{2}'-f($args-split'\D')|iextem 40 bytes e tem uma saída muito mais fria, porque os números são iguais um acima do outro!
TessellatingHeckler
11
@TessellatingHeckler Obrigado pela ajuda do regex. Eu pedi entrada ao Downgoat. Mas $l,$n,$d=$args-split'\D';+$l*$d+$n;$dé mais curto ainda aos 37 anos e segue logicamente o mesmo padrão que aqui.
AdmBorkBork
Oh sim, apenas matemática! (Isso seria o suficiente para bater uma resposta Perl, também)
TessellatingHeckler
3

Java com pólo a laser de dez pés 1.03, 79 + 25 (importação) = 104 bytes

Requer import sj224.tflp.math.*;

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

Isso quase certamente funcionará com a 1.04 também, mas até agora só a testei com a 1.03, porque já havia um projeto java configurado com a 1.03 no caminho da compilação.

SuperJedi224
fonte
3

JavaScript (ES6), 44 41 bytes

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

Economizou 3 bytes graças a @ETHproductions !

Explicação

Muito simples.

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

Teste

O teste é sem atribuição de desestruturação para funcionar na maioria dos navegadores.

user81655
fonte
Agradável! Você pode usar [p,q,r]=no lugar de p=, em seguida, substituir p[0], p[1]e, p[2]com p, qe r, respectivamente. Após essa alteração, recebo 41:m=>([p,q,r]=m.match(/\d+/g),+q+p*r+"/"+r)
ETHproductions
Obrigado pela dica! Na verdade, considerei usar uma tarefa de desestruturação, mas elas não funcionam no Chrome e eu não tinha o Firefox disponível para testá-la. : P
user81655
Meu primeiro riscou 44! : D
user81655
Em m.split(/\W/g)vez disso, você pode salvar um byte
Kritixi Lithos
2

Julia, 58 50 bytes

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

Esta é uma função anônima que aceita uma string e retorna um Rationalobjeto de tipo. Para chamá-lo, dê um nome, por exemplo f=s->....

Podemos tirar vantagem do fato de que a entrada pode ser manipulada levemente para ser uma expressão que é avaliada como racional. Em particular, um número inteiro mais um racional é um racional, e os racionais são indicados com barras duplas. Portanto, se nos transformarmos 4 1/2em 4+1//2, o resultado avaliado será 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
Alex A.
fonte
2

Smalltalk - 76 caracteres

A entrada corresponde exatamente ao delimitador da matriz e à representação da fração inerente do Smalltalk. Se não fosse tão detalhado, poderia ter sido um candidato sério!

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

É uma pena que a simplificação não fosse um requisito, o Smalltalk faz isso automaticamente!


fonte
2

Bash + coreutils, 28

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

$@expande para todos os parâmetros da linha de comando, portanto, ${@/\// }expande para todos os parâmetros da linha de comando /substituídos por , que é colocado na dcpilha de. O resto é simples manipulação de pilha e aritmética.

Trauma Digital
fonte
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

Experimente online!

Explicação

Como H.PWiz descobriu, podemos usar o lexer de Haskell aqui para quebrar a corda em suas partes. (No começo eu estava usando span(>'/')) E Laikoni apontou que <$>funciona exatamente como mapSndem Data.Tuple.

O protetor de padrão divide nosso código nos três números que queremos usar lex. lexchama o lexer de haskell para interromper o primeiro token. Ele retorna uma lista com cada elemento representando uma maneira possível de analisar a sequência. Esses elementos são tuplas, com o primeiro elemento sendo o primeiro token e o restante da string sendo o segundo elemento. Agora, como o formato de entrada é muito regular, apenas teremos exatamente uma análise, para que possamos sempre fazer a primeira. A primeira coisa que fazemos é chamar lexna entrada

lex x

Em seguida, desembrulhámo-lo da lista, fornecendo uma

lex x!!0

O primeiro token será a parte inteira da fração mista, deixando a fração precedida por um espaço para análise. Então, como as tuplas são Functors, podemos usar (<$>)um alias para fmapaplicar lexao segundo elemento da tupla.

lex<$>lex x!!0

Isso consome o espaço e interrompe o próximo token, o numerador da nossa fração. Agora, vinculamos isso a uma correspondência de padrão usando <-. Nosso padrão é

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

aagarra a parte inteira da fração, nosso primeiro token. :_desembrulha a lista resultante do nosso segundo lex. cpega o segundo token que inserimos, que é o numerador da fração. Tudo o que resta está vinculado ao s:dque o divide em seu primeiro caractere, garantido pelo formato de a /e o restante, que será o denominador.

Agora que analisamos a entrada, fazemos o cálculo real:

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

Onde restá a função de leitura que ligamos anteriormente.

É importante observar que lexretorna uma lista vazia se falhar e não vazia se for bem-sucedida. Por que isso não é um Maybeeu não sei.

Assistente de Trigo
fonte
11
67 bytes
H.PWiz 15/06
@ H.PWiz Esse é um ótimo uso do lex.
Assistente de trigo
2
65 bytes: Experimente online!
Laikoni
2
Você deve ser capaz de salvar outro 2 por correspondência na/
H.PWiz
11
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
fonte
11
Muito bom! Algumas dicas: Você pode usar [b,c]=no lugar de b=e depois usar bno lugar de b[0]e cno lugar de b[1]. Além disso, você pode reorganizar a equação para não precisar de parênteses: 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]"

Provavelmente isso pode ser jogado mais.

Alterar

  • Salva 16 bytes usando uma regex em splite 5 usando em <>vez de <STDIN>.
  • Economizou outros 16 bytes graças a Dennis.
ASCIIThenANSI
fonte
Com shebang #!perl -paF/\D/(9 bytes), você pode usar $_=$F[0]*$F[2]+$F[1]."/$F[2]".
Dennis
@ Dennis eu adicionei isso. Obrigado!
ASCIIThenANSI
A #!perlparte do shebang e o avanço de linha não contam. Isso é apenas 38 bytes.
Dennis
@ Dennis Oh, ok. Eu vou corrigir agora. (Do lado da brilhante eu acho que este é o segundo menor resposta não-esotérico)
ASCIIThenANSI
1

Mathematica, 51 bytes

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

Curiosamente, o Mathematica suporta isso com um built-in. Se a saída de um número for permitida, precisamos apenas de 28 bytes:

Interpreter@"ComputedNumber"
LegionMammal978
fonte
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;}

Economizou um monte de bytes graças ao FlagAsSpam.

SuperJedi224
fonte
@FlagAsSpam Done.
SuperJedi224
@FlagAsSpam Mas as variáveis ​​serão deixadas não declaradas!
SuperJedi224
Desconsidere tudo o que eu acabei de dizer - uma maneira curta de fazer o que você está fazendo éLong 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

Experimente online!

ATaco
fonte
Tenho certeza de que o formato de entrada "x y/z"é obrigatório para esse desafio em particular, mas caso eu tenha solicitado ao OP para verificar.
Kevin Cruijssen
1

05AB1E , 17 15 bytes

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

-2 bytes graças a @MagicOctopusUrn .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Com o formato flexível de entrada e saída, pegando os números inteiros na ordem x,z,ye emitindo o nominador e o denominador em linhas separadas, seria de 4 bytes (e foi por isso que adicionei a tag de ao desafio ..):

*+²»

Experimente online ou verifique todos os casos de teste .

Explicação:

*        # 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
fonte
@MagicOctopusUrn Obrigado, mas o formato de entrada é diferente do descrito na descrição do desafio. Aparentemente, o formato (como sequência única) 4 1/2é obrigatório para esse desafio em particular. Caso contrário, eu teria usado a minha versão de 4 bytes (ou se a saída era obrigatório, mas a entrada I flexível usaria este 6-Byter: *+'/²J)
Kevin Cruijssen
11
15 bytes
Magic Octopus Urn
@MagicOctopusUrn Ah, nem sabia " Empurre todos os itens da apilha " .. o.Ô Exatamente o que eu precisava para esse desafio! E inteligente com a junção por "/". Obrigado! :)
Kevin Cruijssen
Eu odeio usar o comando "Enviar todos os itens de um para a pilha" porque é "` "e não pode ser domado por tags de código em linha.
Magic Octopus Urn
@MagicOctopusUrn sim, é também um pouco chato em comentários (que é por isso que eu citei " empurram todos os itens de ana pilha " em vez 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

Experimente online!

xbarbie
fonte
return'%s/'%(int(a)*int(c)+int(b))+cé 2 bytes mais curto
ovs 16/06
1

Stax , 1 byte

+

Execute e depure (embora não haja muito o que depurar)

A especificação do desafio diz "Você não precisa simplificar a saída". Supondo que seja permitido simplificar, há uma instrução interna no stax para fazer isso. A entrada é implicitamente interpretada como um número inteiro e um número racional. A +instrução amplia ambos para os racionais, adiciona e simplifica. O resultado é impresso implicitamente.

recursivo
fonte
1

Perl 5 com -la -Mfeature = digamos, 32 bytes 25 bytes

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

Experimente online!

(-7 bytes graças a Dom Hastings)

$_é a entrada inteira x y/z, que avalia o valor xem contextos numéricos (como o *aqui). $'é a cadeia de caracteres pós-correspondência regex, que aqui contém o que vem depois /- então z,. Para obter o yvalor, usamos a -aflag que divide a entrada em espaços e as coloca na @Fmatriz. Então aqui, o @F = ("x", "y/z")que significa o $F[1]="y/z"que é avaliado em ycontextos numéricos (já que yé a sequência contígua inicial de dígitos com $F[1]).

sundar - Restabelecer Monica
fonte
Você não precisa contar a -pbandeira na sua contagem de bytes; em vez disso, você conta o idioma como Perl 5 with -p flag, 32 bytes. Veja esta meta post para o consenso atual.
Giuseppe
Boa abordagem! Eu tentei fazer uma versão de 25 bytes: Experimente online! . Usar $'era realmente a única diferença real!
Dom Hastings
A combinação de usar regex- $'e -a- $F[n]para obter partes da string é uma boa idéia, tenho que lembrar disso! Obrigado, atualizou a postagem.
sundar - Restabelece Monica
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
fonte
0

Via Láctea 1.6.0 , 31 bytes

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

Acabou sendo muito mais longo do que eu pensava.


Explicação

'" "\="/"\=>;<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>
Zach Gates
fonte
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]

Experimente online !

Você deve digitar a entrada entre aspas.

Provavelmente não é o melhor ...

Alex
fonte
76 bytes
Koishore Roy 13/07
0

C, 64

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

Lê a entrada de STDIN. Bastante auto-explicativo, eu acho.

Trauma Digital
fonte
0

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

Experimente online!

Talvez eu consiga salvar alguns bytes se não tentar reutilizar o loop de análise (a segunda linha). Dessa forma, eu poderia tornar o loop mais específico, evitar a enorme confusão de condicionais e usar o registro para outras coisas.

Esolanging Fruit
fonte
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;}

Versão completa / formatada:

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
fonte
0

PHP, 65 bytes

Experimente online

Código

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

Explicação

$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
fonte
0

Java 10, 87 bytes

Um lambda de Stringpara String.

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

Experimente Online

Jakob
fonte