Schreiben Sie ein Programm oder eine Funktion, die zwei nicht leere Listen mit der gleichen Länge wie die Eingabe verwendet und Folgendes ausführt:

• Verwendet Elemente der ersten Liste, um Zähler zu erhalten.
• Verwendet Elemente der zweiten Liste, um Nenner zu erhalten.
• Nach der Vereinfachung werden die resultierenden Brüche (2/4=>1/2)durch "+" getrennt angezeigt.
• zeigt "=" und das Ergebnis der Addition nach dem letzten Bruch an.

Beispiel:

Eingang

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

Ausgabe

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

Über Regeln

• Elemente von Listen werden positive ganze Zahlen sein,
• Elemente können durch Leerzeichen getrennt werden, zB: 1/2 + 2/9 + 1 + 3/2 + 3/2 = 85/18ist ok,
• nachgestellte Zeilenumbrüche sind erlaubt,
• Listen können als oben in anderen Formaten aufgenommen werden, zB .: (1 2 3 3 6)oder {1;2;3;3;6}usw.
• 1kann ausgedrückt werden als 1/1,
• Anstatt zu drucken, können Sie die entsprechende Zeichenfolge zurückgeben.
• Sie müssen nicht mit falschen Eingaben umgehen,
• kürzester Code gewinnt .

M , 12 11 Bytes

÷µFj”+;”=;S

Dies ist eine dyadische Verbindung. Aufgrund eines Fehlers funktioniert es nicht als vollständiges Programm. Fwird auch wegen eines Fehlers benötigt.

Probieren Sie es online!

Wie es funktioniert

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

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

Dank an:

• Value Ink für die Ruby 2.4-spezifische Version (-3 Zeichen)
• Value Ink zur Optimierung der RationalInitialisierung (-1 Zeichen)

Ruby, 58 57 56 Zeichen

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

Probelauf:

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

Probieren Sie es online!

Mathematica, 33 Bytes

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

Eingang

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

Python 3 , 104 Bytes

9 Bytes dank Felipe Nardi Batista.

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

Probieren Sie es online!

Perl 6 ,  77,  73 Bytes

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

Versuch es

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

Versuch es

Erweitert:

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

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

Ja für eingebaute Brüche!

Mathematica, 61 Bytes

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

JavaScript (ES6), 111 Byte

Übernimmt die Listen in Curry-Syntax (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 Bytes

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

Nund Dsind beide int[]kontextualisiert.

Ich habe die GCD-Funktion von Kevin Cruijssen wieder verwendet .

Sieh es dir an und teste es online!

Julia v0.4 +, 66 53 Bytes

-13 Bytes dank Dennis

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

Probieren Sie es online!

Alternativ funktioniert Folgendes für 35 Bytes , wenn Brüche mit //anstatt angezeigt werden können :/

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

setlX , 103 bytes

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

Erstellt eine Funktion mit dem Namen, fin der Sie zwei Listen einfügen.

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

mit benannten Variablen und Annotationen:
_{setlX bietet keine Kommentarfunktion, also tun wir einfach so, als könnten wir mit Kommentaren arbeiten%}

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 Bytes 65 Bytes

Native und automatische Rationals sollten dies einfach machen, aber die Standardstringifizierung ist immer noch dezimal, also müssen wir .nude( nu merator und de nominator), was unsere Punktzahl tötet und die 1 hässlich macht :(

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

Update: Entfernte nicht benötigte Klammern, töte mehr Platz und verwende eine intelligentere Karte. Spart Charaktere über Brads Lösung, ohne ein Lambda-Sub zu sein.

05AB1E , 35 34 Bytes

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

Probieren Sie es online!

Gelee , 31 Bytes

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

Probieren Sie es online!

PHP> = 7.1, 190 Bytes

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

Online Version

+14 Bytes zum Ersetzen return$x/$t."/".$y/$t;durch return$y/$t>1?$x/$t."/".$y/$t:$x/$t;to output nstattn/1

F #, 244 241 239 Bytes

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

Probieren Sie es online!

setlX , 62 bytes

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

R 109 Bytes

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

benötigt die MASSBibliothek (für ihre fractionsKlasse). Die Funktion ggibt die erforderliche Ausgabe als Zeichenfolge zurück.

Probieren Sie es online! (R-Geige Link)

MATL , 32 Bytes

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

Probieren Sie es online!

Erläuterung

Betrachten wir [1, 2, 3, 3, 6], [2, 9, 3, 2, 4]als Eingabe.

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

: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

Beachten Sie die ⁄am Anfang, anders als /. Dadurch behalten die Fraktionen ihre Form. Es funktioniert mit negativen Brüchen.

Seufz . TI-BASIC ist schrecklich mit Streichern. Wenn wir nur die Brüche und dann ihre Summe drucken müssten, wäre der Code:

TI-BASIC, 12 Bytes

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

Das bedeutet, dass 88 Bytes meines Codes nur für das Formatieren der Antwort ausgegeben werden! Hmph .

C 171 Bytes

Versuchen Sie es online

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

Axiom 212 Bytes

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)

Prüfung

(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 Basic, 161 Bytes

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

Erläuterung:

• Anzahl der Eingaben wird in gespeichert A
• A Iterationen
• B Dient als Zähler für die korrekte Anzeige
• I'th Punkt der Liste 1 und 2 gespeichert in C undD
• Anzeige der Variablen C / VariableD
• Speichern Sie C/ D+E inE
• Nach der letzten Nummer suchen =undE

Haskell (Lambdabot), 94 91 86 Bytes

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

Probieren Sie es online!

Danke @Laikoni für -8Bytes!

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]

Google Sheets, 83 81 Bytes

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

_{^{2 Bytes gespart dank Taylor Scott}}

Sheets fügt am Ende der Formel automatisch 2 schließende Klammern hinzu.

Die beiden Arrays werden als Gesamtheit der Spalten Aund eingegeben B. Leere Zeilen unter den Eingaben führen zu Fehlern.