Agregar fracciones

14

Escriba un programa o una función que tome dos listas no vacías de la misma longitud que la entrada y haga lo siguiente:

  • usa elementos de la primera lista para obtener numeradores,
  • usa elementos de la segunda lista para obtener denominadores,
  • muestra las fracciones resultantes después de la simplificación (2/4=>1/2) , separadas por "+" s,
  • muestra "=" y el resultado de la suma después de la última fracción.

Ejemplo:

Entrada

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

Salida

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

Acerca de las reglas

  • los elementos de las listas serán enteros positivos,
  • los elementos se pueden separar por espacios, por ejemplo: 1/2 + 2/9 + 1 + 3/2 + 3/2 = 85/18 está bien,
  • se permite la nueva línea final,
  • las listas se pueden tomar en otros formatos que no sean los anteriores, por ejemplo: (1 2 3 3 6)o{1;2;3;3;6} , etc.,
  • 1 puede expresarse como 1/1 ,
  • en lugar de imprimir, puede devolver la cadena apropiada,
  • no es necesario manejar una entrada incorrecta,
  • el código más corto gana .

fuente
¿Qué rango de valores tiene que soportar?
Brad Gilbert b2gills
@ BradGilbertb2gills Diría que al menos -30 000 a 30 000, pero no sé si sería un problema adicional para algunos idiomas. Entonces, tal vez solo el rango entero estándar de su idioma de elección.
@ PrzemysławP diciendo que "el rango entero estándar de su idioma de elección" no es una buena idea, algunos idiomas tienen un entero estándar como booleanos
Felipe Nardi Batista
¡Gracias! @ BradGilbertb2gills Entonces al menos -30 000 a 30 000.
¿Podemos obtener fracciones como en su [1, 2] [2, 9] [3, 3] ...lugar?
Olivier Grégoire

Respuestas:

1

M , 12 11 bytes

÷µFj”+;”=;S

Este es un enlace diádico. Debido a un error, no funciona como un programa completo. FTambién es necesario debido a un error.

Pruébalo en línea!

Cómo funciona

÷µ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.
Dennis
fuente
Me gusta cómo más de una cuarta parte del programa es agregar el '='. :)
Computronium
7

Ruby 2.4, 54 53 caracteres

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

Gracias a:

  • Value Ink para la versión específica Ruby 2.4 (-3 caracteres)
  • Value Ink para optimizar la Rationalinicialización (-1 carácter)

Ruby, 58 57 56 caracteres

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

Ejecución de muestra:

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

Pruébalo en línea!

hombre trabajando
fuente
1
a=n.zip(d).map{|f|(f*?/).to_r};a*?++"=#{a.sum}"en Ruby 2.4 te ahorra 3 bytes.
Value Ink
Gracias @ValueInk. Sospeché que puede ser posible, simplemente no tenía 2.4 ni localmente ni en TIO.
manatwork
1
Sí, instalé 2.4 específicamente para poder probar soluciones con sumjaja. También recordé que .map{|i,j|i.to_r/j}es más corto en 1 byte
Value Ink
Doh He intentado varios enfoques a través .to_fy división, pero no pensé que dividir Rationalcon Fixnum. Gracias de nuevo, @ValueInk.
manatwork
6

Mathematica, 33 bytes

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

entrada

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

J42161217
fuente
¿No es lo Row@@{#/#2,"+"}mismo que Row[#/#2,"+"]?
Feersum
¡si! ¡tienes razón!
J42161217
1
¡Fantástico! No me di cuenta de que Rowera tan conveniente para cosas como esta :)
Greg Martin
3

Python 3 , 104 bytes

9 bytes gracias a Felipe Nardi Batista.

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

Pruébalo en línea!

Monja permeable
fuente
golf un poco
Felipe Nardi Batista
@FelipeNardiBatista muito.
Leaky Nun
cambiar +'='+str(sum(c))a,'=',sum(c)
Felipe Nardi Batista
@FelipeNardiBatista Gracias, también he usado Python 3 aquí (según mi preferencia personal).
Leaky Nun
3

Perl 6 ,  77  73 bytes

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

Intentalo

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

Intentalo

Expandido:

{  # 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
}
Brad Gilbert b2gills
fuente
3

Clojure, 71 bytes

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

¡Yay por fracciones incorporadas!

NikoNyrh
fuente
2

Mathematica, 61 bytes

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

JavaScript (ES6), 111 bytes

Toma las listas en sintaxis 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]))

Arnauld
fuente
2

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

Ny Destán ambos int[]contextualizados.

Me reutilicé función GCD de Kevin Cruijssen .

¡Véalo y pruébelo en línea!

Olivier Grégoire
fuente
2

Julia v0.4 +, 66 53 bytes

-13 bytes gracias a Dennis

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

Pruébalo en línea!

Alternativamente, si las fracciones se pueden mostrar usando en //lugar de /, lo siguiente funciona para 35 bytes :

a^b=join(a.//b,'+')"=$(sum(a.//b))"
Julian Wolf
fuente
2

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

Crea una función llamada f donde inserta dos listas.

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

con variables y anotaciones con nombre:
setlX no proporciona una función de comentario, así que solo pretendamos que podemos comentar con%

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

BlueWizard
fuente
¿Qué sucede si #firstList es diferente de #secondList?
RosLuP
te refieres al tamaño denet? Los estados de interrogación que primera lista es utilizada por empadronador y de entrada incorrecta pueden ingored
BlueWizard
pero aparte de eso: si la segunda lista es más larga, se ignorarán las entradas restantes. Si la lista es más corta, se producirá un error de tiempo de ejecución.
BlueWizard
1

Perl 6, 72 bytes 65 bytes

Los racionales nativos y automáticos deberían facilitar esto, pero la cadena de caracteres predeterminada sigue siendo decimal, por lo que tenemos que .nude( nu merator y de nominator) que mata nuestra puntuación y hace que el 1 sea feo :(

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

Actualización: se eliminaron los corchetes innecesarios, se eliminó más espacio y se utilizó un mapa más inteligente. Guarda los personajes sobre la solución de Brad a costa de no ser un sub lambda.

Dean Serenevy
fuente
Bienvenido al sitio! Buena primera respuesta!
programador
1

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

Versión en línea

+14 bytes para reemplazo return$x/$t."/".$y/$t;con return$y/$t>1?$x/$t."/".$y/$t:$x/$t;salida en nlugar den/1

Jörg Hülsermann
fuente
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

Pruébalo en línea!

Brunner
fuente
1

setlX , 62 bytes

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

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

sesión de intérprete

corvus_192
fuente
0

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='=')

requiere la MASSbiblioteca (para su fractionsclase). la función gdevuelve la salida requerida como una cadena.

Pruébalo en línea! (Enlace R-Fiddle)

Giuseppe
fuente
0

MATL , 32 bytes

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

Pruébalo en línea!

Explicación

Considerar [1, 2, 3, 3, 6], [2, 9, 3, 2, 4]como entrada.

/         % 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'
Luis Mendo
fuente
0

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

Tenga en cuenta el al principio, diferente de /. Esto hace que las fracciones mantengan sus formas. Se hace el trabajo con fracciones negativas.

Suspiro . TI-BASIC es horrible con las cuerdas. Si todo lo que tuviéramos que hacer fuera imprimir las fracciones, y luego su suma, el código sería:

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

¡Eso significa que se gastan 88 bytes de mi código simplemente formateando la respuesta! Hmph .

Scott Milner
fuente
0

C, 171 bytes

Probar en línea

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;}
Khaled.K
fuente
0

Axioma, 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)

prueba

(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
RosLuP
fuente
0

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

Explicación:

  • El número de entrada se guarda en A
  • A iteraciones
  • B actúa como un contador para mostrar correctamente
  • IEl elemento de la Lista 1 y 2 se guarda en CyD
  • Visualización de variable C/ variableD
  • guardar C/ D+ EenE
  • Después del último número, ubique =yE
ADDB
fuente
0

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]

Pruébalo en línea!

Gracias @Laikoni por -8bytes!

Sin 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]
ბიმო
fuente
Te falta un import Data.Ratiopara el %que no está en Prelude.
Laikoni
1
Puede guardar algunos bytes reemplazándolos "?"++con '?':.
Laikoni
1
El acortamiento también funciona para "/"++dy "="++.
Laikoni
1
Reorganizar ahorra algunos bytes más:tail(f>>=t)++'=':(tail.t.sum)f
Laikoni
1
Poner taily =<<en tahorra algo más: Pruébalo en línea!
Laikoni
0

Hojas de cálculo de Google, 83 81 bytes

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

Guardado 2 bytes gracias a Taylor Scott

Las hojas agregarán automáticamente 2 paréntesis de cierre al final de la fórmula.

Las dos matrices se ingresan como la totalidad de las columnas Ay B. Las filas vacías debajo de las entradas arrojarán errores.

Tostadas de ingeniero
fuente
deberías poder soltar 2 bytes soltando el terminal))
Taylor Scott