Смешанное число до неправильной дроби

В этом задании вы будете конвертировать смешанное число в неправильную дробь.

Поскольку в неправильных дробях используется меньшее число, ваш код должен быть максимально коротким.

Примеры

4 1/2
9/2

12 2/4
50/4

0 0/2
0/2

11 23/44
507/44

Спецификация

Вы можете предположить, что знаменатель входных данных никогда не будет равен 0. Входные данные всегда будут иметь формат, x y/zгде x, y, z - произвольные неотрицательные целые числа. Вам не нужно упрощать вывод.

Это код-гольф, поэтому выигрывает самый короткий код в байтах.

Japt, 10 байт

Woohoo, в настоящее время побеждает CJam!

U*W+V+'/+W

Попробуйте онлайн!

Как это устроено

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

CJam, 16 15 14 байтов

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

или

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

Проверьте это здесь.

объяснение

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.

Другая версия избегает использования переменной, используя немного большее смещение стека.

Mathematica, 58 байт

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

Это возвращает упрощенный результат. Если вывести рациональное число вместо строки нормально, мы можем сохранить 19 байтов:

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

PowerShell, 47 44 42 байт

_{Вычеркнуто 44 все еще регулярно 44; (}

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

Гольф пару байтов с помощью регулярных выражений -split. Гольф еще пару благодаря TessellatingHeckler путем замены регулярного выражения.

Он $args-split'\D'принимает наш входной аргумент и разделяется на нецифровые символы. Здесь он выполняет два разбиения, одно на пробел, другое на /символ. Затем результаты сохраняются в трех переменных с использованием одновременного назначения. Затем мы формулируем вывод строки как (число $left, умноженное на $dзнаменатель плюс $nумератор), выполненный как блок кода, /косая черта, а затем $dснова знаменатель.

Ява с десятифутовым лазерным полюсом 1,03, 79 + 25 (импорт) = 104 байта

требует import sj224.tflp.math.*;

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

Это почти наверняка будет работать и с 1.04, но до сих пор я тестировал его только с 1.03, потому что мне уже довелось установить java-проект с 1.03 в пути сборки.

JavaScript (ES6), 44 41 байт

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

Сохранено 3 байта благодаря @ETHproductions !

объяснение

Очень просто.

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

Тестовое задание

Тест без деструктурирующего задания для работы в большинстве браузеров.

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>

Юлия, 58 50 байт

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

Это анонимная функция, которая принимает строку и возвращает Rationalобъект типа. Чтобы назвать его, дайте ему имя, например f=s->....

Мы можем воспользоваться тем фактом, что вводом можно слегка манипулировать, чтобы он стал выражением, которое оценивается как рациональное. В частности, целое число плюс рациональное является рациональным, а рациональные обозначаются двойными косыми чертами. Поэтому, если мы перейдем 4 1/2к 4+1//2, оцененный результат будет 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 символов

Входные данные точно соответствуют разделителю массива и представлению дробной части Smalltalk. Если бы это не было так многословно, это могло бы стать серьезным соперником!

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

Это слишком плохое упрощение не было требованием, Smalltalk делает это автоматически!

Bash + coreutils, 28

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

$@расширяется до всех параметров командной строки, поэтому ${@/\// }расширяется до всех параметров командной строки с /заменой на , которая помещается в dcстек. Остальное - простое манипулирование стеком и арифметика.

Haskell , 74 67 63 байта

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

Попробуйте онлайн!

объяснение

Как выяснил H.PWiz , мы можем использовать лексер Haskell, чтобы разбить строку на части. (Ранее я использовал span(>'/')) И Лайкони указал, что <$>работает так же, как и mapSndиз Data.Tuple.

Паттерн-охранник разбивает наш код на три числа, которые мы хотим использовать lex. lexвызывает лексера haskell, чтобы разорвать первый токен. Возвращает список с каждым элементом, представляющим возможный способ разбора строки. Эти элементы являются кортежами, причем первый элемент является первым токеном, а остальная часть строки - вторым элементом. Теперь, поскольку формат ввода очень регулярный, у нас будет только один разбор, поэтому мы всегда можем взять первый. Первое, что мы делаем, это вызываем lexна входе

lex x

Затем мы разворачиваем его из списка, давая нам 2-кортеж

lex x!!0

Первым маркером будет вся часть смешанной фракции, оставляющая фракцию с добавленным пробелом для анализа. Тогда, поскольку кортежи есть, Functorsмы можем использовать (<$>)псевдоним для fmapприменения lexко второму элементу кортежа.

lex<$>lex x!!0

Это проглатывает пространство и обрывает следующий токен, числитель нашей дроби. Теперь мы привязываем это к сопоставлению с образцом, используя <-. Наш образец

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

aзахватывает всю часть дроби, наш первый жетон. :_разворачивает список, полученный в результате нашего второго lex. cберет второй лексем, который мы лексировали, это числитель дроби. Все, что остается, связано с тем, s:dчто разделяет его на первый символ, гарантированный форматом/ а остальная часть будет знаменателем.

Теперь, когда мы проанализировали вход, мы делаем фактические вычисления:

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

Где rфункция чтения, которую мы связали ранее.

Важно отметить, что lexвозвращает список пустым, если он терпит неудачу, и непустым, если он успешен. Почему это не Maybeя не знаю.

Javascript ES6, 62 байта

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

Perl, 82 61 38 байт

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

Это, вероятно, может быть в гольф больше.

изменения

• Сохранено 16 байт с использованием регулярного выражения в split, и 5 с использованием <>вместо <STDIN>.
• Сохранено еще 16 байтов благодаря Денису.

Mathematica, 51 байт

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

Интересно, что Mathematica поддерживает это с помощью встроенного. Если разрешен вывод числа, то нам нужно только 28 байтов:

Interpreter@"ComputedNumber"

Ява, 159 148 142 120 110 байт

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

Благодаря FlagAsSpam сохранено несколько байтов.

ARBLE , 13 байт

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

Попробуйте онлайн!

05AB1E , 17 15 байт

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

-2 байта благодаря @MagicOctopusUrn .

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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

С гибким форматом ввода и вывода, принимая целые числа в порядке x,z,yи выводя знаменатель и знаменатель в разделенных строках, это будет 4 байта (именно поэтому я добавил в задачу синтаксический анализ -tag ...):

*+²»

Попробуйте онлайн или проверьте все тесты .

Объяснение:

*        # 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 байт

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

Попробуйте онлайн!

Stax , 1 байт

+

Запустите и отладьте его (хотя отладки не так много)

В спецификации задачи сказано: «Вам не нужно упрощать вывод». Если предположить , что это позволило упростить, то есть встроенные инструкции в StAX , чтобы сделать это. Входные данные неявно интерпретируются как целое и рациональное число. +Инструкция расширяется как для рациональных чисел, добавлений и упрощает. Результат неявно печатается.

Perl 5 с -la -Mfeature = скажем, 32 байта 25 байтов

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

Попробуйте онлайн!

(-7 байт благодаря Дому Гастингсу)

$_является целым входом x y/z, который оценивает значение xв числовом контексте (как *здесь). $'строка регулярного выражения после совпадения, которая здесь содержит все, что следует после /- так z,. Чтобы получить yзначение, мы используем -aфлаг, который разделяет входные данные на пробелы и помещает их в @Fмассив. Итак, здесь, @F = ("x", "y/z")что означает, $F[1]="y/z"что вычисляется в yчисловом контексте (поскольку yэто начальная непрерывная последовательность цифр с $F[1]).

Луа, 123 байта

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)

Млечный Путь 1.6.0 , 31 байт

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

Закончилось гораздо дольше, чем я думал.

объяснение

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

использование

./mw <path-to-code> -i <input>

Python 2.7, 88 байт

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

Попробуйте онлайн !

Вы должны ввести ввод в кавычках.

Наверное, не самый лучший ...

С, 64

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

Читает ввод из STDIN. Я думаю, что это довольно очевидно.

Чек , 120 байт

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

Попробуйте онлайн!

Я мог бы сохранить некоторые байты, не пытаясь повторно использовать цикл синтаксического анализа (вторая строка). Таким образом я мог бы сделать цикл более конкретным, избежать огромного беспорядка условий и использовать регистр для других целей.

Рубин , 23 байта

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

Попробуйте онлайн!

C #, 112 байт

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

Полная / Отформатированная версия:

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 байт

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

Попробуйте онлайн!

Спасибо ngn за ⊃⊥1∘↓трюк

PHP, 65 байт

Попробуйте онлайн

Код

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

объяснение

$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 байт

Лямбда из Stringв String.

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

Попробуйте онлайн