23

एक पैलिंड्रोम एक ऐसा शब्द है जो अपने आप में उल्टा है।

अब कुछ शब्द ऐसे हैं जो शायद पलिंड्रोम्स की तरह दिखते हैं लेकिन हैं नहीं। उदाहरण के लिए शब्द पर विचार करें sheesh, sheeshएक पैलिंड्रोम नहीं है क्योंकि इसका रिवर्स hseehsअलग है, हालांकि अगर हम shएक अक्षर मानते हैं , तो यह रिवर्स है sheesh। इस तरह के शब्द को हम सेमी-पालिंड्रोम कहेंगे।

विशेष रूप से एक शब्द एक अर्ध-ताल है यदि हम शब्द को कुछ संख्या में विखंडित कर सकते हैं जैसे कि जब विखंडू का क्रम उलट जाता है तो मूल शब्द बनता है। ( sheeshउन विरामों के लिए sh e e sh) हमें यह भी आवश्यक होगा कि किसी भी चंक में शब्द के दोनों हिस्सों से पत्र न हों (अन्यथा हर शब्द एक अर्ध-तालमेल होगा)। उदाहरण के लिए rearएक अर्ध-ताल नहीं है क्योंकि r ea rइसमें एक चंक ( ea) है जिसमें मूल शब्द के दोनों ओर से अक्षर हैं। हम एक विषम लंबाई वाले शब्द में केंद्रीय वर्ण को शब्द के दोनों ओर नहीं मानते हैं, इस प्रकार विषम लंबाई वाले शब्दों के लिए केंद्र वर्ण हमेशा अपने आप में होना चाहिए।

आपका कार्य सकारात्मक पूर्णांक की एक सूची लेना और यह निर्धारित करना होगा कि क्या वे एक अर्ध-तालमेल हैं। आपके कोड को दो लगातार असमान मूल्यों का उत्पादन करना चाहिए, एक यदि इनपुट एक अर्ध-तालमेल है और दूसरा अन्यथा। हालाँकि आपके कोड का बाइट क्रम एक अर्ध-तालमेल ही होना चाहिए ।

उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

[] -> True
[1] -> True
[2,1,2] -> True
[3,4,2,2,3,4] -> True
[3,5,1,3,5] -> True
[1,2,3,1] -> False
[1,2,3,3,4,1] -> False
[11,44,1,1] -> False
[1,3,2,4,1,2,3] -> False

अधिक वृषण उत्पन्न करने के लिए कार्यक्रम।

बोरिस ने बताया कि ये सामान्यीकृत स्मरंडचे पलिंड्रोम्स के समान हैं । इसलिए यदि आप कुछ और पढ़ना चाहते हैं तो शुरू करने के लिए एक जगह है।

code-golf decision-problem restricted-source code-golf number kolmogorov-complexity code-challenge compression code-golf number sequence code-golf math polynomials code-challenge algorithm code-golf javascript code-golf string kolmogorov-complexity code-golf grid puzzle-solver code-golf keyboard code-golf king-of-the-hill javascript code-golf string code-golf pattern-matching code-golf matrix code-golf string game card-games code-golf code-golf string number decision-problem code-golf function hashing code-golf ascii-art date code-challenge fastest-algorithm code-golf string decision-problem keyboard code-golf string

— गेहूं का जादूगर
स्रोत

2

आपने स्ट्रिंग्स का उपयोग करके अर्ध-पेलिंड्रोम को क्यों परिभाषित किया लेकिन आपके इनपुट पूर्णांक के सरणियाँ हैं? भ्रमित होने के अलावा, इसका मतलब है कि हम अपने स्वयं के कार्यक्रम का उपयोग करके अपने स्रोत कोड का परीक्षण नहीं कर सकते।

— ब्रैडक

@ ब्रैड पालिंड्रोम्स और इस तरह शब्दों के संदर्भ में अक्सर समझाया जाता है, क्योंकि ऐसा करना थोड़ा आसान है।

— आउटगॉल्फ

@ ब्रैड स्ट्रिंग्स अजीब बढ़त के मामलों को पेश करते हैं, खासकर वर्ण बनाम बाइट के संदर्भ में। मैं संख्या का चयन करता हूं क्योंकि वे सरल हैं। मुझे लगा कि स्पष्टीकरण के उद्देश्यों के लिए शब्द आसान होंगे।

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

2

इस प्रकार के पैलिंड्रोमों को साहित्य में सामान्यीकृत स्मरंडचे पालिंड्रोम्स के रूप में जाना जाता है।

— borrible

1

@RosLuP हां, "सच" पैलिंड्रोम्स भी अर्ध-पेलिंड्रोम्स हैं, बस प्रत्येक चरित्र / पूर्णांक का इलाज करें जैसा कि कोई अतिरिक्त "चैंकिंग" नहीं है।

— ब्रैडेक

6

रेटिना 0.8.2 , 85 69 बाइट्स

M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)|M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

M`

मैच मोड का चयन करता है। वास्तव में, रेटिना एकल-लाइन प्रोग्राम के लिए मैच मोड में चूक करता है, लेकिन कोड की दूसरी प्रतिलिपि हमेशा इन अतिरिक्त वर्णों के लिए मेल खाती है।

मैच की शुरुआत में होनी चाहिए।

(.+,)*

वर्णों के कई रन कैप्चर करें। प्रत्येक रन अल्पविराम में समाप्त होना चाहिए।

(\d+,)?

वैकल्पिक रूप से अंकों की संख्या और अल्पविराम का मिलान करें।

(?<-1>\1)*

वैकल्पिक रूप से सभी कैप्चर का उल्टा क्रम में मिलान करें, प्रत्येक को मिलान करते हुए पॉपिंग करें।

मैच अंत में समाप्त होना चाहिए।

(?(1)^)

जब तक सभी कैप्चर पॉपअप नहीं किए जाते। यह मैच की आवश्यकता के द्वारा काम करता है फिर भी स्ट्रिंग की शुरुआत में हो सकता है यदि हमारे पास एक अनकैप्ड कैप्चर है, जो असंभव है।

— नील
स्रोत

5

जेली , 27 23 बाइट्स

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ

सेमी-पलिंड्रोम्स के लिए 1 रिटर्न , 0 अन्यथा।

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

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

ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ  Main link. Argument: A (array)

          Œ              Invalid token. Everything to its left is ignored.
           ŒH            Halve; divide A into two halves similar lengths. The middle
                         element (if there is one) goes into the first half.
             Ḣ           Head; extract the first half.
              ŒṖ         Generate all partitions of the first half.
                U        Upend; reverse each chunk of each partition.
                         Let's call the result C.

                     Ṛ   Yield R, A reversed.
                   Ƒ€    Fixed each; for each array P in C, call the link to the left
                         with arguments P and R.
                         Return 1 if the result is P, 0 if not.
                 ṁ@          Mold swapped; replace the n integers of C, in reading
                             order, with the first n integers of R.
                     Ẹ   Exists; check if one of the calls returned 1.

— डेनिस
स्रोत

4

पायथन 2 , 157 153 147 143 बाइट्स

-4 बाइट्स tsh के लिए धन्यवाद ।

s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)
s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)

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

— OVS
स्रोत

1

2 * 2 बाइट्स बचाने के x==x[::-1]लिए बदलें len(x)<2; 143 बाइट्स

— tsh

4

05AB1E , 59 47 43 41 बाइट्स

2äøø€.œ`âʒ`RQ}gĀIg_^q2äøø€.œ`âʒ`RQ}gĀIg_^

-12 बाइट्स @Emigna की बदौलत ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

2ä               # Split the input into two parts
                 #  i.e. [3,4,2,0,2,3,4] → [[3,4,2,0],[2,3,4]]
  øø             # Zip twice without filler
                 # This will remove the middle item for odd-length inputs
                 #  i.e. [[3,4,2,0],[2,3,4]] → [[3,2],[4,3],[2,4]] → [[3,4,2],[2,3,4]]
    €.œ          #  Then take all possible partitions for each inner list
                 #   i.e. [[3,4,2],[2,3,4]]
                 #    → [[[[3],[4],[2]],[[3],[4,2]],[[3,4],[2]],[[3,4,2]]],
                 #       [[[2],[3],[4]],[[2],[3,4]],[[2,3],[4]],[[2,3,4]]]]
`                # Push both lists of partitions to the stack
 â               # Take the cartesian product (all possible combinations) of the partitions
                 #  i.e. [[[[3],[4],[2]],[[2],[3],[4]]],
                 #        [[[3],[4],[2]],[[2],[3,4]]],
                 #        ...,
                 #        [[[3,4,2]],[[2,3,4]]]]
  ʒ   }          # Filter this list of combinations by:
   `             #  Push both parts to the stack
    RQ           #  Check if the second list reversed, is equal to the first
                 #   i.e. [[3,4],[2]] and [[2],[3,4]] → 1 (truthy)
       gĀ        # After the filter, check if there are any combinations left
                 #  i.e. [[[[3,4],[2]],[[2],[3,4]]]] → 1 (truthy)
         Ig_     # Check if the length of the input was 0 (empty input-list edge-case)
                 #  i.e. [3,4,2,0,2,3,4] → 7 → 0 (falsey)
            ^    # Bitwise-XOR
                 #  i.e. 1 XOR 0 → 1 (truthy)
             q   # Stop the program (and then implicitly output the top of the stack)
2äøø€.œ`âʒ`RQ}gĀIg_^
                 # Everything after the `q` are no-ops to comply to the challenge rules

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

आप 2ä6 बाइट्स की बचत के साथ øø -. with} `के साथ विषम-लंबाई सूचियों के साथ समस्या को हल कर सकते हैं । आपको यह भी लगता है कि 30 अप्रयुक्त बाइट्स में छोड़ दिया है ...

— एमिग्ना

@ अंत में नो-ओप्सन चुनौती के प्रतिबंधित स्रोत की आवश्यकता का अनुपालन करने के लिए हैं

— कामिल दकरी

@KamilDrakari: ओह सही है। उस हिस्से को भूल गए। अच्छी खबर यह है कि 6 बाइट बचाने के लिए 12 बाइट्स होंगे :)

— एमिग्ना

@Eignign डबल-जिप ट्रिक के साथ बहुत स्मार्ट है। मैं उस हिस्से के बारे में खुश नहीं था, लेकिन यह बहुत बेहतर है! Btw, चूंकि अमृत फिर से लिखता है 2-बाइट कमांड के €बजाय के साथ उपयोग किया जा सकता है ε }। :)

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

@ केविनक्रूजसेन: आह शांत। मुझे नहीं पता था।

— एमिग्ना

4

05AB1E , 37 बाइट्स

लगभग उसी तकनीक का उपयोग करता है जोनाथन के साथ आया था।

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

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

.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ

पूरा कार्यक्रम। STDIN से एक सूची प्राप्त करता है, STDOUT में 1 या 0 आउटपुट करता है ।

.œʒ        }

फ़िल्टर-विभाजन को संतुष्ट रखें ...

   €gηOZ;îå

यह स्थिति: प्रत्येक की लंबाई ( €g) एक सूची में संग्रहीत की जाती है, जिनके उपसर्ग ( η) तब सारांशित ( O) होते हैं, इसलिए हमें लंबाई सूची के संचयी योग देते हैं। फिर, उस सूची के अधिकतम के छत वाले हिस्से को स्टैक पर धकेल दिया जाता है - लेकिन मूल सूची को उस पर रखने के साथ-साथ ( Z;î) और यदि åसंचयी रकम में ( ) होता है तो फ़ंक्शन सत्य हो जाता है।

εÂQ}

प्रत्येक के लिए, की तुलना ( Q) एक साथ एक उलट है, जिसके द्वारा स्टैक पर अलग से धकेल दिया जाता है Â। 0 s और 1 s की सूची देता है ।

ZĀq

ज्यादा से ज्यादा। यदि कोई सत्य है, तो 1 और 0 । अंतिम निष्पादन। अनुसरण करने वाली हर चीज को पूरी तरह से नजरअंदाज कर दिया जाता है।

— मिस्टर एक्सकोडर
स्रोत

3

पायथन 2 , 275 251 205 बाइट्स

-24 बाइट्स @KevinCruijssen को धन्यवाद

-44 बाइट्स @PostLeftGhostHunter की बदौलत

-2 अधिक बाइट्स @KevinCruijssen के लिए धन्यवाद

def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])
def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])

सेमी-पलिंड्रोम के लिए सही है, अन्यथा कोई नहीं

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

— Cowabunghole
स्रोत

1

या बस 1

— जो किंग

दो बार क्यों परिभाषित किया गया है?

— डॉ। वाई विट

क्योंकि वे कहते हैं कि पैलेंड्रोम के रूप में गिनती ... लेकिन एक ही नाम के साथ एक फ़ंक्शन को परिभाषित करना संभव है ???

— रोजलूपी

@RosLuP हाँ आप कर सकते हैं। दूसरा बस पहले को अधिलेखित करता है

— जो किंग

3

जेली , 33 32 बाइट्स

-1
एक बग फिक्स के लिए डेनिस को भी धन्यवाद दिया गया और जेलि में एक कार्यान्वयन विवरण बदलने के लिए धन्यवाद।

ẸƇŒḂƇƊ$ƊĊHṀċÄẈṖŒŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ

सेमी-पैलिंड्रोमेस उपज 1, अन्य उपज 0।

$O(2^n)$

या परीक्षण-सूट देखें ।

केवल चंक्स ŒḂs ({3 ^rd & 4 ^th } बनाम {29 ^th & 30 ^th } बाइट्स) हैं, बस कोड को पार्स करने की अनुमति देते हैं।

कैसे?

सभी काम दाहिने हाथ से किया जाता है - "मुख्य लिंक":

ŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ - Main Link: list
ŒṖ               - all partitions
           Ƈ     - filter keep those for which this is truthy (i.e. non-zero):
          Ɗ      -   last three links as a monad:
  Ẉ              -     length of each
         $       -     last two links as a monad:
   Ä             -       cumulative addition
        Ɗ        -       last three links as a monad:
     Ṁ           -         maximum
      H          -         halve
       Ċ         -         ceiling
    ċ            -     count
              Ƈ  - filter keep those for which this is truthy:
            ŒḂ   -   is palindrome?
               Ẹ - any?

— जोनाथन एलन
स्रोत

3

पर्ल 6 , 87 79 बाइट्स

जो किंग के जवाब से कुछ ट्रिक्स के साथ 8 बाइट्स

$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}#$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}

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

पोर्ट ऑफ टीएस का जावास्क्रिप्ट उत्तर। दो अलग-अलग रेगेक्स ऑब्जेक्ट लौटाता है।

— nwellnhof
स्रोत

2

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

f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}#f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}

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

— जीबी
स्रोत

1

जावास्क्रिप्ट (Node.js) , 139 बाइट्स

f=a=>(s=(''+a).replace(/^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)//^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)f=a=>(s=(''+a).replace(

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

— TSH
स्रोत

1

सी (gcc) (X86), २१६ बाइट्स

p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)//p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)

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

p(L,a,n)0 रिटर्न अगर aलंबाई की सरणी Lएक अर्ध-ताल है, 1 अन्यथा। यह देखते हुए कि लंबाई के सभी उपसर्ग >nपहले से ही जांचे जा चुके हैं, यह लंबाई nके प्रत्यय के साथ लंबाई के उपसर्ग की तुलना करता है n। p(L,a)प्रवेश बिंदु है।

दुर्भाग्य से, अधिक दिलचस्प समाधान लंबा है:

224 बाइट्स

(f(L,a,n))//#define p(L,a)(n=L/2,
int*a,n;
{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}//{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n))//(

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

Ungolfed:

(f(L,a,n)) //#define p(L,a)(n=L/2,
int*a,n;
{
  return n 
    ? (memcmp(a, a+L-n, n*4) | f(L-2*n, a+n, L/2-n)) &&
      f(L,a,n-1)
    : 1 < L;
} // { ... } 
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n)) //(

— eush77
स्रोत

1

जाप , 66 बाइट्स


@¯X eUsXn}a1 "
Ê§V?UÊ<2:ßUéV sVÑ
@¯X eUsXn}a1 "
Ê§V?UÊ<2:ßUéV sVÑ

जाप दुभाषिया

इस संस्करण में बड़ा सुधार, यह वास्तव में अब व्यावहारिक भाषाओं में से अधिकांश को धड़कता है। अब पूर्णांक की एक सरणी पर संचालित होता है क्योंकि पिछली विधि में बग था।

स्पष्टीकरण:

@        }a1         Find the first number n > 0 such that...
 ¯X                   the first n elements
     UsXn             and the last n elements
    e                 are the same

"
Ê§V?UÊ<2:ßUéV sVÑ    String literal to make it a Semi-palindrome
@¯X eUsXn}a1 "

Ê§V?                 If n >= length of input...
    UÊ<2              return true if the length is less than 2
        :            Otherwise...
          UéV         move n elements from the end of the input to the start
              sVÑ     remove the first 2*n elements
         ß            and repeat on the remaining elements

— कामिल दकरी
स्रोत

0

PHP 237 बाइट्स

function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}#function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}

पुनरावर्ती कार्य, रिटर्न true(इनपुट दो तत्वों से कम के 1लिए ) या सत्य के लिए,
0मिथ्या के लिए। इसे ऑनलाइन आज़माएं (इसमें ब्रेकडाउन शामिल है)।

वास्तविक कोड लंबाई 118 बाइट्स है; कोड-डुप्लीकेशन के जरिए बनाया गया सेमी-पैलिंड्रोम।

बेहतर प्रदर्शन के लिए, पहले के &साथ बदलें &&और डालें ।!$x&&++$i

— टाइटस
स्रोत

0

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

def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}//def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}

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

पुनश्च। जाहिर है, समाधान केवल एक आवश्यकता को संतुष्ट करने के लिए 2 गुना लंबा है कि स्रोत कोड अर्ध पैलिंड्रोम है।

पी पी एस। कोड-गोल्फ उम्मीदवार नहीं, बल्कि पैटर्न मिलान का उपयोग करके विशुद्ध रूप से कार्यात्मक समाधान:

  def f(s:Seq[Int], i:Int=1):Int = {
    (s, i) match {
      case (Nil ,_) => 1
      case (Seq(_), _) => 1
      case (l, _) if l.take(i) == l.takeRight(i) => f(l.slice(i,l.size-i), 1)
      case (l, j) if j < l.size/2 => f(l, i+1)
      case (_, _) => 0
    }
  }

— डॉ। वाई विट
स्रोत

चुनौती के लिए आवश्यक है कि आपका कोड एक अर्ध-तालमेल भी हो। यह चुनौती में सबसे मजेदार है।

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

@PostLeftGhostHunter, मैंने आवश्यकता को पूरा करने के लिए मूल स्रोत कोड टिप्पणी में जोड़ा। बीटीडब्ल्यू, स्रोत कोड अर्ध पैलिंड्रोम बनाने का मज़ा क्या है? अगर मैं गलत नहीं हूं, तो इस धागे का हर समाधान इस आवश्यकता के बिना दो गुना कम होगा। क्या आप किसी भी समाधान के बारे में जानते हैं, ऐसा नहीं है?

— डॉ। वाई विट

0

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

($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs#($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs

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

रेगुलर एक्सप्रेशन से रिटर्न /../यह सच है के लिए और regex /^(.+)(.*)$0$/झूठी के लिए। Nwellnhof के उत्तर के समान ही काम करता है , लेकिन सूची को पहले से ही एक स्ट्रिंग में बदल देता है।

— मजाक कर रहा है
स्रोत

एक सेमी-पेलिंड्रोम पहेली

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

रेटिना 0.8.2 , 85 69 बाइट्स

जेली , 27 23 बाइट्स

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

पायथन 2 , 157 153 147 143 बाइट्स

05AB1E , 59 47 43 41 बाइट्स

05AB1E , 37 बाइट्स

पायथन 2 , 275 251 205 बाइट्स

जेली , 33 32 बाइट्स

कैसे?

पर्ल 6 , 87 79 बाइट्स

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

जावास्क्रिप्ट (Node.js) , 139 बाइट्स

सी (gcc) (X86), २१६ बाइट्स

224 बाइट्स

जाप , 66 बाइट्स

PHP 237 बाइट्स

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

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