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

19

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

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

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


Примеры

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 - произвольные неотрицательные целые числа. Вам не нужно упрощать вывод.


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

Downgoat
источник
5
Вы должны добавить тег "разбора". Я уверен, что большинство ответов потратит больше байтов на разбор ввода и форматирование вывода, чем на математику.
nimi
3
Может ли вывод быть рациональным числовым типом или он должен быть строкой?
Мартин Эндер
2
@AlexA .: ... но большая часть проблемы. Согласно его описанию тег должен использоваться в таких случаях.
nimi
7
Может x, yи zбыть отрицательным?
Деннис
2
Исходя из задачи, я предполагаю, что это так, но является ли формат ввода "xy / z" обязательным, или пробел может быть новой строкой и / или x,y,zразделенными входами? Большинство ответов предполагают, что входной формат действительно обязателен x y/z, но некоторые нет, поэтому на этот вопрос можно дать однозначный ответ.
Кевин Круйссен

Ответы:

1

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
ETHproductions
источник
Вчера я потратил много времени, пытаясь выяснить, как я заработал 15 повторений за ответ, пока не понял: моя первая зеленая галочка! \ o /
ETHproductions
7

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.

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

Мартин Эндер
источник
Мне действительно нужно больше использовать базовое преобразование в CJam.
Esolanging Fruit
Альтернативная версия: '//~\S/1$b'/@это 13 байтов. Редактировать : о, я забыл ввод l.
Chromium
4

Mathematica, 58 байт

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

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

ToExpression@StringReplace[#," "->"+"]&
Мартин Эндер
источник
4

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снова знаменатель.

AdmBorkBork
источник
Привет, я думаю, что вы можете сделать, -split ' |/'чтобы сохранить один символ с регулярным выражением «соответствует либо |, либо», или использовать -split '\D'для разделения на что-либо, что не является цифрой и s (h) имеет два символа. Если @Downgoat желает быть немного гибким в выходном формате, он '{0}*{2}+{1};{2}'-f($args-split'\D')|iexсоставляет 40 байтов и имеет намного более холодный вывод, потому что числа даже одно над другим!
TessellatingHeckler
1
@TessellatingHeckler Спасибо за помощь в регулярных выражениях. Я попросил Downgoat для ввода. Но $l,$n,$d=$args-split'\D';+$l*$d+$n;$dеще короче на 37 и логически следует той же схеме, что и здесь.
AdmBorkBork
Ах да, просто математика! (Этого было бы достаточно, чтобы обойти ответ Perl)
TessellatingHeckler
3

Ява с десятифутовым лазерным полюсом 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 в пути сборки.

SuperJedi224
источник
3

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
  )

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

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

user81655
источник
Ницца! Вы можете использовать [p,q,r]=вместо p=, а затем заменить p[0], p[1]и p[2]с p, qи r, соответственно. После этого изменения я получаю 41:m=>([p,q,r]=m.match(/\d+/g),+q+p*r+"/"+r)
ETHproductions
@ETHproductions Спасибо за совет! Я действительно рассматривал возможность использования задания по деструктуризации, но они не работают в Chrome, и у меня не было Firefox для его тестирования. : P
user81655 18.12.15
Мой первый вычеркнул 44! : D
user81655 18.12.15
Вы можете использовать m.split(/\W/g)вместо этого, чтобы сохранить байт
Kritixi Lithos
2

Юлия, 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
Алекс А.
источник
2

Smalltalk - 76 символов

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

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

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


источник
2

Bash + coreutils, 28

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

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

Цифровая травма
источник
2

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я не знаю.

Мастер пшеницы
источник
1
67 байт
H.PWiz
@ H.PWiz Это отличное использование lex.
Пшеничный волшебник
2
65 байт: попробуйте онлайн!
Лайкони
2
Вы должны быть в состоянии сохранить еще 2, сопоставив на/
H.PWiz
1
59 байт
H.PWiz
1

Javascript ES6, 62 байта

p=prompt;b=p(a=+p()).split`/`;alert((+b[1]*a+ +b[0])+"/"+b[1])
SuperJedi224
источник
1
Довольно мило! Некоторые советы: Вы можете использовать [b,c]=вместо b=, а затем использовать bвместо b[0]и cвместо b[1]. Кроме того, вы можете переставить уравнение так, чтобы вам вообще не нужны круглые скобки: p=prompt;[b,c]=p(a=+p()).split/;alert(+b+c*a+"/"+c)
ETHproductions
1

Perl, 82 61 38 байт

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

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

изменения

  • Сохранено 16 байт с использованием регулярного выражения в split, и 5 с использованием <>вместо <STDIN>.
  • Сохранено еще 16 байтов благодаря Денису.
ASCIIThenANSI
источник
С Шебанг #!perl -paF/\D/(9 байт), вы можете использовать $_=$F[0]*$F[2]+$F[1]."/$F[2]".
Деннис
@ Денис, я добавил это. Спасибо!
ASCIIThenANSI
#!perlЧасть притон и перевода строки не учитывается. Это всего 38 байтов.
Деннис
@ Денис О, хорошо. Я исправлю это сейчас. (С другой стороны, я думаю, что это второй самый короткий неэзотерический ответ)
неэзотерический
1

Mathematica, 51 байт

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

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

Interpreter@"ComputedNumber"
LegionMammal978
источник
1

Ява, 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 сохранено несколько байтов.

SuperJedi224
источник
@FlagAsSpam Готово.
SuperJedi224
@FlagAsSpam Но тогда переменные останутся необъявленными!
SuperJedi224
Не обращайте внимания на все, что я только что сказал - короткий путь к тому, что вы делаете,Long b=new Long(a[0]),c=new Long((a=a[1].split("/"))[0]),d=new Long(a[1]);
Аддисон Крамп
1

ARBLE , 13 байт

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

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

Ataco
источник
Я почти уверен, что формат ввода "x y/z"является обязательным для этой конкретной задачи, но на всякий случай я попросил OP подтвердить.
Кевин Круйссен
1

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
Кевин Круйссен
источник
@MagicOctopusUrn Спасибо, но формат ввода отличается от описания вызова. Очевидно, формат (как одна строка) 4 1/2является обязательным для этой конкретной задачи. В противном случае я бы использовал свой 4-байтовый версию (или если выход является обязательным, но вход гибкий Я хотел бы использовать эту 6-byter: *+'/²J)
Кевин Cruijssen
1
15 байт
Волшебная Урна Осьминога
@MagicOctopusUrn О, я даже не знал о том, что « Сложи все предметы aв стек » ... o.Ô Именно то, что мне было нужно для этого испытания! И умный с присоединением "/". Благодарность! :)
Кевин Круйссен
Я ненавижу использовать команду «Push all items of the stack», потому что она «` »и не может быть приручена встроенными кодовыми тегами.
Волшебная Урна Осьминога
@MagicOctopusUrn да, это также немного раздражает в комментариях (вот почему я цитировал « Поместить все элементы aв стек » вместо использования '`'..
Кевин Круйссен
1

Stax , 1 байт

+

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

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

рекурсивный
источник
1

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

sundar - Восстановить Монику
источник
Вам не нужно считать -pфлаг в вашем количестве байтов; вместо этого вы считаете язык Perl 5 with -p flag, 32 bytes. Смотрите этот мета-пост для текущего консенсуса.
Джузеппе
Хороший подход! Я только немного подумал и смог сделать 25-байтовую версию: попробуйте онлайн! , Использование $'было единственной реальной разницей там на самом деле!
Дом Гастингс
Комбинация использования обоих регулярных выражений - $'и -a- $F[n]для получения частей строки - довольно хорошая идея, я должен помнить это! Спасибо, обновил пост.
sundar - Восстановить Монику
0

Луа, 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)
Nikolai97
источник
0

Млечный Путь 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>
Зак Гейтс
источник
0

Python 2.7, 88 байт

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

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

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

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

Alex
источник
76 байтов
Койшор Рой
0

С, 64

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

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

Цифровая травма
источник
0

Чек , 120 байт

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

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

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

Esolanging Fruit
источник
0

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();
        }
    }
}
TheLethalCoder
источник
0

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
Франциско Хан
источник