Добавление дробей


14

Напишите программу или функцию, которая принимает в качестве входных данных два непустых списка одинаковой длины и выполняет следующие действия:

  • использует элементы первого списка, чтобы получить числители,
  • использует элементы второго списка, чтобы получить знаменатели,
  • отображает результирующие дроби после упрощения (2/4=>1/2), разделенные знаком «+»,
  • отображает «=» и результат сложения после последней дроби.

Пример:

вход

[1, 2, 3, 3, 6]
[2, 9, 3, 2, 4]

Выход

1/2+2/9+1+3/2+3/2=85/18

О правилах

  • элементы списков будут целыми положительными числами,
  • элементы могут быть разделены пробелами, например: 1/2 + 2/9 + 1 + 3/2 + 3/2 = 85/18это нормально,
  • завершающий перевод новой строки разрешен,
  • списки могут быть взяты в других форматах, чем указано выше, например: (1 2 3 3 6)или {1;2;3;3;6}, и т. д.,
  • 1может быть выражено как 1/1,
  • вместо печати вы можете вернуть соответствующую строку,
  • вам не нужно обрабатывать неправильный ввод,
  • самый короткий код выигрывает .

Какой диапазон значений он должен поддерживать?
Брэд Гилберт b2gills

@ BradGilbertb2gills Я бы сказал, по крайней мере, от -30 000 до 30 000, но тогда я не знаю, будет ли это дополнительной проблемой для некоторых языков. Так что, возможно, просто стандартный диапазон целых чисел вашего выбора языка.

@ PrzemysławP, говоря, что «стандартный целочисленный диапазон вашего языка по вашему выбору» не очень хорошая идея, некоторые языки имеют стандартное целое число в виде логических значений
Felipe Nardi Batista

Спасибо! @ BradGilbertb2gills Тогда, по крайней мере, от -30 000 до 30 000.

Можем ли мы получить дроби [1, 2] [2, 9] [3, 3] ...вместо?
Оливье Грегуар

Ответы:


1

М , 12 11 байт

÷µFj”+;”=;S

Это диадическая ссылка. Из-за ошибки, она не работает как полная программа. Fтакже требуется из-за ошибки.

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

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

÷µFj”+;”=;S  Dyadic link. Left argument: N. Right argument: D

÷            Perform vectorized division, yielding an array of fractions (R).
 µ           Begin a new, monadic chain. Argument: R
  F          Flatten R. R is already flat, but j is buggy and has side effects.
   j”+       Join R, separating by '+'.
      ;”=    Append '='.
         ;S  Append the sum of R.

Мне нравится, как более четверти программы добавляет «=». :)
Computronium

7

Ruby 2.4, 54 53 символа

->n,d{a=n.zip(d).map{|n,d|n.to_r/d};a*?++"=#{a.sum}"}

Благодаря:

Рубин, 58 57 56 символов

->n,d{t=0;n.zip(d).map{|n,d|t+=r=n.to_r/d;r}*?++"=#{t}"}

Образец прогона:

irb(main):001:0> puts ->n,d{t=0;n.zip(d).map{|n,d|t+=r=n.to_r/d;r}*?++"=#{t}"}[[1, 2, 3, 3, 6], [2, 9, 3, 2, 4]]
1/2+2/9+1/1+3/2+3/2=85/18

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


1
a=n.zip(d).map{|f|(f*?/).to_r};a*?++"=#{a.sum}"в Ruby 2.4 экономит 3 байта.
Value Ink

Спасибо @ValueInk. Я подозревал, что это возможно, просто не было 2.4 ни локально, ни на TIO.
manatwork

1
Да, я установил 2.4 специально, чтобы я мог проверить решения с sumхаха. Также я только что вспомнил, что .map{|i,j|i.to_r/j}короче на 1 байт
Value Ink

Doh. Я пробовал разные подходы .to_fи деления, но не думал делиться Rationalс ними Fixnum. Еще раз спасибо, @ValueInk.
manatwork

6

Mathematica, 33 байта

Row@{Row[#/#2,"+"],"=",Tr[#/#2]}&

вход

[{1, 2, 3, 3, 6}, {2, 9, 3, 2, 4}]


Разве не так Row@@{#/#2,"+"}же, как Row[#/#2,"+"]?
feersum

да! вы правы!
J42161217

1
Фантастический! Я не понимал, что Rowбыло так удобно для таких вещей, как это :)
Грег Мартин

3

Python 3 , 104 байта

9 байтов благодаря Фелипе Нарди Батиста.

from fractions import*
def f(*t):c=[Fraction(*t)for t in zip(*t)];print('+'.join(map(str,c)),'=',sum(c))

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



@FelipeNardiBatista muito.
Утренняя монахиня

изменить +'='+str(sum(c))на,'=',sum(c)
Фелипе Нарди Батиста

@FelipeNardiBatista Спасибо, я также использовал Python 3 здесь (исходя из личных предпочтений).
Дрянная монахиня


3

Perl 6 ,  77  73 байта

{join('+',($/=[@^a Z/ @^b]).map:{.nude.join('/')})~"="~$/.sum.nude.join('/')}

Попытайся

{($/=[@^a Z/@^b])».nude».join('/').join('+')~'='~$/.sum.nude.join('/')}

Попытайся

Expanded:

{  # bare block lambda with two placeholder params 「@a」 and 「@b」

  (
    $/ = [              # store as an array in 「$/」 for later use

      @^a Z/ @^b        # zip divide the two inputs (declares them)

    ]

  )».nude\              # get list of NUmerators and DEnominators
  ».join('/')           # join the numerators and denominators with 「/」

  .join('+')            # join that list with 「+」

  ~
  '='                   # concat with 「=」
  ~

  $/.sum.nude.join('/') # get the result and represent as fraction
}

3

Clojure, 71 байт

#(let[S(map / % %2)](apply str(concat(interpose '+ S)['=(apply + S)])))

Yay для встроенных дробей!



2

JavaScript (ES6), 111 байт

Принимает списки в карри синтаксисе (a)(b).

let f =

a=>b=>a.map((v,i)=>F(A=v,B=b[i],N=N*B+v*D,D*=B),N=0,D=1,F=(a,b)=>b?F(b,a%b):A/a+'/'+B/a).join`+`+'='+F(A=N,B=D)

console.log(f([1, 2, 3, 3, 6])([2, 9, 3, 2, 4]))


2

Java, 225 байт

int c(int a,int b){return b>0?c(b,a%b):a;}
(N,D)->{int n=0,d=1,i=0,g;String s="";for(;i<N.length;g=g(N[i],D[i]),N[i]/=g,D[i]/=g,s+=(i>0?"+":"")+N[i]+"/"+D[i],n=n*D[i]+N[i]*d,d*=D[i++],g=g(n,d),n/=g,d/=g);return s+"="+n+"/"+d;}

Nи Dоба int[], контекстуализированы.

Я снова использовал функцию GCD Кевина Круйссена .

Посмотрите и протестируйте онлайн!


2

Юлия v0.4 +, 66 53 байта

-13 байтов благодаря Деннису

a^b=replace(join(a.//b,"+")"=$(sum(a.//b))","//","/")

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

С другой стороны, если дроби могут отображаться с использованием, //а не /, следующее работает для 35 байтов :

a^b=join(a.//b,'+')"=$(sum(a.//b))"

2

setlX , 103 байта

f:=procedure(a,b){i:=1;l:=[];while(i<=#a){l:=l+[a[i]/b[i]];i+=1;}s:=join(l,"+");return s+"="+eval(s);};

Создает функцию, вызываемую fгде вы вставляете два списка.

ungolfed:

f := procedure (a,b) {
    i:=1;
    l:=[];
    while(i<=#a){
        l:=l+[a[i]/b[i]];
        i+=1;
    }
    s:=join(l,"+");
    return s+"="+eval(s);
};

с именованными переменными и аннотациями:
setlX не предоставляет функцию комментариев, поэтому давайте просто притворимся, что мы можем комментировать%

f := procedure(firstList,secondList) {
    count := 1;
    list := []; 
    while(count <= #firstList) {
        % calculate every fraction and save it as a list
        list := list + [firstList[count]/secondList[count]];
        count += 1;
    }
    % Seperate every list entry with a plus ([2/3,1] -> "2/3+1")
    str := join(list, "+");
    % eval executes the string above and thus calculates our sum
    return str + "=" + eval(str);
};


Что если #firstList отличается от #secondList?
РосЛюП

Вы имеете в виду разный размер? В вопросе говорится, что перечислитель использует первый список, и может быть введен неправильный ввод
BlueWizard

но кроме этого: если второй список длиннее, остальные записи будут игнорироваться. Если список будет короче, произойдет ошибка времени выполнения.
BlueWizard

1

Perl 6, 72 байта 65 байтов

Собственные и автоматические рациональные числа должны упростить эту задачу, но по умолчанию строковое форматирование по- прежнему является десятичным, поэтому мы должны .nude( nu merator и de nominator) убить наш счет и сделать 1 уродливым :(

my \n = 1,2,3,3,6; my \d = 2,9,3,2,4;
(n Z/d)».nude».join("/").join("+")~"="~([+] n Z/d).nude.join("/")

Обновление: убрал ненужные скобки, убил больше места и использовал более умную карту. Сохраняет персонажей над решением Брэда за счет того, что не является лямбда-сабом.


Добро пожаловать на сайт! Хороший первый ответ!
programmer5000



1

PHP> = 7.1, 190 байт

<?function f($x,$y){for($t=1+$x;$y%--$t||$x%$t;);return$x/$t."/".$y/$t;}[$n,$d]=$_GET;for($p=array_product($d);$x=$n[+$k];$e+=$x*$p/$y)$r[]=f($x,$y=$d[+$k++]);echo join("+",$r)."=".f($e,$p);

Онлайн версия

+14 Bytes для замены return$x/$t."/".$y/$t;с return$y/$t>1?$x/$t."/".$y/$t:$x/$t;на выходе nвместоn/1


1

F #, 244 241 239 байт

let rec g a=function|0->abs a|b->g b (a%b)
let h a b=g a b|>fun x->a/x,b/x
let s,n,d=List.fold2(fun(s,n,d)N D->
 let(N,D),(n,d)=h N D,h(n*D+N*d)(d*D)
 s@[sprintf"%i/%i"N D],n,d)([],0,1)nom div
printf"%s=%i/%i"(System.String.Join("+",s))n d

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


1

setlX , 62 байта

[a,b]|->join([x/y:[x,y]in a><b],"+")+"="++/[x/y:[x,y]in a><b];

ungolfed:

[a,b]|->                  define a function with parameters a and b
  join(                 
    [ x/y :               using set comprehension, make a list of fractions 
      [x,y] in a><b       from the lists zipped together
    ],
    "+"
  )                       join them with "+"
  + "="                   concat with an equals sign
  +                       concat with
  +/[x/y:[x,y]in a><b]    the sum of the list
;

сессия переводчика


0

R, 109 байт

f=MASS::fractions;a=attributes
g=function(n,d)paste(paste(a(f(n/d))$f,collapse='+'),a(f(sum(n/d)))$f,sep='=')

требует MASSбиблиотеки (для своего fractionsкласса). функцияg возвращает требуемый вывод в виде строки.

Попробуйте онлайн! (Ссылка R-fiddle)


0

MATL , 32 байта

/YQv'%i/%i+'wYD3L)61yUYQVwV47b&h

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

объяснение

Посмотрим [1, 2, 3, 3, 6], [2, 9, 3, 2, 4]как на вход.

/         % Implicit inout. Divide element-wise
          % STACK: [0.5 0.222 1 1.5 1.5]
YQ        % Rational approximation (with default tolerance)
          % STACK: [1 2 1 3 3], [2 9 1 2 2]
v         % Conctenate all stack elements vertically
          % STACK: [1 2; 2 9; 1 2; 3 2; 3 2]
'%i/%i+'  % Push this string (sprintf format specifier)
          % STACK: [1 2; 2 9; 1 2; 3 2; 3 2], '%i/%i+'
wYD       % Swap, sprintf
          % STACK: '1/2+2/9+1/1+3/2+3/2+'
3L)       % Remove last entry
          % STACK: '1/2+2/9+1/1+3/2+3/2'
61        % Push 61 (ASCII for '=')
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61
y         % Duplicate from below
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, '1/2+2/9+1/1+3/2+3/2'
U         % Evaluste string into a number
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, 4.722
YQ        % Rational approximation 
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, 85, 18
VwV       % Convert to string, swap, convert to string
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, '18', '85'
47        % Push 47 (ASCII for '/')
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, '18', '85', 47
b         % Bubble up in stack
          % STACK: '1/2+2/9+1/1+3/2+3/2', 61, '85', 47, '18'
&h        % Concatenate all stack elements horizontally. Implicitly display
          % STACK: '1/2+2/9+1/1+3/2+3/2=85/18'

0

TI-BASIC, 100 байт

:L₁⁄L₂                                              //Creates a fraction from Lists 1 & 2, 7 bytes
:toString(Ans→Str1                                  //Create string from list, 7 bytes
:inString(Ans,",→A                                  //Look for commas, 9 bytes
:While A                                            //Begin while loop, 3 bytes
:Str1                                               //Store Str1 to Ans, 3 bytes
:sub(Ans,1,A-1)+"+"+sub(Ans,A+1,length(Ans)-A→Str1  //Replace "," with "+", 33 bytes
:inString(Ans,",→A                                  //Check for more commas, 9 bytes
:End                                                //End while loop, 2 bytes
:Str1                                               //Store Str1 to Ans, 3 bytes
:sub(Ans,2,length(Ans)-2                            //Remove opening and closing brackets, 13 bytes
:Ans+"="+toString(expr(Ans                          //Add "=" and answer, 11 bytes

Обратите внимание на начало, отличное от /. Это заставляет фракции держать свои формы. Это делает работу с отрицательными фракциями.

Вздох . TI-BASIC - это ужасно со строками. Если бы все, что нам нужно было сделать, это распечатать дроби, а затем их сумму, код был бы:

TI-BASIC, 12 байтов

:L₁⁄L₂    //Create fractions from lists, 7 bytes
:Disp Ans //Display the above fractions, 3 bytes
:sum(Ans  //Display the answer, 2 bytes

Это означает, что 88 байтов моего кода тратятся только на форматирование ответа! Хммм .



0

Аксиома, 212 байт

C==>concat;S==>String;g(a)==C[numerator(a)::S,"/",denom(a)::S];h(a:List PI,b:List PI):S==(r:="";s:=0/1;#a~=#b or #a=0=>"-1";for i in 1..#a repeat(v:=a.i/b.i;s:=s+v;r:=C[r,g(v),if i=#a then C("=",g(s))else"+"]);r)

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

(5) -> h([1,3,4,4,5,6], [2,9,5,5,6,7])
   (5)  "1/2+1/3+4/5+4/5+5/6+6/7=433/105"
                                                             Type: String
(6) -> h([1,3,4,4], [2,9,5,5,6,7])
   (6)  "-1"
                                                             Type: String

0

Casio Basic, 161 байт

Dim(List 1)->A
for 1->I to A step 1
3*I-2->B
List 1[I]->C
List 2[I]->D
locate 1,B,C
locate 1,B+1,"/"
locate 1,B+2,D
C/D+E->E
next
locate 1,B+3,"="
locate 1,B+4,E

Объяснение:

  • Номер входа сохраняется в A
  • A итерации
  • B действует как счетчик для правильного отображения
  • I-й элемент списка 1 и 2 сохраняются в CиD
  • Отображение переменной C/ переменнойD
  • сохранить C/ D+ EвE
  • После последнего номера найдите =иE

0

Haskell (Lambdabot), 94 91 86 байтов

t=tail.((\[n,_,d]->'+':n++'/':d).words.show=<<)
a#b|f<-zipWith(%)a b=t f++'=':t[sum f]

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

Спасибо @Laikoni за -8 байты!

Ungolfed

-- convert each fraction to a string (has format "n%d", replace '%' with '/' and prepend '+' ("+n/d"), keep the tail (dropping the leading '+')
t = tail.((\[n,_,d]->'+':n++'/':d).words.show=<<)
-- build a list of fractions
a # b = let f = zipWith(%) a b in
-- stringify that list, append "=" and the stringified sum of these fractions
  t f ++ "=" ++ t [sum f]

Вы пропустили, import Data.Ratioдля %которого нет в Prelude.
Лайкони

1
Вы можете сохранить несколько байтов, заменив "?"++на '?':.
Лайкони

1
Сокращение также работает для "/"++dи "="++.
Лайкони

1
Переупорядочение сохраняет еще несколько байтов:tail(f>>=t)++'=':(tail.t.sum)f
Laikoni

1
Ввод tailи =<<в tэкономит несколько больше: Попробуйте его в Интернете!
Лайкони

0

Google Sheets, 83 81 байт

=ArrayFormula(JOIN("+",TRIM(TEXT(A:A/B:B,"?/???")))&"="&TEXT(sum(A:A/B:B),"?/???"

Сохранено 2 байта благодаря Тейлору Скотту

Листы автоматически добавят 2 закрывающие скобки в конец формулы.

Два массива вводятся как совокупность столбцов Aи B. Пустые строки под входами приведут к ошибкам.


вы должны иметь возможность сбросить 2 байта, сбросив терминал))
Тейлор Скотт
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.