입력과 길이가 같은 비어 있지 않은 두 개의 목록을 사용하고 다음을 수행하는 프로그램이나 함수를 작성하십시오.

• 분자를 얻기 위해 첫 번째 목록의 요소를 사용합니다.
• 두 번째 목록의 요소를 사용하여 분모를 얻습니다.
• 단순화 후 (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.
• 인쇄하는 대신 적절한 문자열을 반환 할 수 있습니다.
• 잘못된 입력을 처리 할 필요가 없습니다.
• 가장 짧은 코드가 승리 합니다.

M , 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.

루비 2.4, 54 53 자

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

덕분에 :

• Ruby 2.4 전용 버전의 Value Ink (-3 자)
• Rational초기화 최적화를위한 Value Ink (-1 자)

루비, 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

온라인으로 사용해보십시오!

수학, 33 바이트

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

입력

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

파이썬 3 , 104 바이트

Felipe Nardi Batista 덕분에 9 바이트.

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

온라인으로 사용해보십시오!

펄 6 ,  77  73 바이트

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

시도 해봐

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

시도 해봐

넓히는:

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

클로저, 71 바이트

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

내장 분수에 대한 예!

수학, 61 바이트

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

자바 스크립트 (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]))

자바, 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[]있습니다.

Kevin Cruijssen의 GCD 기능을 재사용했습니다 .

그것을보고 온라인으로 테스트하십시오!

Julia v0.4 +, 66 53 바이트

Dennis 덕분에 -13 바이트

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

온라인으로 사용해보십시오!

또는을 사용 //하지 않고 분수를 표시 할 수있는 경우 35 바이트에/ 대해 다음이 작동 합니다 .

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

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두 개의 목록을 삽입 하는 함수를 작성합니다.

언 골프 :

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

Perl 6, 72 바이트 65 바이트

기본 및 자동 유리수 해야 으로이 작업을 쉽게 수행 하지만 기본 문자열 화는 여전히 십진법이므로 점수를 죽이고 1 ugly를 만드는 .nude( nu merator 및 de nominator)해야합니다.

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

업데이트 : 불필요한 괄호를 제거하고 더 많은 공간을 제거하고 더 똑똑한지도를 사용하십시오. 람다 하위가 아닌 대가로 Brad의 솔루션보다 캐릭터를 절약합니다.

05AB1E , 35 34 바이트

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

온라인으로 사용해보십시오!

젤리 , 31 바이트

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

온라인으로 사용해보십시오!

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 바이트 return$x/$t."/".$y/$t;로 return$y/$t>1?$x/$t."/".$y/$t:$x/$t;출력 n대신n/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

온라인으로 사용해보십시오!

setlX , 62 바이트

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

언 골프 :

[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 바이트

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 바이올린 링크)

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'

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 바이트 가 답을 형식화하는 데 소비 된다는 것을 의미합니다 ! 흠 .

C, 171 바이트

온라인 시도

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

공리, 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

카시오 베이직, 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

하스켈 (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바이트 합니다!

언 골프

-- 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 스프레드 시트, 83 81 바이트

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

_{^{Taylor Scott 덕분에 2 바이트 절약}}

시트는 수식 끝에 닫는 괄호 2 개를 자동으로 추가합니다.

두 어레이는 입력으로서 전부 열 A및 B. 입력 아래에 빈 행이 있으면 오류가 발생합니다.