निम्नलिखित त्रिकोण पर विचार करें।

1
23
456
7891
01112
131,415
1617181
92021222
324252627
2829303132
33343536373
839404142434
4454647484950
51525354555657
585960616263646
5666768697071727
37475767778798081

जैसा कि आपने शायद देखा, पहली पंक्ति 1 लंबाई की है, और उसके बाद प्रत्येक पंक्ति पिछले एक की तुलना में 1 अंक लंबी है और इसमें समवर्ती पूर्णांक के सकारात्मक अंक हैं।

आपको एक पूर्णांक N दिया जाएगा । आपका कार्य उन अंकों का योग खोजना है जो उपरोक्त त्रिभुज की N वीं पंक्ति पर स्थित हैं।

नियम

आप या तो 0 या 1 अनुक्रमण चुन सकते हैं। कृपया अपने उत्तर में निर्दिष्ट करें।
डिफ़ॉल्ट ढीले लागू होते हैं।
आप इनपुट ले सकते हैं और किसी भी मानक माध्यम से और किसी भी उचित प्रारूप में आउटपुट प्रदान कर सकते हैं ।
यह OEIS A066548 है , और यह अनुक्रम स्वयं त्रिभुज है (सिवाय इसके कि हम अग्रणी शून्य को नहीं हटाते हैं)।
यह कोड-गोल्फ है , इसलिए बाइट्स (हर भाषा में) में सबसे छोटा कोड जीतता है। मज़ा गोल्फ है!

परीक्षण के मामलों

Input  |  Output

0  |  1
1  |  5
2  |  15
3  |  25
4  |  5
5  |  15
6  |  25
7  |  20
8  |  33
9  |  33
10 |  43
11 |  46
12 |  64

ध्यान दें कि उपरोक्त 0-अनुक्रमित हैं। यदि आप 1-अनुक्रमित परीक्षण मामलों की तलाश कर रहे हैं, तो 1 से इनपुट बढ़ाएँ।

_{काफी असंबंधित नोट पर, मैंने हाल ही में अपनी प्रोफ़ाइल तस्वीर बदल दी और इसने मुझे इस चुनौती को लिखने के लिए प्रेरित किया।}

— श्री एक्सकोडर
स्रोत

8

भूसी , 7 बाइट्स

1 अनुक्रमित

Σ!CNṁdN

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

व्याख्या

    ṁ     Map then concatenate
     d    Integer digits
      N   Over the natural numbers
  CN      Cut into lists of lengths corresponding to the natural numbers
 !        Index it
Σ         Sum

— H.PWiz
स्रोत

4

अजगर २ , 69 बाइट्स

यह शायद काफी कम हो सकता है।

1 अनुक्रमित

संपादित करें: -7 बाइट्स @ Mr.Xcoder का धन्यवाद

lambda n:sum(map(int,"".join(map(str,range(1,n*n+1)))[~-n*n/2:][:n]))

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

— हलवार्ड वुल्फ
स्रोत

1

n**2है n*n।

— श्री एक्सकोडर

69 बाइट्स । गॉस के फॉर्मूले का उपयोग करते हुए,sum(range(n)) = ~-n*n/2 = (n - 1) * n / 2

— श्री एक्सकोडर

1

@ Mr.Xcoder मुझे लगता है कि वह करता है ...

— 21

@EriktheOutgolfer आप सही कह रहे हैं, मेरा बुरा

— श्री एक्सकोडर

3

हास्केल , 57 बाइट्स

f n=sum[read[d]|d<-take n$drop(div(n*n-n)2)$show=<<[1..]]

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

— Laikoni
स्रोत

3

05AB1E , 8 बाइट्स

nLS¹L£θO

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

-1 Emigna को धन्यवाद ।

1-अनुक्रमण।

— आउटगोल्फ को एरिक करें
स्रोत

Sयदि आप के Jसाथ प्रतिस्थापित आप अपने को हटा सकते हैं S।

— एमिग्ना

@ इग्नू दुह ....

— आउटगॉल्फ

3

पर्ल 6 , 47 45 42 बाइट्स

{[~](1..$_²).substr(:1[^$_],$_).comb.sum}

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

1 अनुक्रमित

— nwellnhof
स्रोत

2

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

(d=Flatten[IntegerDigits/@Range[#^2]];Last@Table[Tr@Take[d,{i(i+1)/2+1,(i+1)(i+2)/2}],{i,0,#}])&

इसे ऑनलाइन आज़माएं! (गणित पर काम करने के लिए "Tr" को "Total" से बदलना होगा)

— J42161217
स्रोत

2

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

²RDFṁRS$ṫCS

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

1-आधारित अनुक्रमण का उपयोग करता है।

व्याख्या

²RDFṁRS$ṫCS  Input: n
²            Square
 R           Range, [1, n^2]
  D          Decimal digits
   F         Flatten
    ṁ        Reshape to
       $     Monadic chain
     R         Range, [1, n]
      S        Sum
        ṫ    Tail
         C   Complement, 1-n
          S  Sum

— मील की दूरी पर
स्रोत

2

हास्केल, 69 64 बाइट्स

n%x=sum[read[d]|d<-take n x]:(n+1)%drop n x
f=(1%(show=<<[1..])!!)

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

लाईकोनी के लिए धन्यवाद 5 बाइट्स बचाए !

यहाँ कम गोल्फ वाला संस्करण है:

-- continuous stream of digits representing
-- the concatenation of positive integers in
-- order: 1234567891011...
digitstream = show=<<[1..]

-- sequence that yields the rows of the triangle
triangle n xs |(a,b)<-splitAt n xs=a:triangle(n+1)b

digitSum xs = sum[read[d]|d<-xs]

-- sequence that sums up the digits in each row
rowSumSequence = map digitSum (triangle 1 digitstream)

-- the final function that just shows the value 
-- at a given index
g=(rowSumSequence!!)

— क्रिस्टियन लुपस्कू
स्रोत

n%x=sum[read[d]|d<-take n x]:(n+1)%drop n xकुछ बाइट्स कम है।

— लकोनी

@ लायकोनी धन्यवाद! संपादित। मुझे नहीं पता कि मैंने क्यों सोचा कि splitOnबाइट्स बचाएंगे।

— क्रिस्टियन लुपस्क्यू

2

आर, 119 109 108 93 88 बाइट्स

गोल्फ के लिए शुरू .... 1-अनुक्रमित

function(n){for(i in 1:n+n*(n-1)/2){F=F+strtoi(substr(paste(1:n^2,collapse=""),i,i))};F}

धन्यवाद @Zachary आपका अनुमान सही है :) मुंडा 1 बाइट tnx को @Aririus और 15 अधिक tnx को @ user2315246

@ गुइसेप्पे - स्ट्रेटी के लिए tnx। मेरे लिए नया है। 5 बाइट्स नीचे :)

— ज़ाहिरो मोर
स्रोत

2

मुझे नहीं लगता कि आपको इसकी आवश्यकता है y=, और न ही आसपास के परिजनों की n*(n-1)/2+1, और भाषा का नाम संभवतः नहीं है [R]।

— Zacharý

1

आप को बदलने के द्वारा 1 बाइट बचा सकता है as.integerके साथas.double

— AndriusZ

1

इसके बजाय x, उपयोग के Fरूप में यह पहले से ही 0.

— user2390246

1

भी, के 1:n+a-1रूप में ही देता है a:(a+n-1)। उस स्थिति में, आपको aपहले से परिभाषित करने की आवश्यकता नहीं है , आप इसे सीधे forअभिव्यक्ति में डाल सकते हैं । यह आपको + 1 / -1 को रद्द करने की भी अनुमति देगा।

— user2390246

2

79 बाइट्स । substringइसके बजाय इसका इस्तेमाल substrवास्तव में घटिया वस्तुओं के सूचकांकों पर किया गया एक योग है। इसके अलावा, आपके समाधान :) +1, महान काम के लिए TIO लिंक को शामिल करना हमेशा अच्छा होता है।

— ग्यूसेप

2

इमोजीकोड , 182 बाइट्स

🐖©a🚂➡🚂🍇🍦l➗✖a➕a 1 2🍮t🔤🔤🍮i 0🔁▶l🐔t🍇🍮➕i 1🍮t🍪t🔡i 10🍪🍉🍮s 0🔂g🔪t➖l a a🍇🍮➕s 🍺🚂🔡g 10🍉🍎s🍉

एक विधि को परिभाषित करता है जिसे © कहा जाता है जो 🚂 लेता है और एक © देता है। 1 अनुक्रमित।

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

स्पष्टीकरण:

ध्यान दें: इमोजी पसंद का बहुत कुछ इमोजीकोड 0.5 में बहुत मायने नहीं रखता है। यह 0.x है, सब के बाद। 0.6 इसे ठीक कर देगा, इसलिए यदि आप इसे सीखना चाहते हैं (क्योंकि जो नहीं करना चाहते हैं), मैं एक पल प्रतीक्षा करने की सलाह देता हूं।

इमोजीकोड एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज है जिसमें जेनरिक, प्रोटोकॉल, ऑप्शंस और क्लोजर शामिल हैं, लेकिन यह प्रोग्राम बिना क्लोजर का उपयोग करता है, और सभी जेनरिक और प्रोटोकॉल को अंतर्निहित माना जा सकता है।

कार्यक्रम केवल कुछ प्रकारों पर संचालित होता है: ger पूर्णांक प्रकार है और type स्ट्रिंग प्रकार है। इसके अतिरिक्त 👌s परिस्थितियों में दिखाई देते हैं, जो true (सत्य) या 👌 (गलत) का मान ले सकते हैं।

वर्तमान में Emojicode में कोई ऑपरेटर नहीं हैं, इसलिए इसके अलावा, संकलन और अन्य संचालन जो सामान्य रूप से ऑपरेटर हैं, कार्यों के रूप में कार्यान्वित किए जाते हैं, प्रभावी ढंग से अभिव्यक्तियों को उपसर्ग संकेतन का उपयोग करते हैं । ऑपरेटरों को भी 0.6 में योजना बनाई गई है।

🐖©a🚂➡🚂🍇

 🍦l➗✖a➕a 1 2

एक lत्रि-त्रिकोणीय संख्या (उपसर्ग संकेतन में सूत्र ) के बराबर एक जमे हुए ("स्थिर") की घोषणा करें । यह संख्याओं की स्ट्रिंग की लंबाई को दर्शाता है जो हमें उत्पन्न करने की आवश्यकता है।

 🍮t🔤🔤

चर के लिए एक खाली स्ट्रिंग असाइन करें t।

 🍮i 0

असाइन करें i = 0।

 🔁▶l🐔t🍇

जबकि की lलंबाई से अधिक हैt

  🍮➕i 1

i += 1

  🍮t🍪t🔡i 10🍪

iआधार 10 से पाठीय निरूपण में संलग्न करें t।

 🍉

अंत लूप

 🍮s 0

असाइन s = 0

 🔂g🔪t➖l a a🍇

(सभी त्रिभुजाकार संख्या) की लंबाई का tप्रारंभ का एक विकल्प लें , सभी वर्णों पर पुनरावृतिl - aa - 1

  🍮➕s 🍺🚂🔡g 10

चरित्र को स्ट्रिंग में परिवर्तित करें, आधार -10 में पूर्णांक को पार्स करें, वैकल्पिक को खोल दें (यदि स्ट्रिंग संख्या नहीं है तो कुछ भी नहीं लौटाया जाता है) और sचर में जोड़ें ।

 🍉

अंत लूप

 🍎s

वापस लौटें

🍉

अंतिम विधि।

— NieDzejkob
स्रोत

1

PHP, 66 + 1 बाइट्स

for($p=($n=$argn)*-~$n/2;$n--;)$r+=join(range(1,$p))[--$p];echo$r;

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

अभिव्यक्ति को अनुक्रमित करने के लिए PHP 5.4 या बाद के संस्करण की आवश्यकता है।

— टाइटस
स्रोत

1

पायथ, 24 बाइट्स

u+GsH<>jkS+*QQ2/*QhQ2hQ0

इसे यहाँ आज़माएँ: http://pyth.herokuapp.com/

— करण इलांगोवन
स्रोत

1

एपीएल, 28 26 25 बाइट्स

{+/⍎¨⍵↑⌽(+/⍳⍵)↑∊,/⍕¨⍳⍵×⍵}

1-आधारित अनुक्रमण का उपयोग करता है

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

कैसे?

⍳⍵×⍵, इनपुट के माध्यम से 1 चुकता
⍕¨, प्रत्येक तत्व को एक स्ट्रिंग में बदल दें
∊,/, उन्हें एक साथ मिलाना
(+/⍳⍵)↑, इनपुट तक पंक्तियों को पकड़ो
⍵↑⌽, वांछित पंक्ति को पकड़ो
⍎¨, प्रत्येक तत्व को एक संख्या में बदल दें
+/, योग

— जाकारी
स्रोत

1

क्लोजर v1.8, 154 बाइट्स

1 अनुक्रमित

(fn[n](loop[i 1 s(clojure.string/join""(take(* n n)(iterate inc 1)))](if(= i n)(apply +(map #(Character/digit % 10)(take n s)))(recur(inc i)(subs s i)))))

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

व्याख्या

(take(* n n)(iterate inc 1))  Take the first N*N numbers
(clojure.string/join""...)    Combine them into a string
(loop[i 1 ...](if(= i n)...)  Loop N times
(apply +(map #(Character/digit % 10)(take n s)))  Take N characters from the string, convert to integers and add them
(recur(inc i)(subs s i))      Increment iterator, remove i characters from string

— क्रिस
स्रोत

1

जावा 8, 116 98 बाइट्स

n->{String t="";int r=0,i=0;for(;i++<n*n;t+=i);for(i=0;i<n;r+=t.charAt(i+++~-n*n/2)-48);return r;}

1 अनुक्रमित

-18 बाइट्स थैंक्स टू @ नवे

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

n->{                             // Method with integer as both parameter and return-type
  String t="";                   //  Triangle-String
  int r=0,                       //  Result-integer
      i=0;                       //  Index-integer
  for(;i++<n*n;                  //  Loop (1) from 0 to `n^2` (exclusive)
    t+=i                         //   And append String `t` with all the numbers
  );                             //  End of loop (1)
  for(i=0;i<n;                   //  Loop (2) from 0 to `n` (exclusive)
    r+=t.charAt(i+++~-n*n/2)-48  //   And raise the sum `r` by the digits
  );                             //  End of loop (2)
  return r;                      //  Return the resulting sum of digits
}                                // End of method

— केविन क्रूज़सेन
स्रोत

1

98 बाइट्स: n->{String r="";int i=0,x=0;for(;x++<n*n;r+=x);for(x=0;x<n;)i+=r.charAt(x+++~-n*n/2)-48;return i;}।

— नेवई

1

आर, 99 , 105 , 97 बाइट्स

a=diag(N<-scan());a[upper.tri(a,T)]=strtoi(strsplit(paste(1:N^2,collapse=""),"")[[1]]);sum(a[,N])

1 अनुक्रमित

ungolfed संस्करण

a <- diag(N<-scan())
a[upper.tri(a, diag=TRUE)] <- strtoi(strsplit(paste(1:N^2, 
                                                  collapse=""),
                                            "")[[1]])
sum(a[,N])

यहाँ यह कोशिश करो!

8 बाइट बचाने के लिए @Giuseppe का धन्यवाद

— AndriusZ
स्रोत

वर्णन में @Giuseppe का उल्लेख किया गया है: "आपको एक पूर्णांक एन दिया जाएगा।" और यह एन मेरे समाधान में उपयोग किया जाता है। या हो सकता है कि मैंने कुछ गलत समझा हो।

— एंड्रियसजज

विवरण में लिंक किए गए "किसी भी मानक मतलब" को देखें :)

— Giuseppe

@Giuseppe परिवर्तित करें और अपने सुझाव के बारे मेंstrtoi

— AndriusZ

1

चेतावनी संदेश के साथ 97 बाइट्स । अपने विवरण में TIO का लिंक शामिल करना हमेशा अच्छा होता है, ताकि अन्य इसका परीक्षण कर सकें!

— ग्यूसेप

@Giuseppe मुझे कोई आर नहीं पता, लेकिन शायद एक फ़ंक्शन कम बाइट्स का उपयोग करेगा?

— 15 अक्टूबर को NieDzejkob

1

पर्ल 6 , 44 बाइट्स

{[+] (1..*).flatmap(*.comb).rotor(1..*)[$_]}

झसे आज़माओ

विस्तारित:

{
  [+]        # reduce the result of the following using &infix«+»

  ( 1 .. * ) # infinite range starting at 1

  .flatmap(  # map, then flatten
    *.comb   # split into digits (100 ⇒ 1,0,0)
  )

  .rotor(    # break the sequence into pieces
    1 .. *   # start with 1 value, then 2 values, then 3, etc.
  )\

  [$_]       # index into that infinite sequence
}

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

0

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

Ṭ€Ẏ0;œṗ²D€Ẏ$$⁸ịS

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

1 अनुक्रमित।

— आउटगोल्फ को एरिक करें
स्रोत

0

SOGL V0.12 , 15 13 बाइट्स

²Δr∑.δ∑⌡kmčr∑

यह कोशिश करो!
1 अनुक्रमित।

इस पर काम करते हुए मैंने एक बग तय किया जो बनाया गया था ∑ संख्या सरणियों पर काम नहीं करता था और यह mगलत तरीके से निहित इनपुट ले लिया था।

स्पष्टीकरण:

²              square the input
 Δ             get a range from 1 to that
  r∑           join as a string
    .δ         create a range 0 - input-1
      ∑        sum that
       ⌡       that many times do
        k        remove the 1st character of the joined string
         m     mold to the length of the input
          č    chop into characters
           r∑  convert to numbers and sum

— dzaima
स्रोत

0

सी ++, 180 बाइट्स

-17 बाइट्स Zacharý को धन्यवाद

सूचकांक 1 पर शुरू होता है

#include<string>
int s(int n){std::string t;int i=0,p=0;for(;i<=n;)p+=i++;for(i=0;t.size()<p;t+=std::to_string(++i));t=t.substr(0,p).substr(p-n);i=0;for(auto&a:t)i+=a-48;return i;}

— HatsuPointerKun
स्रोत

अंतिम पंक्ति को बदलने से दो बाइट

int s(int n){++n;std::string t;int i=0,p=0;for(;i<=n;)p+=i++;for(i=0;t.size()<p;t+=std::to_string(++i));t=t.substr(0,p);t=t.substr(t.size()-n);i=0;for(auto&a:t)i+=a-48;return i;}

— बचनी

इसके अलावा, यदि आप वर्तमान में 0-अनुक्रमित के रूप में इनपुट ले रहे हैं, तो आप इसे 1-इंडेक्स में बदल सकते हैं और ++n;

— Zacharý

@ Zacharý धन्यवाद। Btw, आपके कोड में कुछ कारणों से अदृश्य यूनिकोड चरित्र है

— HatsuPointerKun

कौन सा, मेरा सी ++ सुझाव, या मेरा एपीएल? एपीएल अपने स्वयं के कोडपेज का उपयोग करता है, और यदि आपके पास सही फ़ॉन्ट नहीं है, तो संभवतः सही नहीं दिखाएगा।

— Zacharý

@ Zacharý C ++ सुझाव जो आपने टिप्पणी में लिखा है। एक शून्य से पहले 2 यूनिकोड वर्णों की तरह है, जिससे "0" identifier is unknownदृश्य स्टूडियो की तरह त्रुटियां होती हैं । to_stringऔर के लिए एक ही बात है size। आप इसे देख सकते हैं यदि आप कोड को नोटपैड ++ में कॉपी-पेस्ट करते हैं, और एन्कोडिंग को एएनएसआई में परिवर्तित करते हैं, तो आप ??संपादक में कुछ देखेंगे

— HatsuPointerKun

0

पायथ , 15 14 13 बाइट्स

s<>sMjkS^Q2sU

यहाँ यह कोशिश करो! या परीक्षण सूट की जाँच करें।

13 बाइट्स विकल्प:

ssM<>jkS^Q2sU
ssM<>jkS*QQsU
s<>sMjkS^Q2sU

कैसे?

s<>sMjkS^Q2sU    Full program. Q means input.

       S^Q2      The range [1, Q^2].
     jk          Join as a String.
   sM            Convert each character to integer.
  >              All the elements of the above, but the first Q*(Q-1)/2.
 <               All the element of the above but the last Q.
s                Sum.
                 Output implicitly.

— श्री एक्सकोडर
स्रोत

0

> <>, 141 + 2 बाइट्स

::1+* 2,01\
@}})?/:0$\>$:@{{:
:%a:/?(1:< ,a-]{+1[4
  /~/     \+1~\
1:<]{+1[+4@:-1\?(
{1-}>{:}1(?\@1-@+
    \0}~{{\\n;
@:{{:<-1~$\!?)}}
     ~

1-इंडेक्स्ड

+ 2 बी -v ध्वज के लिए

Tio.run वास्तव में मेरे> <> कार्यक्रमों को हाल ही में पसंद नहीं करता ... यह अभी भी https://fishlanguage.com पर सत्यापित किया जा सकता है । इनपुट 'प्रारंभिक स्टैक' में जाता है।

संपादित करें: यह tio.run को पसंद नहीं करता क्योंकि यह '[' और ']' को अलग से fishlanguage.com को संभालता है। fishlanguage.com नया स्टैक बनाते या निकालते समय स्टैक को उलट देता है, लेकिन tio.run नहीं करता है।

— साशा
स्रोत

0

पर्ल 5 , 62 + 1 (-पी) = 63 बाइट्स

$_=eval(substr((join'',1..$_*$_),($_**2-$_)/2,$_)=~s/./+$&/gr)

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

परिणाम 1 अनुक्रमित है।

कैसे?

एक साथ पर्याप्त से अधिक अंकों को समेटें, फिर शुरुआत में अप्रासंगिक वाले को छोड़ें (स्किप की लंबाई 1 से पूर्णांक का योग है n-1)। अगले nअंक लें , +प्रत्येक के सामने एक जगह रखें , फिर उस समीकरण का मूल्यांकन करें।

— Xcali
स्रोत

0

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

f=
n=>eval([...(g=n=>n?g(n-1)+n:``)(n*n).substr(n*~-n/2,n)].join`+`)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

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

1 अनुक्रमित। संपादित करें: @ बाइट के लिए धन्यवाद 13 बाइट्स सहेजे गए।

— नील
स्रोत

n=>eval([...(g=n=>n?g(n-1)+n:'')(n*n)].join<+>.substr(~-n*n-1,2*n))

— tsh

@tsh स्टिल गोल्फर join`+` अंत में डाल दिया ...

— नील

समवर्ती त्रिकोण की पंक्तियों को जोड़ो

नियम

परीक्षण के मामलों

भूसी , 7 बाइट्स

व्याख्या

अजगर २ , 69 बाइट्स

हास्केल , 57 बाइट्स

05AB1E , 8 बाइट्स

पर्ल 6 , 47 45 42 बाइट्स

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

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

व्याख्या

हास्केल, 69 64 बाइट्स

आर, 119 109 108 93 88 बाइट्स

इमोजीकोड , 182 बाइट्स

PHP, 66 + 1 बाइट्स

पायथ, 24 बाइट्स

एपीएल, 28 26 25 बाइट्स

कैसे?

क्लोजर v1.8, 154 बाइट्स

व्याख्या

जावा 8, 116 98 बाइट्स

आर, 99 , 105 , 97 बाइट्स

पर्ल 6 , 44 बाइट्स

विस्तारित:

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

SOGL V0.12 , 15 13 बाइट्स

सी ++, 180 बाइट्स

पायथ , 15 14 13 बाइट्स

कैसे?

> <>, 141 + 2 बाइट्स

पर्ल 5 , 62 + 1 (-पी) = 63 बाइट्स

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