एक प्रोग्राम या एक फ़ंक्शन लिखें जो इनपुट के समान लंबाई की दो गैर-रिक्त सूची लेता है और निम्न कार्य करता है:

संख्यात्मक सूची प्राप्त करने के लिए पहली सूची के तत्वों का उपयोग करता है,
हर सूची के तत्वों का उपयोग करता है, ताकि भाजक प्राप्त कर सकें,
सरलीकरण के बाद परिणामी अंशों को प्रदर्शित करता है (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,
मुद्रण के बजाय आप उपयुक्त स्ट्रिंग वापस कर सकते हैं,
आपको गलत इनपुट को संभालने की आवश्यकता नहीं है,
सबसे छोटा कोड जीतता है ।

code-golf math rational-numbers

मूल्यों का किस सीमा तक समर्थन करना है?

— ब्रैड गिल्बर्ट b2gills

@ ब्रैडगिल्बर्ब 2 जील्स मैं कम से कम -30 000 से 30 000 कहूंगा, लेकिन फिर मुझे नहीं पता कि यह कुछ भाषाओं के लिए अतिरिक्त समस्या होगी। तो शायद अपनी पसंद की भाषा के मानक पूर्णांक रेंज।

@ PrzemysławP ने कहा, "अपनी पसंद की भाषा का मानक पूर्णांक श्रेणी" एक अच्छा विचार नहीं है, कुछ भाषाओं में मानक पूर्णांक बूलियन के रूप में होता है

— फेलिप नार्डी बतिस्ता

धन्यवाद! @ ब्रैडगिल्बर्ब २गिल्स कम से कम -३० ००० से ३० ००० तक।

क्या हम [1, 2] [2, 9] [3, 3] ...इसके बजाय अंश प्राप्त कर सकते हैं ?

— ओलिवियर ग्रेजायर

1

एम , 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.

— डेनिस
स्रोत

मुझे यह पसंद है कि कार्यक्रम का एक चौथाई से अधिक '=' को जोड़ना है। :)

— कॉम्प्यूट्रोनियम

7

रूबी 2.4, 54 53 वर्ण

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

करने के लिए धन्यवाद:

रूबी 2.4 विशिष्ट संस्करण के लिए मूल्य स्याही (-3 अक्षर)
Rationalआरंभीकरण के अनुकूलन के लिए मूल्य स्याही (-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

इसे ऑनलाइन आज़माएं!

— आदमी काम पर है
स्रोत

1

a=n.zip(d).map{|f|(f*?/).to_r};a*?++"=#{a.sum}"रूबी में 2.4 आपको 3 बाइट बचाता है।

— मूल्य स्याही

धन्यवाद @ValueInk मुझे संदेह था कि यह संभव हो सकता है, बस स्थानीय रूप से और न ही टीआईओ पर कोई 2.4 था।

— manatwork

1

हाँ, मैंने 2.4 को विशेष रूप से स्थापित किया है ताकि मैं sumहाहा के साथ समाधान का परीक्षण कर सकूं। इसके अलावा मुझे सिर्फ याद है कि .map{|i,j|i.to_r/j}1 बाइट से छोटी है

— वैल्यू इंक

रवींद्र। मैंने विभिन्न तरीकों के माध्यम से .to_fऔर विभाजन की कोशिश की , लेकिन Rationalसाथ विभाजित करने के लिए नहीं सोचा था Fixnum। धन्यवाद फिर से, @ValueInk

— मैनेटवर्क

6

गणितज्ञ, 33 बाइट्स

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

इनपुट

[{१, २, ३, ३, ६}, {२, ९, ३, २, ४}]

— J42161217
स्रोत

के Row@@{#/#2,"+"}रूप में ही नहीं है Row[#/#2,"+"]?

— फ़ेरसम

हाँ! तुम सही हो!

— J42161217

1

बहुत खुबस! मुझे एहसास नहीं Rowथा कि इस तरह की चीजों के लिए इतना सुविधाजनक था :)

— ग्रेग मार्टिन

3

पायथन 3 , 104 बाइट्स

फेलिप नारदी बतिस्ता के लिए 9 बाइट्स धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

थोड़ा सा गोल्फ

— फेलिप

@FelipeNardiBatista muito।

— लीक नून

बदलने +'='+str(sum(c))के लिए,'=',sum(c)

— फेलिप Nardi बतिस्ता

@FelipeNardiBatista धन्यवाद, यहां भी मैंने पायथन 3 का उपयोग किया है (व्यक्तिगत पसंद के आधार पर)।

— लीक

आप पायथन 2

— ओव

3

पर्ल 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
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

क्लोजर, 71 बाइट्स

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

अंतर्निहित भिन्नों के लिए याय!

— NikoNyrh
स्रोत

2

गणितज्ञ, 61 बाइट्स

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

— alephalpha
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 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]))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

जावा, 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[], प्रासंगिक हैं।

मैंने केविन क्रूज़सेन के जीसीडी फ़ंक्शन का पुन: उपयोग किया ।

इसे देखें और इसे ऑनलाइन टेस्ट करें!

— ओलिवियर ग्रेजायर
स्रोत

2

जूलिया v0.4 +, 66 53 बाइट्स

-13 बाइट्स डेनिस की बदौलत

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

इसे ऑनलाइन आज़माएं!

वैकल्पिक रूप से, यदि भिन्न के //बजाए भिन्नों को प्रदर्शित किया जा सकता है, तो 35 बाइट्स के/ लिए निम्न काम करता है :

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

— जूलियन वुल्फ
स्रोत

2

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जहां आपके द्वारा दो सूचियां सम्मिलित की जाती हैं।

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

नामांकित चर और एनोटेशन के साथ:
_{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);
};

— BlueWizard
स्रोत

क्या होगा अगर #firstList #secondList से अलग है?

— रोजलूपी

आप अलग आकार का मतलब है? प्रश्न में कहा गया है कि पहली सूची का उपयोग एन्यूमरेटर और गलत इनपुट द्वारा किया जा सकता है

— ब्लूव्हेयर

लेकिन इसके अलावा: यदि दूसरी सूची लंबी है, तो शेष प्रविष्टियों को नजरअंदाज कर दिया जाएगा। यदि सूची छोटी है तो रनटाइम त्रुटि होगी।

— ब्लूव्हेल

1

पर्ल 6, 72 बाइट्स 65 बाइट्स

मूल और स्वचालित तर्कसंगत को इसे आसान बनाना चाहिए , लेकिन डिफ़ॉल्ट कड़ेकरण अभी भी दशमलव के रूप में है, इसलिए हमें .nude( नू मेटर और डे नॉमिनेटर ) जो हमारे स्कोर को मारता है और 1 बदसूरत बनाता है :(

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

अद्यतन: हटाए गए कोष्ठक को हटा दें, अधिक स्थान को मारें और स्मार्ट मैप का उपयोग करें। लैम्बडा उप नहीं होने की कीमत पर ब्रैड के समाधान पर पात्रों को बचाता है।

— डीन सीरवी
स्रोत

साइट पर आपका स्वागत है! अच्छा पहला जवाब!

— प्रोग्रामर

1

05AB1E , 35 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

1

जेली , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

1

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

ऑनलाइन संस्करण

के बजाय आउटपुट के return$x/$t."/".$y/$t;साथ प्रतिस्थापन के लिए +14 बाइट्सreturn$y/$t>1?$x/$t."/".$y/$t:$x/$t;nn/1

— जार्ग हुल्सरमन
स्रोत

1

एफ #, 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

इसे ऑनलाइन आज़माएं!

— ब्रूनर
स्रोत

1

setlX , 62 बाइट्स

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

— corvus_192
स्रोत

0

आर, 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स्ट्रिंग के रूप में आवश्यक आउटपुट देता है।

इसे ऑनलाइन आज़माएं! (आर-फिडल लिंक)

— ग्यूसेप
स्रोत

0

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'

— लुइस मेंडो
स्रोत

0

टीआई-बेसिक, 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 हैतार के साथ भयानक है । अगर हम सभी को अंशों को प्रिंट करना था, और फिर उनका योग, कोड होगा:

टीआई-बेसिक, 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 बाइट्स केवल उत्तर को स्वरूपित करने में खर्च होते हैं! हम्फ ।

— स्कॉट मिलनर
स्रोत

0

सी, 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;}

— Khaled.K
स्रोत

0

Axiom, 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

— RosLuP
स्रोत

0

कैसियो बेसिक, 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

— ADDB
स्रोत

0

हास्केल (लैंबडॉट), 94 91 86 बाइट्स

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

इसे ऑनलाइन आज़माएं!

धन्यवाद @Laikoni -8बाइट्स के लिए!

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]

— ბიმო
स्रोत

आपका लापता एक import Data.Ratioके लिए %जो प्रस्तावना में नहीं है।

— लकोनी

1

के "?"++साथ बदलकर आप कुछ बाइट्स बचा सकते हैं '?':।

— लैकोनी

1

छोटा भी काम करता है "/"++dऔर "="++।

— लकोनी

1

tail(f>>=t)++'=':(tail.t.sum)f

— रीयर्रेंजिंग

1

लाना tailऔर =<<में tकुछ और की बचत होती है: यह ऑनलाइन कोशिश करो!

— लकोनी

0

Google शीट, 83 81 बाइट्स

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

_{^{टेलर स्कॉट के लिए 2 बाइट्स बचाए गए}}

सूत्र के अंत में शीट स्वचालित रूप से 2 समापन कोष्ठक जोड़ेगी।

दो सरणियाँ स्तंभों की संपूर्णता के रूप में इनपुट हैं Aऔर B। इनपुट्स के नीचे की खाली पंक्तियाँ त्रुटियों को फेंकेगी।

— इंजीनियर टोस्ट
स्रोत

आपको टर्मिनल को छोड़ने के लिए 2 बाइट्स छोड़ने में सक्षम होना चाहिए))

— टेलर स्कॉट

अंश जोड़ना

उदाहरण:

इनपुट

उत्पादन

नियमों के बारे में

एम , 12 11 बाइट्स

यह काम किस प्रकार करता है

रूबी 2.4, 54 53 वर्ण

रूबी, 58 57 56 वर्ण

गणितज्ञ, 33 बाइट्स

पायथन 3 , 104 बाइट्स

पर्ल 6 , 77 73 बाइट्स

विस्तारित:

क्लोजर, 71 बाइट्स

गणितज्ञ, 61 बाइट्स

जावास्क्रिप्ट (ईएस 6), 111 बाइट्स

जावा, 225 बाइट्स

जूलिया v0.4 +, 66 53 बाइट्स

setlX , 103 बाइट्स

पर्ल 6, 72 बाइट्स 65 बाइट्स

05AB1E , 35 34 बाइट्स

जेली , 31 बाइट्स

PHP> = 7.1, 190 बाइट्स

एफ #, 244 241 239 बाइट्स

setlX , 62 बाइट्स

ungolfed:

आर, 109 बाइट्स

MATL , 32 बाइट्स

व्याख्या

टीआई-बेसिक, 100 बाइट्स

टीआई-बेसिक, 12 बाइट्स

सी, 171 बाइट्स

Axiom, 212 बाइट्स

कैसियो बेसिक, 161 बाइट्स

हास्केल (लैंबडॉट), 94 91 86 बाइट्स

Ungolfed

Google शीट, 83 81 बाइट्स