Змішане число до неправильної дроби

У цьому виклику ви перетворите змішане число на неправильну дріб.

Оскільки неправильні дроби використовують меншу кількість, ваш код повинен бути якомога коротшим.

Приклади

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.

Інша версія уникає використання змінної, використовуючи трохи більше зміщення стека.

Математика, 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'бере наш вхідний аргумент і розбивається на нецифрові символи. Тут він виконує два розколи, один на пробіл, інший на /персонажі. Потім результати зберігаються у трьох змінних за допомогою одночасного призначення. Потім формулюємо рядок виводу як ( eft $lчисло, що перевищує $dзнаменник плюс $nрозмір), виконаний у вигляді кодового блоку, /косою рисою, а потім $dзнову еномінатором.

Java з десятистопним лазерним полюсом 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.

Безголівки:

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

Маленька розмова - 76 символів

Вхід точно відповідає роздільнику масиву та притаманному йому представленню дріб. Якби це було не так багатослівно, це могло б бути серйозним суперником!

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

Це занадто погане спрощення не було вимогою, Smalltalk робить це автоматично!

Bash + coreutils, 28

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

$@розширюється на всі параметри командного рядка, тому ${@/\// }розширюється на всі параметри командного рядка із /заміненим на , який ставиться на dcs стек. Решта - це проста маніпуляція стеком і арифметика.

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 байт завдяки Деннісу.

Математика, 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.

АРБЛ , 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 байти (саме тому я додав розбір- тег до виклику ..):

*+²»

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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

Спробуйте в Інтернеті!

Стакс , 1 байт

+

Запустіть і налагоджуйте його (хоча не так багато для налагодження)

Специфікація виклику говорить "Вам не потрібно спрощувати вихід". Якщо припустити , що це дозволило спростити, тобто вбудовані інструкції в StAX , щоб зробити це. Введення неявно трактується як ціле і раціональне число. +Інструкція розширюється як для раціональних чисел, додавань і спрощує. Результат неявно друкується.

Perl 5 з -la -Matature = скажімо, 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 ]), '/', a [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];}

Спробуйте це в Інтернеті