Viết chương trình hoặc hàm lấy hai danh sách không trống có cùng độ dài làm đầu vào và thực hiện như sau:

• sử dụng các yếu tố của danh sách đầu tiên để có được tử số,
• sử dụng các yếu tố của danh sách thứ hai để lấy mẫu số,
• hiển thị các phân số kết quả sau khi đơn giản hóa (2/4=>1/2), được phân tách bằng "+" s,
• hiển thị "=" và kết quả của phép cộng sau phân số cuối cùng.

Thí dụ:

Đầu vào

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

Đầu ra

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

Về quy tắc

• các yếu tố của danh sách sẽ là số nguyên dương,
• các phần tử có thể được phân tách bằng dấu cách, ví dụ: 1/2 + 2/9 + 1 + 3/2 + 3/2 = 85/18ok,
• dòng mới được cho phép,
• danh sách có thể được lấy ở các định dạng khác hơn ở trên, ví dụ: (1 2 3 3 6)hoặc {1;2;3;3;6}, v.v.
• 1có thể được thể hiện như 1/1,
• thay vì in bạn có thể trả về chuỗi thích hợp,
• bạn không cần xử lý đầu vào sai,
• mã ngắn nhất thắng .

M , 12 11 byte

÷µFj”+;”=;S

Đây là một liên kết dyadic. Do một lỗi, nó không hoạt động như một chương trình đầy đủ. Fcũng được yêu cầu do một lỗi.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

÷µ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.

Ruby 2.4, 54 53 ký tự

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

Nhờ vào:

• Giá trị mực cho phiên bản cụ thể của Ruby 2.4 (-3 ký tự)
• Giá trị mực để tối ưu hóa việc Rationalkhởi tạo (-1 ký tự)

Ruby, 58 57 56 ký tự

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

Chạy mẫu:

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

Hãy thử trực tuyến!

Toán học, 33 byte

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

đầu vào

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

Python 3 , 104 byte

9 byte nhờ Felipe Nardi Batista.

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

Hãy thử trực tuyến!

Perl 6 ,  77  73 byte

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

Thử nó

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

Thử nó

Mở rộng:

{  # 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
}

Clojure, 71 byte

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

Yay cho các phân số tích hợp!

Toán học, 61 byte

t=#~ToString~InputForm&;Riffle[t/@#,"+"]<>"="<>t@Tr@#&[#/#2]&

JavaScript (ES6), 111 byte

Đưa các danh sách theo cú pháp currying (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]))

Java, 225 byte

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

Nvà Dlà cả hai int[], theo ngữ cảnh.

Tôi đã sử dụng lại chức năng GCD của Kevin Cruijssen .

Xem nó và kiểm tra nó trực tuyến!

Julia v0.4 +, 66 53 byte

-13 byte nhờ Dennis

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

Hãy thử trực tuyến!

Cách khác, nếu phân số có thể được hiển thị bằng cách sử dụng //chứ không phải /, các công việc sau đây cho 35 byte :

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

setlX , 103 byte

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

Tạo một hàm được gọi là fnơi bạn chèn hai danh sách.

vô dụng:

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

với các biến và chú thích được đặt tên:
_{setlX không cung cấp tính năng nhận xét, vì vậy hãy giả vờ rằng chúng ta có thể nhận xét với%}

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

Perl 6, 72 byte 65 byte

Các tỷ lệ hợp lý tự động và tự động sẽ làm cho điều này trở nên dễ dàng, nhưng chuỗi phân loại mặc định vẫn là số thập phân, vì vậy chúng tôi phải .nude( nu merator và de nomator ) sẽ giết điểm của chúng tôi và làm cho 1 xấu xí :(

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("/")

Cập nhật: Đã xóa các dấu ngoặc không cần thiết, giết thêm dung lượng và sử dụng bản đồ thông minh hơn. Lưu các nhân vật qua giải pháp của Brad với chi phí không phải là một phụ lambda.

05AB1E , 35 34 byte

‚øvyy¿÷'/ý'+}¨'=¹.¿©¹÷²*O®‚D¿÷'/ýJ

Hãy thử trực tuyến!

Thạch , 31 byte

,:gj”/
ṙJ$ṖP×Sç⁸P¤,ç@"j”+$¥Ṛj”=

Hãy thử trực tuyến!

PHP> = 7.1, 190 byte

<?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);

Phiên bản trực tuyến

+14 byte để thay thế return$x/$t."/".$y/$t;bằng return$y/$t>1?$x/$t."/".$y/$t:$x/$t;đầu ra nthay vìn/1

F #, 244 241 239 byte

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

Hãy thử trực tuyến!

setlX , 62 byte

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

vô dụng:

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

R, 109 byte

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

yêu cầu MASSthư viện (cho fractionslớp học của nó ). hàm gtrả về đầu ra cần thiết dưới dạng chuỗi.

Hãy thử trực tuyến! (Liên kết R-fiddle)

MATL , 32 byte

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

Hãy thử trực tuyến!

Giải trình

Hãy xem xét [1, 2, 3, 3, 6], [2, 9, 3, 2, 4]như là đầu vào.

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

TI-BASIC, 100 byte

: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

Lưu ý ⁄ở đầu, khác với /. Điều này làm cho các phân số giữ hình thức của họ. Nó không hoạt động với các phân số âm.

Thở dài . TI-BASIC là khủng khiếp với chuỗi. Nếu tất cả những gì chúng ta phải làm là in các phân số, và sau đó tổng của chúng, mã sẽ là:

TI-BASIC, 12 byte

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

Điều đó có nghĩa là 88 byte mã của tôi được sử dụng chỉ để định dạng câu trả lời! Hừm .

C, 171 byte

Thử trực tuyến

i;t;x;y;f(int s,int*a,int*b){x=*a;y=*b;while(++i<s)x=(y-b[i])?(x*b[i])+(a[i]*y):(x+a[i]),y=(y-b[i])?(b[i]*y):y;for(i=1;i<=(x<y?x:y);++i)t=(x%i==0&&y%i==00)?i:t;x/=t;y/=t;}

Tiên đề, 212 byte

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)

kiểm tra

(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

Casio cơ bản, 161 byte

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

Giải trình:

• Số lượng đầu vào được lưu trong A
• A lặp đi lặp lại
• B hoạt động như một bộ đếm để hiển thị chính xác
• Imục thứ nhất của Danh sách 1 và 2 được lưu trong C vàD
• Hiển thị biến C / biếnD
• lưu C/ D+E vàoE
• Sau số cuối định vị =vàE

Haskell (Lambdabot), 94 91 86 byte

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

Hãy thử trực tuyến!

Cảm ơn @Laikoni cho -8byte!

Ung dung

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

Google Sheets, 83 81 byte

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

_{^{Đã lưu 2 byte nhờ Taylor Scott}}

Trang tính sẽ tự động thêm 2 dấu ngoặc đơn vào cuối công thức.

Hai mảng được nhập vào dưới dạng toàn bộ cột Avà B. Hàng trống bên dưới đầu vào sẽ ném lỗi.