20

यह समस्या एक प्रश्न से "प्रेरित" है जो मूल रूप से क्वोरा (कोड गोल्फिंग के लिए नहीं) पर पूछा गया था । मैं सिर्फ इसे आप लोगों के लिए एक चुनौती बनाना चाहता हूं (और मेरी पहली समस्या यहां प्रस्तुत करना)।

पूर्णांक तत्वों vऔर पूर्णांक की एक सरणी को देखते हुए d(हम मानते हैं कि डी सरणी की लंबाई के बराबर या कम है), dसरणी में लगातार तत्वों के सभी अनुक्रमों पर विचार करें । प्रत्येक अनुक्रम के लिए, उस अनुक्रम में तत्वों के अधिकतम और न्यूनतम मूल्य के बीच अंतर की गणना करें और इसे विचलन नाम दें।

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो ऊपर दिए गए सभी अनुक्रमों के सभी विचलन के बीच अधिकतम मूल्य की गणना करता है, और उस मूल्य को वापस या आउटपुट करता है।

काम के माध्यम से उदाहरण:

v: (6,9,4,7,4,1)
d: 3

The sequences of length 3 are:
6,9,4 with deviation 5
9,4,7 with deviation 5
4,7,4 with deviation 3
7,4,1 with deviation 6

Thus the maximal deviation is 6, so the output is 6.

यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

— todeale
स्रोत

14

दिल्लोग एपीएल, 7 बाइट्स

⌈/⌈/-⌊/

इसे TryAPL पर टेस्ट करें ।

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

⌈/⌈/-⌊/  Dyadic chain. Left argument: d. Right argument: v

     ⌊/  Reduce v by d-wise minimum, yielding the minima of all slices of length d.
  ⌈/     Reduce v by d-wise maximum, yielding the maxima of all slices of length d.
    -    Subtract, yielding the ranges of all slices of length d.
⌈/       Take the maximum.

— डेनिस
स्रोत

5

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

with(Math)(v,d)=>max(...v.map((a,i)=>max(...a=v.slice(i,i+d))-min(...a)))

— नील
स्रोत

टीआईएल के लिए +1 है कि आप उपयोग कर सकते हैं withएक पूरे लैम्ब्डा समारोह पर

— Bassdrop Cumberwubwubwub

वास्तव में, Uncaught SyntaxError: Unexpected token with। क्या आप वर्किंग स्निपेट पोस्ट कर सकते हैं?

— बैसड्रॉप कंबरवुबवबूब

@BassdropCumberwubwubwub यदि आप लैम्ब्डा का नाम लेना चाहते हैं, तो आपको असाइनमेंट को with(Math)उपयोग या उसके बाद करने की आवश्यकता है f=eval("with(Math)(v,d)=>max(...a)))")।

— नील

4

अजगर, 60 बाइट्स

नील को धन्यवाद देते हुए 5 बाइट्स बचाए

f=lambda v,d:v and max(max(v[:d])-min(v[:d]),f(v[1:],d))or 0

मेरा पहला पुनरावर्ती मेमना!

उपयोग:

print f([6,9,4,7,4,1], 3)

— कार्ल नेफ
स्रोत

1

मुझे लगता है कि आप सिर्फ उपयोग कर सकते हैं v and; यदि आप तत्वों को निकालते हैं तो सीमा ऊपर नहीं जा रही है।

— नील

4

पर्ल, 48 बाइट्स

के लिए +5 शामिल है -0pi

-iविकल्प के बाद चौड़ाई दें , तत्वों को STDIN पर अलग लाइनों के रूप में दें:

perl -0pi3 -e '/(^.*\n){1,$^I}(?{\$F[abs$1-$&]})\A/m;$_=$#F'
6
9
4
7
4
1
^D

बस कोड:

/(^.*\n){1,$^I}(?{\$F[abs$1-$&]})\A/m;$_=$#F

( \nदावा किए गए स्कोर के लिए शाब्दिक उपयोग करें )

— टन हास्पेल
स्रोत

मैं एक रेगीक्स देखता हूं, और फिर मैं खो जाता हूं। 0.0 यहाँ क्या हो रहा है?

— Addison Crump

@VTCAKAVSMoACE मूल रूप से मैं लगातार 1 लाइनों की चौड़ाई से मेल खाता हूं। $&में पूरा मैच होगा जो अंकगणित के संदर्भ में पहले नंबर के रूप में मूल्यांकन करेगा। $1अंतिम संख्या होगी। मैं तो जबरदस्ती के साथ regex विफल \A। तो यह सभी शुरुआती स्थिति और चौड़ाई तक लंबाई की कोशिश करेगा। मैं एक सरणी इंडेक्स के रूप में अंतर का पूर्ण मूल्य का उपयोग करता हूं और देखता हूं कि सरणी कितनी बड़ी हो जाती है। पर्ल का कोई max

— बिल्ड

यह बहुत चालाक है। किसी भी तरह से आप रख सकते हैं -0pi3 -eमें -0pi3e? एक संभावित कमी के बारे में सिर्फ एक धारणा, मैं पर्ल का उपयोग नहीं करता (इस प्रकार मेरा प्रश्न)।

— एडिसन क्रम्प

@VTCAKAVSMoACE दुर्भाग्य से नहीं। -iइसके मूल्य के रूप में इसके बाद सब कुछ खाती है, किसी भीe

— टन हास्पेल

और मैं मान रहा हूं कि -eकोड से ठीक पहले जाना है? ओह।

— एडिसन क्रम्प

4

आर, 63 62 56 बाइट्स

बिलीवोब ने पहले ही आधार कार्यों का उपयोग करके एक शानदार आर उत्तर प्रदान किया है । हालांकि, मैं यह देखना चाहता था कि क्या वैकल्पिक दृष्टिकोण संभव था, शायद आर के कुछ व्यापक पैकेजों का उपयोग करना। किसी ऐरे की रोलिंग विंडो में फंक्शन लागू करने के लिए डिज़ाइन किए गए पैकेज rollapplyमें एक अच्छा फंक्शन है zoo, ताकि हमारे उद्देश्य अच्छी तरह से फिट हो सकें। हम प्रत्येक विंडो rollapplyको खोजने के लिए उपयोग maxकरते हैं, और हम इसे minप्रत्येक विंडो के खोजने के लिए फिर से उपयोग करते हैं। फिर हम अधिकतम और न्यूनतम के बीच अंतर लेते हैं, जो हमें प्रत्येक विंडो के लिए विचलन देता है, और फिर maxउन में से वापस लौटाता है ।

function(v,d)max((r=zoo::rollapply)(v,d,max)-r(v,d,min))

— rturnbull
स्रोत

1

अच्छा, मुझे पता था कि बाद में उत्पन्न करने के लिए एक समारोह था लेकिन यह नहीं मिल सका। इसके अलावा काम पर एक प्रॉक्सी के पीछे तो किसी भी बाहरी पैकेज का उपयोग नहीं कर सकते।

— बिलीवोब

1

कुछ googling ने मुझे बताया कि वहाँ भी है gtools::rolling, लेकिन यह एक और बाइट है और मैं इससे परिचित नहीं हूँ। मैं हमेशा गैर-बेस पैकेजों का उपयोग करने के बारे में दो दिमागों में हूं: एक तरफ, यह आसान समाधान होने पर धोखा देने जैसा लगता है; दूसरी ओर, संकुल (और समुदाय) एक भाषा के रूप में आर की ताकत में से एक है, मुझे लगता है।

— rturnbull

3

आर, 80 77 बाइट्स बाइट्स

संपादित करें: 3 बाइट्स @rturnbull के लिए धन्यवाद सहेजा गया

function(s,d)max(sapply(d:sum(1|s)-d+1,function(i)diff(range(s[i:(i+d-1)]))))

— Billywob
स्रोत

1

आप बदल सकते हैं 1:(length(s)-d+1)के साथ d:sum(1|s)-d+1।

— rturnbull

@rturnbull अच्छा कैच!

— बिलीवोब

2

PowerShell v2 +, 68 बाइट्स

param($v,$d)($v|%{($x=$v[$i..($i+++$d-1)]|sort)[-1]-$x[0]}|sort)[-1]

Iterative समाधान। के माध्यम से लूप्स $v, लेकिन वास्तव में हम वास्तव में मूल्यों के माध्यम से जाने के बजाय काउंटर के रूप में उपयोग कर रहे हैं। प्रत्येक पुनरावृत्ति, हम $vद्वारा कटाई कर रहे हैं $i..($i+++$d-1), जहां $iचूक है 0। हम |sortउन तत्वों को, और परिणाम को स्टोर करते हैं $x। फिर हम सबसे बड़ा लेते हैं और सबसे [-1]छोटे को घटाते हैं [0]। हम फिर |sortउन परिणामों और सबसे बड़ा लेते हैं [-1]। उस नंबर को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(6,9,4,7,4,1) 3
6

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(1,2,3,4,5,6) 3
2

PS C:\Tools\Scripts\golfing> .\find-the-maximum-deviation.ps1 @(7,2,3,4,5,6) 3
5

— AdmBorkBork
स्रोत

2

05AB1E , 12 10 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

Œù€{øÀ`-ÄZ

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

व्याख्या

Œ              # sublists of v
 ù             # of length d
  €{           # sort each
    ø          # zip
     À         # rotate left (last 2 lists will be largest and smallest)
      `        # flatten (lists with smallest and largest item will be on top)
       -       # subtract largest from smallest
        Ä      # take absolute value (as we will have negatives after the previous step)
         Z     # take the largest

— Emigna
स्रोत

2

जावा 8, 140 128

VTCAKAVSMoACE के लिए धन्यवाद, भाग में एक गुच्छा बंद किया।

int l(int[]a,int d){int x=0,i=0,f,j,k;for(;i<=a.length-d;i++)for(j=i;j<i+d;j++)for(k=i;k<i+d;)x=(f=a[j]-a[k++])>x?f:x;return x;}

Ungolfed

int l(int[]a,int d){
    int x=0,i=0,f,j,k;
    for(;i<=a.length-d;i++)
        for(j=i;j<i+d;j++)
            for(k=i;k<i+d;)
                x=(f=a[j]-a[k++])>x?f:x;
    return x;
}

— dpa97
स्रोत

आपको एक अंतिम कोष्ठक याद आ रहा है। ;)

— एडिसन क्रम्प

@VTCAKAVSMoACE उफ़। कॉपी और पेस्ट त्रुटि :(

— dpa97

1

5 बाइट में कमी:

int l(int[]a,int d){int x=0,i=0,f,j,k;for(;i<=a.length-d;i++)for(j=i;j<i+d;j++)for(k=j;k<i+d;)x=(f=a[j]-a[k++])<0?-f:f>x?f:x;return x;}

— एडिसन क्रम्प

@VTCAKAVSMoACE मुझे विश्वास नहीं है कि आपके पास क्या काम होगा- गलत हो सकता है। परीक्षण मामले में 7 और 1 को स्विच करने का प्रयास करें। हालाँकि, मैं इसे अपने नए विचार से दूर करने के लिए उपयोग कर सकता हूँ!

— dpa97

1

मुझे एब्स की आवश्यकता से छुटकारा मिल गया (प्रक्रिया में बहुत बुरा बना रहा है, निश्चित रूप से) के रूप में अच्छी तरह से मैं शुरू करने से। एक ही पंक्ति में x = (f = ...) होने वाली सुंदर निफ्टी ट्रिक, इसके लिए धन्यवाद

— dpa97

2

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

Max[MovingMap[MinMax,#,#2-1].{-1,1}]&

— जंगवान मिन
स्रोत

{-1,1}से बचने के लिए आप डॉट उत्पाद का उपयोग नहीं कर सकते थे Abs?

— मील

@ मीलों धन्यवाद! संपादित उत्तर।

— जंगवान मिन ऑक्ट

@JHM एक बाइट के साथ सहेजा Max[BlockMap[MinMax,#,#2,1].{-1,1}]&।

1

रूबी, 45 बाइट्स

->a,d{a.each_cons(d).map{|b|b.max-b.min}.max}

मुझे लगता है कि यह काफी बेहतर हो सकता है।

— ली डब्ल्यू
स्रोत

1

MATLAB सांख्यिकी और छवि प्रसंस्करण टूलबॉक्स के साथ, 33 बाइट्स

@(v,d)max(range(im2col(v,[1 d])))

यह एक अनाम फ़ंक्शन को परिभाषित करता है। उदाहरण का उपयोग करें:

>> f = @(v,d)max(range(im2col(v,[1 d])));
>> f([6,9,4,7,4,1], 3)
ans =
     6

आप इसे इटवे में ऑक्टेव पर भी आज़मा सकते हैं (लेकिन ऑक्टेव, मैटलैब के विपरीत, छवि पैकेज को स्पष्ट रूप से लोड करने की आवश्यकता है)।

व्याख्या

im2col(v,[1 d]))   % Takes overlapping blocks of size d from v, and arranges them as
                   % columns of a matrix
range(...)         % Maximum minus minimum of each column. Gives a row vector
max(...)           % Maximum of the above row vector

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

1

स्काला, 48 बाइट्स

(_:Seq[Int])sliding(_:Int)map(s=>s.max-s.min)max

Ungolfed:

(a:Seq[Int],d:Int)=>a.sliding(d).map(s=>s.max-s.min).max

स्पष्टीकरण:

(_:Seq[Int])   //define a function with a seq of ints as an argument
sliding(_:Int) //get the sequences with the length of an int argument
map(s=>        //map each sequence
  s.max-s.min    //to its deviation
)max           //and take the maximum value

— corvus_192
स्रोत

1

Matl , 10 बाइट्स

YCS5LY)dX>

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

व्याख्या

उदाहरण के तौर पर [6,9,4,7,4,1], 3 पर विचार करें।

       % Implicitly take the two inputs: v, d
       % STACK: [6,9,4,7,4,1], 3
YC     % Matrix of overlapping d-blocks of v
       % STACK: [6 9 4 7
                 9 4 7 4
                 4 7 4 1]
S      % Sort each column
       % STACK: [4 4 4 1
                 6 7 4 4
                 9 9 7 7]
5LY)   % Keep first and last rows
       % STACK: [4 4 4 1
                 9 9 7 7]
d      % Differences along each column
       % STACK: [5 5 3 6]
X>     % Maximum
       % STACK: 6
       % Implicitly display

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

1

दरअसल , 13 बाइट्स

╗╜@V`;m@M-`MM

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

N6 के हास्केल उत्तर में अवलोकन से -6 बाइट्स , जो कि कम से कम स्लाइस dअधिकतम विचलन को प्रभावित नहीं करते हैं।

स्पष्टीकरण:

╗╜@V`;m@M-`MM
╗              store d in register 0
 ╜@            push d, swap so v is on top
   V           push all slices of v whose length is in [1, d]
    `;m@M-`M   map (for each slice):
     ;m@M-       get minimum and maximum, subtract min from max
           M  get maximum of list of deviations

— मै जाऊं
स्रोत

1

PHP, 89 87 बाइट्स

for($i=1;$r=array_slice($argv,++$i,$argv[1]);$d=max($r)-min($r))$o=$d>$o?$d:$o;echo+$o;

विशेष रूप से चतुर या सुंदर नहीं है, लेकिन यह काम करता है। जैसे उपयोग करें:

php -r "for($i=1;$r=array_slice($argv,++$i,$argv[1]);$d=max($r)-min($r))$o=$d>$o?$d:$o;echo+$o;" 3 6 9 4 7 1

के लिए v= 6,9,4,7,4,1,d =3

संपादित करें: 2 बाइट्स ने हॉर्ग्समैन को धन्यवाद दिया

— user59178
स्रोत

echo+$o;की जगहecho$o?:0;

— Jörg Hülsermann

0

सीजेएम , 17 बाइट्स

q~ew{$)\(\;-}%:e>

(इसके अलावा q~ew:$z)\(\;.-:e>)

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

व्याख्या

q~                   e# Read the two inputs. Evaluate
  ew                 e# Overlapping blocks
    {       }%       e# For each block
     $               e# Sort
      )              e# Get last element (that is, maximum)
       \(            e# Swap, get first element (minimum)
         \;          e# Swap, delete rest of the block
           -         e# Subtract (maximum minus minimum)
              :e>    e# Maximum of array

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

0

जावा 7,159 बाइट्स

जावा = महंगा (मुझे पता है कि यह बहुत अधिक गोल्फ हो सकता है)

int c(int[]a,int d){int[]b=new int[d];int i,j,s=0;for(i=-1;i<a.length-d;){for(j=++i;j<i+d;)b[i+d-1-j]=a[j++];Arrays.sort(b);s=(j=b[d-1]-b[0])>s?j:s;}return s;}

Ungolfed

static int c ( int []a , int d){
    int []b = new int[ d ];
    int i , j , s = 0 ;
    for ( i = -1 ; i < a.length - d ;) {
        for ( j = ++i ; j < i + d ;)
        b[ i + d - 1 - j ] = a[ j++ ] ;
        Arrays.sort( b ) ;
        s = ( j = b[ d - 1 ] - b[ 0 ] ) > s ? j : s ;
    }
    return s ;
    }

— Numberknot
स्रोत

0

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

_#[]=0 
d#l|m<-take d l=max(maximum m-minimum m)$d#tail l

प्रयोग उदाहरण: 3 # [6,9,4,7,4,1]-> 6।

सीमाओं को ध्यान में रखते तुलना में कम dसमग्र अधिकतम परिवर्तन नहीं होता है, तो हम चला सकते हैं take dसूची के एकदम अंत करने के लिए नीचे (यानी भी साथ पिछले पर्वतमाला शामिल d-1, d-2... 0तत्व)। खाली सूची के साथ पुनरावृत्ति रुक जाती है जहां हम विचलन सेट करते हैं 0।

— nimi
स्रोत

0

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

मुझे dpa97 के उत्तर से प्रेरणा मिली और यह पाया:

int f(int v[],int d){int m=0,i=0,j,t,l=v.length;for(;i<l;i++)for(j=i;j<l;j++)m=j-i<d&&(t=Math.abs(v[i]-v[j]))>m?t:m;return m;}

विस्तारित, गोल्फ और उदाहरण कोड

— AlexRacer
स्रोत

0

रैकेट 121 बाइट्स

(let p((v v)(j 0))(let*((l(take v d))(k(-(apply max l)(apply min l)))
(j(if(> k j)k j)))(if(= d(length v))j(p(cdr v)j))))

Ungolfed:

(define (f d v)
  (let loop ((v v)
             (mxdev 0))                     ; start with max deviation as 0
    (let* ((l (take v d))                   ; take initial d elements in v
           (dev (- (apply max l)            ; find deviation
                    (apply min l)))
           (mxdev (if(> dev mxdev)          ; note max deviation
                   dev
                   mxdev)))
      (if (= d (length v)) mxdev            ; if all combinations tested, print max deviation
          (loop (rest v) mxdev))            ; else test again 
      )))                                   ; with first element of list removed

परिक्षण:

(f 3 '(6 9 4 7 4 1))

आउटपुट:

— rnso
स्रोत

0

क्यू, 25 बाइट्स

{max mmax[y;x]-mmin[y;x]}

mmaxऔर mminक्रमशः खिड़की की अधिकतम और न्यूनतम स्लाइडिंग कर रहे हैं

उदाहरण

q){max mmax[y;x]-mmin[y;x]}[6 9 4 7 4 1;3]
6

— skeevey
स्रोत

0

सी #, 131 बाइट्स

यहाँ एक क्रिया linq समाधान है

int c(int[]a){var x=from j in Enumerable.Range(0,a.Length-2)let p=new[]{a[j],a[j+1],a[j+2]}select p.Max()-p.Min();return x.Max();}

— downrep_nation
स्रोत

0

सी #, 163 बाइट्स

golfed:

int m(List<int> v,int d){var l=new List<List<int>>();for(int i=0;i<v.Count;i++){if(v.Count-i>=d)l.Add(v.GetRange(i,d));}return l.Select(o=>o.Max()-o.Min()).Max();}

Ungolfed:

public int m(List<int> v, int d)
{
  var l = new List<List<int>>();

  for (int i = 0; i < v.Count; i++)
  {
    if (v.Count - i >= d)
      l.Add(v.GetRange(i, d));
  }

  return l.Select(o => o.Max() - o.Min()).Max();
}

परीक्षा:

var maximumDeviation = new MaximumDeviation();
Console.WriteLine(maximumDeviation.f(new List<int> {6,9,4,7,4,1}, 3));

आउटपुट:

— पीट आर्डेन
स्रोत

0

अजगर, 11 बाइट्स

eSms.+Sd.:F

व्याख्या

eSms.+Sd.:FQ   Implicit input
          FQ   Unpack the input (v, d)
        .:     Get all subsequences of length d
  m   Sd       Sort each
   s.+         Take the sum of differences to get the deviation
eS             Get the maximum

0

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

ṡµṂ€ạṀ€Ṁ

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

Dyalog APL के समान एल्गोरिथ्म का उपयोग करता है, लेकिन मैंने इसे देखने से पहले खुद को समझा।

स्पष्टीकरण:

ṡµṂ€ạṀ€Ṁ ḷ“Main link. Arguments: v d.”
ṡ        ḷ“Overlapping sublists of x of length y.”
 µ       ḷ“Start a new monadic chain.”
  Ṃ€ạṀ€  ḷ“Find the deviation of each of the elements of x.”
       Ṁ ḷ“Take the maximum of x.”

नोट: x, yछोड़ दिया जाता है, सही तर्क क्रमशः।

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

0

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

{$^a.rotor($^b=>1-$^b).map({.max-.min}).max}

$^aऔर समस्या बयान में क्रमशः और $^bकहा जाने वाले कार्य के दो तर्क हैं । विधि के subsequences के अनुक्रम रिटर्न आकार की ।vdrotorvd

— शॉन
स्रोत

0

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

संपादित करें: के #(...)बजाय (fn[...])और के forबजाय का उपयोग करना map।

#(apply max(for[p(partition %2 1 %)](-(apply max p)(apply min p))))

— NikoNyrh
स्रोत

0

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

lambda v,d:max(map(lambda g:max(g)-min(g),[v[i:i+d]for i in range(-~len(v)-d)]))

— Cormac
स्रोत

आप के (max(v[i:i+d])-min(v[i:i+d])for i in range(-~len(v)-d)बजाय का उपयोग कर सकते हैंmap(lambda g:max(g)-min(g),[v[i:i+d]for i in range(-~len(v)-d)])

— गेहूं जादूगर

अधिकतम विचलन ज्ञात कीजिए

दिल्लोग एपीएल, 7 बाइट्स

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

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

अजगर, 60 बाइट्स

पर्ल, 48 बाइट्स

आर, 63 62 56 बाइट्स

आर, 80 77 बाइट्स बाइट्स

PowerShell v2 +, 68 बाइट्स

उदाहरण

05AB1E , 12 10 बाइट्स

जावा 8, 140 128

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

रूबी, 45 बाइट्स

MATLAB सांख्यिकी और छवि प्रसंस्करण टूलबॉक्स के साथ, 33 बाइट्स

व्याख्या

स्काला, 48 बाइट्स

Matl , 10 बाइट्स

व्याख्या

दरअसल , 13 बाइट्स

PHP, 89 87 बाइट्स

सीजेएम , 17 बाइट्स

व्याख्या

जावा 7,159 बाइट्स

Ungolfed

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

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

रैकेट 121 बाइट्स

क्यू, 25 बाइट्स

सी #, 131 बाइट्स

सी #, 163 बाइट्स

अजगर, 11 बाइट्स

व्याख्या

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

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

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

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