Écrivez un programme ou une fonction qui prend deux listes non vides de la même longueur en entrée et effectue les opérations suivantes:

• utilise des éléments de première liste pour obtenir des numérateurs,
• utilise des éléments de la deuxième liste pour obtenir des dénominateurs,
• affiche les fractions résultantes après simplification (2/4=>1/2), séparées par des "+",
• affiche "=" et le résultat de l'addition après la dernière fraction.

Exemple:

Contribution

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

Production

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

À propos des règles

• les éléments des listes seront des entiers positifs,
• les éléments peuvent être séparés par des espaces, par exemple: 1/2 + 2/9 + 1 + 3/2 + 3/2 = 85/18est ok,
• le retour à la ligne est autorisé,
• les listes peuvent être prises dans d'autres formats que ci-dessus, par exemple: (1 2 3 3 6)ou {1;2;3;3;6}, etc.,
• 1peut être exprimé comme suit 1/1:
• au lieu d'imprimer, vous pouvez renvoyer la chaîne appropriée,
• vous n'avez pas besoin de gérer une mauvaise entrée,
• le code le plus court gagne .

M , 12 11 octets

÷µFj”+;”=;S

Il s'agit d'un lien dyadique. En raison d'un bogue, il ne fonctionne pas comme un programme complet. Fest également requis en raison d'un bogue.

Essayez-le en ligne!

Comment ça fonctionne

÷µ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 caractères

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

Grâce à:

• Encre de valeur pour la version spécifique Ruby 2.4 (-3 caractères)
• Encre de valeur pour optimiser l' Rationalinitialisation (-1 caractère)

Ruby, 58 57 56 caractères

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

Exemple d'exécution:

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

Essayez-le en ligne!

Mathematica, 33 octets

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

contribution

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

Python 3 , 104 octets

9 octets grâce à Felipe Nardi Batista.

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

Essayez-le en ligne!

Perl 6 ,  77  73 octets

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

Essayez-le

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

Essayez-le

Étendu:

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

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

Ouais pour les fractions intégrées!

Mathematica, 61 octets

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

JavaScript (ES6), 111 octets

Prend les listes dans la syntaxe de curry (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 octets

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

Net Dsont tous deux int[]contextualisés.

J'ai réutilisé la fonction GCD de Kevin Cruijssen .

Voir et tester en ligne!

Julia v0.4 +, 66 53 octets

-13 octets grâce à Dennis

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

Essayez-le en ligne!

Alternativement, si les fractions peuvent être affichées en utilisant //plutôt que /, les éléments suivants fonctionnent pour 35 octets :

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

setlX , 103 octets

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

Crée une fonction appelée foù vous insérez deux listes.

non golfé:

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

avec des variables nommées et des annotations:
_{setlX ne fournit pas de fonction de commentaire, alors faisons comme si nous pouvions commenter avec%}

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

Les rationnels natifs et automatiques devraient rendre cela facile, mais la chaîne de caractères par défaut est toujours aussi décimale, nous devons donc .nude( nu merator et de nominator) ce qui tue notre score et rend le 1 laid :(

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

Mise à jour: Suppression des supports inutiles, tuez plus d'espace et utilisez une carte plus intelligente. Enregistre les personnages sur la solution de Brad au prix de ne pas être un sous-marin lambda

05AB1E , 35 34 octets

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

Essayez-le en ligne!

Gelée , 31 octets

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

Essayez-le en ligne!

PHP> = 7.1, 190 octets

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

Version en ligne

+14 octets pour le remplacement return$x/$t."/".$y/$t;par la return$y/$t>1?$x/$t."/".$y/$t:$x/$t;sortie nau lieu den/1

F #, 244 241 239 octets

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

Essayez-le en ligne!

setlX , 62 octets

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

non golfé:

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

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

nécessite la MASSbibliothèque (pour sa fractionsclasse). la fonctiong renvoie la sortie requise sous forme de chaîne.

Essayez-le en ligne! (Lien R-violon)

MATL , 32 octets

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

Essayez-le en ligne!

Explication

Considérez [1, 2, 3, 3, 6], [2, 9, 3, 2, 4]comme entrée.

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

: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

Notez le ⁄au début, différent de /. Cela fait que les fractions conservent leurs formes. Il fait le travail avec des fractions négatives.

Soupir . TI-BASIC est horrible avec des cordes. Si tout ce que nous avions à faire était d'imprimer les fractions, puis leur somme, le code serait:

TI-BASIC, 12 octets

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

Cela signifie que 88 octets de mon code sont dépensés juste pour formater la réponse! Hmph .

C, 171 octets

Essayez en ligne

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

Axiome, 212 octets

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)

tester

(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 octets

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

Explication:

• Le nombre d'entrées est enregistré dans A
• A itérations
• B agit comme un compteur pour un affichage correct
• I'e élément des listes 1 et 2 enregistré dans CetD
• Affichage de variable C/ variableD
• enregistrer C/ D+ EdansE
• Après le dernier numéro, localisez =etE

Haskell (Lambdabot), 94 91 86 octets

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

Essayez-le en ligne!

Merci @Laikoni pour les -8octets!

Non golfé

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

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

_{^{Enregistré 2 octets grâce à Taylor Scott}}

Les feuilles ajouteront automatiquement 2 parenthèses fermantes à la fin de la formule.

Les deux tableaux sont entrés comme l' intégralité des colonnes Aet B. Les lignes vides sous les entrées génèrent des erreurs.