14

एक पिल्लई प्राइम एक अभाज्य संख्या है जिसके लिए कुछ धनात्मक मौजूद है जैसे कि और । $p$ $m$ $(m! + 1) \equiv 0 \:(\text{mod } p)$ $p \not\equiv 1\:(\text{mod }m)$

दूसरे शब्दों में, एक पूर्णांक $p$ अगर यह एक है एक पिल्लई प्रधानमंत्री है अभाज्य संख्या है, अगर वहाँ एक और सकारात्मक पूर्णांक मौजूद $m$ ऐसी है कि भाज्य के $m$ , प्लस $1$ से विभाज्य है $p$ और अगर $p - 1$ से विभाज्य नहीं है $m$ ।

इनपुट के रूप में एक सकारात्मक पूर्णांक को देखते हुए, यह तय करें कि क्या यह पिल्लई प्राइम है। पिल्लई के अपराधों का क्रम OEIS A063980 है ।

उदाहरण के लिए, $23$ एक पिल्लई प्राइम है क्योंकि:

यह एक प्रमुख संख्या है, जिसमें केवल 2 कारक हैं।
$m = 14$ और $m = 18$ उपरोक्त शर्तों को पूरा करते हैं: $23 \mid (14! + 1)$ और $14$ विभाजित नहीं करता है ; और या तो विभाजित नहीं करते हैं। $22$ $23 \mid (18! + 1)$ $18$ $22$

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

Truthy:

Falsy:

सत्य मामलों के लिए, संबंधित मीटर हैं [(23, [14, 18]), (59, [15, 40, 43]), (83, [13, 36, 69]), (109, [86]), (139, [16]), (593, [274])]।

आप या तो मानक निर्णय-समस्या आउटपुट प्रारूप (जो कि, सत्य / मिथ्या मूल्यों) का पालन कर सकते हैं या पिल्लई अपराधों के लिए एक सुसंगत मूल्य और एक गैर-संगत मूल्य अन्यथा या इसके विपरीत है ।

आप किसी भी प्रोग्रामिंग भाषा में प्रतिस्पर्धा कर सकते हैं और इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है , इसलिए हर भाषा के लिए सबसे कम सबमिशन (बाइट्स में) जीतता है।

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

क्या इनपुट एक समग्र पूर्णांक हो सकता है?

— जुंगवान मिन

@JungHwanMin हाँ, इनपुट एक पूर्णांक हो सकता है।

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

मैं 437 जैसा टेस्ट केस सुझाता हूं, जो कंपोजिट है, लेकिन 18 को विभाजित करता है! +1।

— नाइट्रोडॉन

@Nitrodon ने उस परीक्षण मामले को जोड़ा, धन्यवाद!

— श्री Xcoder

1

@DanielIndie यहां आप जाएं [(23, 14), (23, 18), (59, 15), (59, 40), (59, 43), (83, 13), (83, 36), (83, 69), (109, 86), (139, 16), (593, 274)]:। मैंने उन्हें चुनौती से भी जोड़ा है।

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

9

पायथन 2 , 115 111 110 109 बाइट्स

^{-6 बाइट्स मिस्टर एक्सकोडर की बदौलत}

lambda n:n>2and cmp(*map(all,zip(*[[n%x==1or~f(x)%n,n%x]for x in range(2,n)])))<0
f=lambda x:0**x or x*f(x-1)

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

फ़ंक्शंस में दो भाग होते हैं ~-n%x<1or~f(x)%n>0जो सत्यापित करता है कि "पिल्लई की स्थिति" को संतुष्ट n नहीं करता है, और n%x>0प्रमुख सत्यापन के लिए।
उसके बाद allदोनों वस्तुओं पर लागू होता है, पहला आइटम शामिल होंगे False/ 0अगर वहाँ है एक वैध "पिल्लै संख्या", और दूसरा शामिल होंगे True/ 1यदि nप्रधानमंत्री है।
इन करने के लिए पारित कर रहे हैं cmpकि वापस आ जाएगी -1इस cenario (एक वैध पिल्लई प्रधानमंत्री है) में। अन्य संयोजन [[0, 0], [1, 0], [1, 1]]वापस आ जाएंगे 0या1

— छड़ी
स्रोत

2

+1, चतुर एल्गोरिदम (और उनके स्पष्टीकरण) मुझे इस SE से प्यार क्यों है

— IanF1

8

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

Ṗ!%ẹ’ḍ’E

पिल्लई प्राइम के लिए रिटर्न 0 , 1 अन्यथा।

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

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

Ṗ!%ẹ’ḍ’E  Main link. Argument: n

Ṗ         Pop; yield [1, ..., n-1].
 !        Take the factorial of each integer.
  %       Take the factorials modulo p.
   ẹ’     Find all indices of n-1.
     ḍ’   Test n-1 for divisibility by each of these indices.
       E  Return 1 if all of the resulting Booleans are equal (all 1 means there is
          no suitable m, all 0 means n is not prime), 0 if they are different.

— डेनिस
स्रोत

1

लगभग यही है कि मैंने भी इसे कैसे किया होगा, लेकिन मैंने उस m would [1, n) को साबित करने का प्रबंधन नहीं किया ।

— आउटगोल्फर

4

यदि m ≥ n , तो m! n से विभाज्य है , इसलिए मी! + 1 ≡ 1 (mod n) ।

— डेनिस

6

परी / जीपी , 44 बाइट्स

p->isprime(p)&&sum(m=2,p,p%m-1&&!((m!+1)%p))

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

— alephalpha
स्रोत

5

ब्रेकीलॉग , 19 बाइट्स

ṗ>.ḟ+₁;?%0&-₁;.%>0∧

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

इस सवाल का सुंदर सीधा अनुवाद:

ṗ          Input is a prime
>.         And output is a number less than the input
ḟ+₁;?%0    And output's factorial + 1 mod input is 0
&-₁;.%>0   And input - 1 mod output is greater than 0
∧          No further constraints

— sundar - मोनिका को बहाल करना
स्रोत

3

जे , 30 26 बाइट्स

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

1 e.i.((|1+!)~<1~:|)1&p:*]

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

स्पष्टीकरण:

                        1&p:*]      checks if the number is prime and if not sets it to 0
                   1~:|             checks if p is not 1 mod m
           (|1+!)~                  m factorial plus 1 modulo n
                  <                 are both conditions met?  
       i.                           generates successive m's (a list 0..n-1)
   1 e.                             1's are at the indices of m, so if there's 1 - Pillai

— गैलेन इवानोव
स्रोत

1

जाँच करें कि मोडुलो एन 1~:|2 बाइट्स बचाने के लिए कम है ।

— फ्रॉनीफ्रॉग

1

(]|1+!@[)बस है(|1+!)~

— FrownyFrog

@FrownyFrog - धन्यवाद! मैं इसके बारे में सोच रहा था ~और यह आपकी पिछली टिप्पणी के बारे में बताता है ।

— गैलेन इवानोव

3

पायथन 2 , 65 64 53 52 बाइट्स

f=lambda n,k=3,m=2:~m%n<1<n%k%(n%~-k)or f(n,k+1,m*k)

आउटपुट एक त्रुटि की उपस्थिति या अनुपस्थिति के माध्यम से है।

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

— डेनिस
स्रोत

2

पायथन 2 , 109 107 बाइट्स

lambda p:any(~-p%m>~l(m)%p<1for m in range(2,p))*all(p%i for i in range(2,p-1))
l=lambda a:0**a or a*l(a-1)

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

व्याख्या

lहां, तो संख्या में पारित की भाज्य पाता 5इनपुट रिटर्न के रूप में 120।

यह all(p%i for i in range(2,p-1))देखने के लिए कि क्या कोई संख्या प्रधान है, हम 0 और 1 को नजरअंदाज करते हैं क्योंकि हमारी अन्य शर्तें पहले से ही उन पर नियंत्रण करती हैं।

अंत में, हम any(~-p%m>-~l(m)%p==0for m in range(2,p))सभी संभावित मीटरों को देखने के माध्यम से पुनरावृत्ति करने के लिए उपयोग करते हैं कि क्या कोई हमारी जरूरतों को पूरा करता है। ~-pका मतलब है p+1। फिर हम यह देखने के लिए जांच करते हैं कि क्या यह अधिक है -~l(m)%p(जो अनुवाद करता है (m!-1)%p, और फिर हम इसकी तुलना करते हैं 0। मूल रूप ~-p%mसे 0 से अधिक -~l(m)%pहोना चाहिए और 0 होना चाहिए।

सूत्रों का कहना है

क्रमगुणित द्वारा 0xKirill

सुधार

109 से 107 तक, श्री एक्सकोडर

— नील
स्रोत

2

जैसा कि आप शायद tio लिंक में देख सकते हैं कि सभी मामले पास नहीं होते हैं, क्योंकि js कठबोली बड़ी संख्या को संभालते हैं, अगर ऐसी आवश्यकता मौजूद है तो इसे लागू करने की कोशिश करें :)

F%n>n-2&(F+1)%n<1झूठी सकारात्मक को रोकने के लिए एक दोहरी जांच है (लेकिन जेएस बड़ी संख्या के मुद्दों के साथ दूसरा तरीका नहीं है, हमें वास्तव में (F+1)%n<1छोटी संख्या के लिए आवश्यकता है , जो कि समाधान के लिए बाइट गिनती को कम कर देता है 60

जावास्क्रिप्ट (Node.js) , 90 88 86 72 68 बाइट्स

1 बाइट कम करने के लिए अरनौल का धन्यवाद

f=(n,F=i=2,g=0)=>n%i?f(n,F*=++i,g|=F%n>n-2&(F+1)%n<1&~-n%i>0):i==n*g

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

— DanielIndie
स्रोत

2

ब्रेकीलॉग , 13 बाइट्स

>.ḟ+₁ḋ∋?-₁f≡ⁿ

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

पिल्लई अपराधों के लिए सफलता, आउटपुट चर के माध्यम से सबसे छोटी मी प्रदान करता है , और किसी और चीज के लिए विफल रहता है। चूँकि यह सूंदर के घोल पर बाइट्स को कैसे बचाता है इसका एक बड़ा हिस्सा यह है कि यह बार-बार कुछ बहुत बड़ी संख्याओं के अभाज्य गुणनखंडों की गणना करता है, यह बड़े आदानों पर काफी अविश्वसनीय रूप से धीमा है। (यदि मेरा लैपटॉप बैटरी की शक्ति पर नहीं है, तो मैं शायद उन मामलों को अपने स्थानीय ब्रेकीलॉग इंस्टॉलेशन पर चलाऊंगा।)

 .               The output
>                is less than the input,
       ?         the input
      ∋          is an element of
     ḋ           the prime factorization of
 .               the output's
  ḟ              factorial
   +₁            plus one,
           ≡ⁿ    and the output is not an element of
          f      the list of all factors of
       ?         the input
        -₁       minus one.

— असंबंधित स्ट्रिंग
स्रोत

1

[पर्ल], 45 बाइट्स

use ntheory":all";is_prime($n)&&is_pillai($n)

संख्या सिद्धांत मॉड्यूल में अंतर्निहित कार्यों के रूप में विधेय होता है (is_pillai वास्तव में 0 या सबसे छोटा मीटर है, इसलिए A063828 भी हल करता है)। अंतर्निहित C और पर्ल कोड गोल्फ (बेशक) नहीं है। सी कोड इस तरह दिखता है:

UV pillai_v(UV n) {
  UV v, fac = 5040 % n;
  if (n == 0) return 0;
  for (v = 8; v < n-1 && fac != 0; v++) {
    fac = (n < HALF_WORD) ? (fac*v) % n : mulmod(fac,v,n);
    if (fac == n-1 && (n % v) != 1)
      return v;
  }
  return 0;
}

(मूल रूप से यूवी को uint64_t या समान के साथ बदलें, और HALF_WORD यह तय करता है कि क्या हम mulmod को सरल देशी ऑप्स में अनुकूलित कर सकते हैं)।

शुद्ध पर्ल कोड के समान है:

sub is_pillai {
  my $p = shift;
  return 0 if $p <= 2;
  my($pm1, $nfac) = ($p-1, 5040 % $p);
  for (my $n = 8; $n < $p; $n++) {
    $nfac = mulmod($nfac, $n, $p);
    return $n if $nfac == $pm1 && ($p % $n) != 1;
  }
  0;
}

— DanaJ
स्रोत

1

सी (जीसीसी) , 64 बाइट्स

f(n,k,m,r){for(k=m=1,r=0;k<n;m=m*++k%n)r|=m/~-n<<(n%k==1);r/=3;}

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

— डेनिस
स्रोत

1

व्हिस्पर v2 , 230 बाइट्स

> 1
> Input
>> 1…2
>> L!
>> L+1
>> L∣2
>> L⋅R
>> 2%L
>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3
> {0}
>> 12∖13
>> Each 8 14
>> L≠1
>> Each 16 15
>> Each 7 17 15
>> 18∖13
>> [19]
>> 2’
>> 21⋅20
>> Output 22

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

यह गैर-पिल्लई अपराधों के लिए एक खाली सूची देता है, और एक गैर-रिक्त सूची अन्यथा।

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

फुसफुसाते हुए वास्तविक / जटिल संख्याओं में हेरफेर के लिए डिज़ाइन किया गया था, अच्छे माप के लिए थोड़े सरणी कमांड जोड़े गए थे, इसलिए Eachउत्पन्न सूचियों पर पुनरावृति का दोहराया उपयोग ।

फुसफुसाते हुए पृष्ठभूमि पर थोड़ा सा:

फुसफुसाते हुए यह सबसे अलग भाषाओं के लिए पथ में थोड़ा अलग है। प्रत्येक लाइन के माध्यम से काम करने के बजाय, केवल सशर्त शाखाओं में शाखाओं में बंटी, व्हिस्पर की शुरुआत फ़ाइल में अंतिम पंक्ति से होती है >(नियम इससे थोड़ा अधिक जटिल होते हैं, लेकिन यह सब हमें अभी जानने की जरूरत है), और संख्याओं के अर्थ अलग है, इस पर निर्भर करता है कि क्या लाइन के साथ शुरू होता है >या >>।

यदि रेखा के साथ शुरू होता है >, जैसे कि > 1या > Input, यह एक निरंतर रेखा है - यह हर बार समान मूल्य देता है। यहां, संख्याएं उनके संख्यात्मक रूप का प्रतिनिधित्व करती हैं, इसलिए पहली पंक्ति हमेशा 1 तब वापस आएगी जब बुलाया जाएगा।

यदि रेखा के साथ शुरू होता है >>, तो संख्याओं को अन्य लाइनों के संदर्भ के रूप में माना जाता है, यदि आप चाहें तो फ़ंक्शन कॉल की तरह। उदाहरण के लिए, लाइन में >> 1…2, यह …पूर्णांक 1 और 2 पर कमांड का प्रदर्शन नहीं करता है , बल्कि 1 और 2 लाइनों से लौटाए गए मानों पर निर्भर करता है । इस स्थिति में, वे मान पूर्णांक 1 हैं और जो भी पूर्णांक हम इनपुट के रूप में पास किए गए हैं।

इस उदाहरण के लिए, आइए 23 के इनपुट पर विचार करें । ध्यान रखें कि, व्हिस्पर के प्रीप्रोसेसिंग के कारण दूसरी लाइन ( > Input) में परिवर्तित हो जाती है > 23।

हमारा पहला कमांड लाइन 3: पर है >> 1…2। …डाईएडिक श्रेणी है, इस मामले में 1 से 23 तक , {1, 2, ... 22, 23} उपज है । इसके बाद, हम लाइनों के लिए नीचे छोड़ 9 के माध्यम से 12 :

>> Each 4 3
>> Each 5 9
>> Each 6 10
>> Each 7 11 3

यहां हमारे पास 4 संकेंद्रित Eachकथन हैं, जिनमें से प्रत्येक पिछले परिणाम पर पुनरावृति करता है, अनिवार्य रूप से पंक्ति 3 पर सरणी पर 4 आदेशों की मैपिंग करता है : सीमा। पहले तीन कथन सरल मानचित्र हैं, जिनमें रेखाएँ 4 , 5 और 6 हैं :

>> L!
>> L+1
>> L∣2

इन तीन आज्ञाओं, एक पूर्णांक n पर , पैदावार (n! +1) wherex , कहाँ ! अर्थ है भाज्य , | दर्शाता है divisbility और एक्स इनपुट है। अंत में, लाइन 12 में एक डाईएडिक मानचित्र संरचना है।

एक डाईएडिक मैप संरचना तीन पूर्णांक लेती है: लक्ष्य, बाएं और दाएं, प्रत्येक अनुक्रमणिका अन्य लाइनों के लिए। यहाँ, हम बाएँ और दाएँ जोड़े की सूची बनाते हैं, फिर प्रत्येक जोड़ी को डाइएडिक कमांड (लक्ष्य) द्वारा कम करते हैं। यहां, यदि इनपुट 23 है , तो सूचियां {1, 2, ... 22, 23} और {0, 0, ... 1, 0} हैं और कमांड है

>> L⋅R

जो दायें से बायें तर्क को गुणा करता है। यह पूर्णांकों की एक सरणी, साथ पैदा करता है 0 पूर्णांकों जिसका factorials वृद्धि आदानों से विभाज्य नहीं कर रहे हैं की अनुक्रमणिका में, और मूल सूचकांक कि वे कहाँ हैं। हम इस सरणी को A कहेंगे । आगे, हम {0} और A के बीच के अंतर को लेते हुए A से 0 को हटाते हैं :

> {0}
>> 12∖13

हमारे उदाहरण इनपुट के साथ, यह {14, 18, 22} सेट का उत्पादन करता है । अगला हम इनपुट के शेष भाग को सेट में प्रत्येक मान से विभाजित करते हैं, और जाँचते हैं कि क्या शेष 1 के बराबर नहीं है :

>> 2%L
>> Each 8 14
>> L≠1
>> Each 16 15

फिर से, हमारे पास 0 या 1 एस की सूची है और 0 एस को हटाने और 1 एस को मूल मूल्यों के साथ बदलने की आवश्यकता है । यहां हम उस कोड को दोहराते हैं जो हमने ऊपर देखा था, लेकिन इसके >> 18∖13बजाय 12। अंत में, हमने इस परिणाम को अंतिम जांच के लिए एक सूची में सेट कर दिया। दुर्भाग्य से, हमारे कोड को समग्र संख्या को भी अस्वीकार करना चाहिए जो इन सभी मानदंडों को प्राप्त करते हैं, जैसे कि 437 । इसलिए हम अपनी अंतिम सूची को जोड़ते हैं, इनपुट की प्रधानता द्वारा हमारी अंतिम सूची को गुणा करते हैं। पायथन गुणन सूचियों पर काम करने के कारण, 0 इसे एक खाली सूची के साथ बदल देता है, और 1 का कोई प्रभाव नहीं होता है। तो हम इनपुट की मौलिकता की गणना करते हैं, कि मी की सूची से गुणा करेंइनपुट के लिए और अंतिम परिणाम ouput:

>> 2’
>> 21⋅20
>> Output 22

0

एपीएल (एनएआरएस), 65 चार्ट, 130 बाइट्स

{∼0π⍵:0⋄m←⎕ct⋄⎕ct←0⋄r←⍬≢a/⍨{0≠⍵∣p}¨a←k/⍨0=⍵∣1+!k←⍳p←¯1+⍵⋄⎕ct←m⋄r}

यहाँ 23x का अर्थ होगा 23r1 और इसलिए अंश 23/1, इसलिए अन्य सभी; परीक्षा:

  f←{∼0π⍵:0⋄m←⎕ct⋄⎕ct←0⋄r←⍬≢a/⍨{0≠⍵∣p}¨a←k/⍨0=⍵∣1+!k←⍳p←¯1+⍵⋄⎕ct←m⋄r}
  f¨23x 59x 83x 109x 139x 593x
1 1 1 1 1 1 
  f¨5x 7x 73x 89x 263x 437x
0 0 0 0 0 0

— RosLuP
स्रोत

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 138 + 22 = 160 बाइट्स

n=>Enumerable.Range(2,n-2).All(x=>n%x>0)&Enumerable.Range(1,n).Any(x=>{BigInteger a,b=1;for(a=1;a<=x;a++)b*=a;return(b+1)%n<1&(n-1)%x>0;})

TIO ने सिस्टम को लागू नहीं किया है। यह मोनो के रिलीज में पुस्तकालय पुस्तकालय है, तो आप परिणाम देख सकते हैं ~~इसे ऑनलाइन आज़माएं!~~ यहाँ इसके बजाय।

स्पष्टीकरण:

using System.Numerics; //necessary to handle large numbers created by the factorials

return 
    Enumerable.Range(2,n-2).All(x=>n%x>0)       // is prime
    &
    Enumerable.Range(1,n).Any(x=>
    {
        BigInteger a,b=1;for(a=1;a<=x;a++)b*=a; //b = a!
        return (b+1)%n<1
               &                                //the condition for PPs
               (n-1)%x>0;             
    });

— Innat3
स्रोत

0

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

ri_mp\[_{_M)m!)@%!\_M)%1=!@&\}fM]);:|

आउटपुट 11अगर इनपुट पिल्लई प्राइम है, अन्यथा 00, 01या10

स्पष्टीकरण:

                                         e# Explanation | Stack
ri_mp\[_{_M)m!)@%!\_M)%1=!@&\}fM]);:|    e# Whole code | Example input: 593
ri                                       e# Read input as integer | 593
  _                                      e# Duplicate | 593 593
   mp                                    e# Is it prime? | 593 1
     \                                   e# Swap top two stack elements | 1 593
      [                         ]        e# Delimits an array. Any operations that
                                         e# push a value are placed into the array
       _                                 e# Duplicate | 1 593 [593]
        {                    }fM         e# A for loop from 0 to (n-1) looped through
                                         e# variable M
         _                               e# Duplicate top stack value | ...[593 593]
          M)                             e# Get M+1, as if we try M=0 we get an error
                                         e# | ...[593 593 1]
            m!                           e# Factorial | ...[593 593 1]
              )                          e# Add one | ...[593 593 2]
               @                         e# Rotate stack | ...[593 2 593]
                %                        e# Modulus | ...[593 2]
                 !                       e# Equal to 0? | ...[593 0]
                  \_                     e# Swap and duplicate | ...[0 593 593]
                    M)                   e# Push M+1 | ...[0 593 593 1]
                      %                  e# Modulus | ...[0 593 0]
                       1=!               e# Not equal to 1? | ...[0 593 1]
                          @              e# Rotate | ...[593 1 0]
                           &             e# AND | ...[593 0]
                            \            e# Swap | ...[0 593]
                             }     
                                ]
                                 );      e# Dump and discard last element
                                         e# | 1 593 [...]
                                   :|    e# Flatten array with OR | 1 1
                                         e# Implicit output

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

— lolad
स्रोत

क्या मैं पिल्लई प्रधान हूं?

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

पायथन 2 , 115 111 110 109 बाइट्स

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

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

परी / जीपी , 44 बाइट्स

ब्रेकीलॉग , 19 बाइट्स

जे , 30 26 बाइट्स

स्पष्टीकरण:

पायथन 2 , 65 64 53 52 बाइट्स

पायथन 2 , 109 107 बाइट्स

जावास्क्रिप्ट (Node.js) , 90 88 86 72 68 बाइट्स

ब्रेकीलॉग , 13 बाइट्स

[पर्ल], 45 बाइट्स

सी (जीसीसी) , 64 बाइट्स

व्हिस्पर v2 , 230 बाइट्स

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

एपीएल (एनएआरएस), 65 चार्ट, 130 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 138 + 22 = 160 बाइट्स

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