17

आपकी चुनौती, क्या आपको इसे स्वीकार करने के लिए चुना जाना चाहिए, एक ऐसा फ़ंक्शन कोड-गोल्फ करना है जो सही या गलत (या हां और नहीं के कुछ समान सार्थक प्रतिनिधित्व) लौटाता है यदि कोई संख्या निम्न मानदंडों को पूरा करती है:

पूर्णांक स्वयं एक अभाज्य संख्या है या
या तो इसके पड़ोसी पूर्णांक प्रमुख हैं

उदाहरण के लिए: का
एक इनपुट 7सही लौटाएगा।
का एक इनपुट 8भी सही लौटाएगा।
का एक इनपुट15 गलत लौटाएगा। (न तो 14, 15, या 16 प्रमुख हैं)

इनपुट को 2 ^ 0 और 2 ^ 20 समावेशी के बीच की संख्याओं के लिए सही ढंग से वापस करने में सक्षम होना चाहिए, इसलिए साइन मुद्दों या पूर्णांक ओवरफ्लो के बारे में चिंता करने की कोई आवश्यकता नहीं है।

— श्री लामा
स्रोत

32-बिट संख्या ओवरफ्लो, बफर ओवरफ्लो नहीं, मुझे लगता है।

— उपयोगकर्ता अनजान

व्हाट्स, का अर्थ था "पूर्णांक अतिप्रवाह"। ब्रेन ऑटोपायलट पर चला गया।

— श्री लामा

11

जे, १ 17

*/<:$&q:(<:,],>:)

रिटर्न बूलियंस प्रक्रिया रिटर्न कोड के रूप में एन्कोडेड है: सत्य के लिए शून्य, झूठे के लिए गैर-शून्य। नमूना उपयोग:

   */<:$&q:(<:,],>:) 7
0
   */<:$&q:(<:,],>:) 8
0
   */<:$&q:(<:,],>:) 15
3

— जेबी
स्रोत

*/0 p:<:,],>:छोटा है और एक उचित (लैम्ब्डा) फ़ंक्शन है([:*/0 p:<:,],>:)

— यादृच्छिक

9

हास्केल, 47 वर्ण

f n=any(\k->all((>0).mod k)[2..k-1])[n-1..n+1]

— Hammar
स्रोत

6

अजगर 85 80

def f(n):g=lambda n:all(n%i!=0for i in range(2,n));return g(n)or g(n-1)or g(n+1)

कोड गोल्फ पर पहली बार तो शायद कुछ ट्रिक्स मुझे याद आ रही हैं।

— क्रिश हार्पर
स्रोत

आप निकाल सकते हैं []। सभी जनरेटर अभिव्यक्ति के साथ काम करने के लिए खुश से अधिक होंगे। आप अपने कोड बदसूरत जा रहा है कोई आपत्ति नहीं है, तो आप भी बीच रिक्त स्थान को हटा सकते हैं 0और for, और )और or।

— अजनबी

@stranac बहुत बढ़िया। आपका बहुत बहुत धन्यवाद।

— क्रिश हार्पर

3

कुछ सीधे बदलाव किए, उम्मीद है कि यह अभी भी काम करेगा:f=lambda n:any(all(m%i for i in range(2,m))for m in[n,n-1,n+1])

— नब

@ नबब वेरी गुड। बहुत बढ़िया।

— क्रिश हार्पर

5

किसी भी तरह से कोड की कमी में एक वास्तविक दावेदार नहीं है, लेकिन अभी भी प्रधानता का निर्धारण करने के बाद से प्रस्तुत करना नियमित अभिव्यक्ति द्वाराकई तरीकों से घुमा दिया जाता है!

पायथन (2.x), 85 वर्ण

import re
f=lambda n:any(not re.match(r"^1?$|^(11+?)\1+$","1"*x)for x in[n,n-1,n+1])

— ChristopheD
स्रोत

आप लूप के लिए निकाल सकते हैं और "1" * (n + 1) का परीक्षण करके इसे regexp में बना सकते हैं लेकिन ^ 1? 1 के साथ? बजाय।

— हावर्ड

4

रूबी (55, या 50 लंबा के रूप में)

def f q;(q-1..q+1).any?{|n|(2..n-1).all?{|d|n%d>0}};end

या लैम्ब्डा के रूप में ( g[23]इसे कॉल करने के लिए उपयोग करें)

g=->q{(q-1..q+1).any?{|n|(2..n-1).all?{|d|n%d>0}}}

कॉफ़ीस्क्रिप्ट (53)

p=(q)->[q-1..q+1].some (n)->[2..n-1].every (d)->n%d>0

— jsvnm
स्रोत

<पंडिताऊ> यह होना चाहिए </ पंडिताऊ> ;-) "proc" नहीं "लैम्ब्डा"

— दरवाज़े

3

उबाऊ गणितज्ञ, 35 समाधान!

PrimeQ[n-1]||PrimeQ[n]||PrimeQ[n+1]

— Ry-
स्रोत

15

कम से कम आप इसे गोल्फ में डाल सकते हैं Or@@PrimeQ/@{n-1,n,n+1}।

— हावर्ड

यह कोई फ़ंक्शन नहीं है।

— मार्टिन एंडर

@ मार्टिनबटनर: मुझे माथेमैटिका पता नहीं है, क्षमा करें।

— Ry-

2

हावर्ड के संस्करण का उपयोग करना, Or@@PrimeQ@{#-1,#,#+1}&(उसके कोड में स्लैश की आवश्यकता नहीं है)

— मार्टिन एंडर

3

सी, ११२ 112२ 72 वर्ण

इल्मारी करोनेन की टिप्पणी के बाद, 30 चार्टों को हटाकर बचाया main, अब Pसही / गलत है। पुनरावृत्ति के साथ लूप को भी बदल दिया, और कुछ और मोड़।

p(n,q){return++q==n||n%q&&p(n,q);}P(n){return p(-~n,1)|p(n,1)|p(~-n,1);}

मूल संस्करण:

p(n,q,r){for(r=0,q=2;q<n;)r|=!(n%q++);return!r;}
main(int n,int**m){putchar(48|p(n=atoi(*++m))|p(n-1)|p(n+1));}

— ugoren
स्रोत

आप के साथ 2 वर्ण बचा सकता है main(n,m)int**m;।

— इल्मरी करोनें

... और इसके अलावा, चुनौती "कोड-गोल्फ ए फंक्शन " कहती है ।

— इल्मरी करोनन

3

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

न जाने क्यों यह पुरानी पोस्ट आज मेरी सूची में दिखाई दी, लेकिन मुझे एहसास हुआ कि यहां गणितज्ञ प्रतिस्पर्धी है।

Or@@PrimeQ/@{#-1,#,#+1}&

एक पूर्णांक तर्क लेने और लौटने Trueया False। प्रत्यक्ष कार्यान्वयन।

— ग्रेग मार्टिन
स्रोत

PrimeQसूचियों पर धागे, इसलिए Or@@PrimeQ@{#-1,#,#+1}&(या Or@@PrimeQ[#+{-1,0,1}]&) -1 बाइट के लिए भी काम करता है। (हालांकि, मुझे लगता है कि मुझे नहीं पता कि PrimeQ2012 में सूचियों को पिरोया गया था।)

— मिशा लावरोव

3

स्टैक्स , 6 बाइट्स

Ç▀<╝ºΩ

इसे चलाएं और डीबग करें

स्पष्टीकरण (अनपैक्ड):

;v:Pv<! Full program, implicit input  Example: 7
;v      Copy input and decrement               7 6
  :P    Next prime                             7 7
    v   Decrement                              7 6
     <! Check if input is >= result            1

— wastl
स्रोत

2

जावास्क्रिप्ट (71 73 80 )

n=prompt(r=0);for(j=n-2;p=j++<=n;r|=p)for(i=1;++i<j;)p=j%i?p:0;alert(r)

डेमो: http://jsfiddle.net/ydsxJ/3/

संपादित करें 1: बदलें for(i=2;i<j;i++)करने के लिए for(i=1;++i<j;)(धन्यवाद @minitech)। ifकथन को टर्नरी में बदलें । भीतर के ब्रेसिज़ को खत्म करने के लिए स्थानांतरित r|=pऔर p=1बाहरी for। 7 पात्रों को बचाया।

संपादित करें 2: कम्बाइन p=1और j++<=nकरने के लिए p=j++<=n, सेव 2 वर्ण (धन्यवाद @ugoren)।

— mellamokb
स्रोत

आप 1 और चरित्र को बचाने के for(i=1;++i<j;)बजाय उपयोग कर सकते हैं for(i=2;i<j;i++)।

— Ry-

1

@ मिनिटेक: !j%iपूर्वता के कारण काम नहीं करेगा। एक काम करने का विकल्प है j%i<1।

— नबं

@ नब: वाह, आप सही कह रहे हैं। ये बेवकूफी है।

— Ry-

कैसे के बारे में p=j++<=n? यदि जावास्क्रिप्ट यहाँ C की तरह है, तो यह काम करना चाहिए।

— बदसूरत

@ugoren: लगता है जैसे यह काम किया, धन्यवाद!

— मेलमोकब

2

रेगेक्स (ECMAScript), 20 बाइट्स

^x?x?(?!(x+)(x\1)+$)

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

उपरोक्त संस्करण सही ढंग से शून्य को संभालता नहीं है, लेकिन यह केवल 1 अतिरिक्त बाइट लेता है:

^x?x?(?!(x+)(x\1)+$)x

अतिरिक्त बोनस के रूप में, यहां एक ऐसा संस्करण है जो 1एक प्राइम से कम के लिए, प्राइम के 2लिए और 3एक से अधिक प्राइम के लिए एक रिटर्न मैच देता है :

^x?x??(?!(x+)(x\1)+$)x

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

— Deadcode
स्रोत

सीमा के बारे में सवाल यह है कि "2 ^ 0 और 2 ^ 20 के बीच" है तो 1..2 ^ 20 तो 0 नहीं है ...

— RosLuP

@RosLuP यही कारण है कि मेरा प्राथमिक उत्तर 20 बाइट्स है और 0 को सही तरीके से नहीं संभालता है। मुझे प्रश्न के सटीक विनिर्देशों से परे जाने और अधिक मजबूत उत्तर देने के साथ - साथ उस उत्तर के साथ मूल्य मिलता है जो न्यूनतम रूप से प्रश्न की कल्पना से मेल खाता है।

— डेडकोड

कभी-कभी मैं भी ऐसा ही करता हूं ('अनावश्यक' टेस्ट लिखता हूं) लेकिन ऐसा लगता है कि कोडगॉल्फ के सोचने के तरीके के खिलाफ है, और जो लोग उन्हें लिखते हैं उन्हें "गंभीर" नहीं माना जाता है ...

— रोजलाउप

1

@RosLuP लेकिन क्या नुकसान है, जब तक कि मैं अपने प्राथमिक उत्तर के रूप में न्यूनतम उत्तर देता हूं? और क्या आप ऐसे लोगों का कोई उदाहरण दे सकते हैं जो वास्तव में ऐसा सोचते हैं? मैं इसे समझ सकता था अगर मैंने अपना एकमात्र जवाब मजबूत के रूप में दिया था , लेकिन मैं ऐसा नहीं कर रहा हूं।

— डेडकोड

1

सी #, 96

यह सच के लिए -1,0,1 देता है, बाकी कुछ भी गलत है।

इसे छोटा बनाने के लिए कोई सुझाव अद्भुत होगा!

int p(int q){var r=q-1;for(var i=2;i<r&r<q+2;i++){if(i==r-1)break;if(r%i==0)r+=i=1;}return r-q;}

विस्तारित रूप:

int p(int q){
    var r=q-1;
    for(var i=2;i<r&r<q+2;i++){
        if(i==r-1)break;
        if(r%i==0)r+=i=1;
    }
    return r-q;     
}

— अनाज
स्रोत

मैं पूरी तरह यकीन नहीं है, लेकिन मुझे लगता है कि आप को दूर कर सकता है if(i==r-1)break;और के बीच बदलने forसे पाश i<rके लिए i<r-1। यह आपको 82 तक ले जाएगा।

— सियारन_मार्क

1

गोल्फस्क्रिप्ट: 26

)0\{.:i,{i\%!},,2=@|\(}3*;

स्पष्टीकरण: अंतरतम ब्लॉक {.:i,{i\%!},,2=@|\(} यह निर्धारित करता है कि क्या स्टैक के शीर्ष की जाँच की जाती है यदि स्टैक के शीर्ष से कम 2 कारक हैं। इसके बाद यह स्टैक पर दूसरे आइटम के साथ विघटित हो जाता है, जो यह बताता है कि क्या एक प्राइम को अभी तक देखा गया है। अंत में, यह स्टैक के शीर्ष पर संख्या को घटाता है।

इनपुट को बढ़ाकर शुरू करें, प्राइम-देखा स्थिति को इनिशियलाइज़ करें, और 3 बार ब्लॉक को दोहराएं। चूंकि यह दो बार घटेगा, लेकिन हमने वेतन वृद्धि से शुरू किया, यह कवर होगा n+1और n-1।

— बेन रीच
स्रोत

1

सी #, 87 97 चार्ट

bool p(int q){return new[]{q-1,q,q+1}.Any(x=>Enumerable.Range(2,Math.Abs(x-2)).All(y=>x%y!=0));}

— स्टीव क्लैंटन
स्रोत

मुझे नहीं लगता कि यह इनपुट के रूप में 1 या 2 के साथ काम करता है

— बेन रेइच

@BenReich यह नहीं था। मुझे इसे ठीक करने के लिए दस वर्ण जोड़ने पड़े :(

— स्टीव क्लेटन

1

CJam, 12 बाइट्स

CJam इस चुनौती से बहुत छोटा है, इसलिए यह उत्तर ग्रीन चेकमार्क के लिए योग्य नहीं है (जिसे वैसे भी यादृच्छिक क्रम में अद्यतन किया जाना चाहिए)। हालाँकि, यह वास्तव में काफी मजेदार था - मैंने 17 बाइट्स शुरू किए और फिर हर बार एक या दो बाइट्स बचाते हुए अपना दृष्टिकोण पूरी तरह से तीन बार बदल दिया।

{(3,f+:mp:|}

यह एक ब्लॉक है, जो सीजेएम में एक फ़ंक्शन के सबसे करीब है, जो स्टैक पर इनपुट की अपेक्षा करता है, और स्टैक पर 1 (सत्य) या 0 (मिथ्या) छोड़ देता है।

इसका परीक्षण यहां करें।

यहाँ दिया गया है कि यह कैसे काम करता है:

(3,f+:mp:|
(          "Decrement the input N.";
 3,        "Push an array [0 1 2].";
   f+      "Add each of those to N-1, to get [N-1 N N+1].";
     :mp   "Test each each element for primality, yielding 0 or 1.";
        :| "Fold bitwise OR onto the list, which gives 1 if any of them was 1.";

— मार्टिन एंडर
स्रोत

1

एफ #, 68 बाइट्स (गैर-प्रतिस्पर्धात्मक)

let p n=Seq.forall(fun x->n%x>0){2..n-1}
let m n=p(n-1)||p n||p(n+1)

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

यही कारण है कि मुझे कोड गोल्फ से प्यार है। मैं अभी भी F # से बहुत हरा हूं लेकिन मैं इस बारे में बहुत कुछ सीखता हूं कि भाषा कैसे काम करती है और इस प्रकार की चुनौतियों से क्या कर सकती है।

— Ciaran_McCarthy
स्रोत

यह गैर-प्रतिस्पर्धा क्यों है?

— निट

1

क्योंकि मुझे यकीन नहीं है कि मैं एफ # में आज कुछ भी उपयोग कर रहा हूं जो 2012 में सवाल पूछे जाने के आसपास नहीं था। मैं मानता हूं कि यह पांडित्य है - यहां तक कि पागल भी। लेकिन मैं जीने के लिए दवा सॉफ्टवेयर लिखता हूं। व्यामोह स्वस्थ है। ;)

— सियारन_मार्चार्थी

1

विकिपीडिया में F # की संस्करण तालिका देखें । आपके द्वारा आवश्यक संस्करण के आधार पर, यह प्रश्न से पुराना हो सकता है।

1

APL (Dyalog Classic) , 20 बाइट्स

0∊¯1 0 1∘+∊(∘.×⍨1↓⍳)

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

— TwiNight
स्रोत

1

रेटिना , 22 बाइट्स

$
1
^1?1?(?!(11+)\1+$)

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

इनपुट के रूप में एकरी लेता है

— TwiNight
स्रोत

एक शुद्ध रेगेक्स रेटिना समाधान 2 बाइट्स द्वारा यह धड़कता है ।

— डेडकोड

ऐसा लगता है कि हावर्ड के मन में क्या था।

— नील

1

जावा 8, 83 बाइट्स

n->n==1|p(n-1)+p(n)+p(n+1)>0int p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return--n;}

रिटर्न true/ falseसत्य / गलत मूल्यों के रूप में।

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

स्पष्टीकरण: "

n->                    // Method with integer parameter and boolean return-type
  n==1                 //  Return whether the input is 1 (edge-case)
  |p(n-1)+p(n)+p(n+1)>0//  Or if the sum of `n-1`, `n`, and `n+1` in method `p(n)` is not 0

int p(int n){          // Separated method with integer as both parameter and return-type
  for(int i=2;i<n;     //  Loop `i` in the range [2, `n`)
    n=n%i++<1?         //   If `n` is divisible by `i`
       0               //    Change `n` to 0
      :                //   Else:
       n);             //    Leave `n` as is
                       //  (After the loop `n` is either 0, 1, or unchanged,
                       //   if it's unchanged it's a prime, otherwise not)
  return--n;}          //  Return `n` minus 1

तो int p(int n)में परिणाम होगा -1के लिए n=0और गैर अभाज्य संख्या है, और का परिणाम देगा n-1के लिए n=1या अभाज्य संख्या। चूंकि p(0)+p(1)+p(2)बन जाएगा -1+0+1 = 0और झूठे वापस आ जाएगा (भले ही2 एक प्रमुख है), n=1इस दृष्टिकोण का उपयोग करके एक किनारे का मामला है।

अलग विधि के बिना एक लूप 85 बाइट्स होगा :

n->{int f=0,j=2,i,t;for(;j-->-1;f=t>1?1:f)for(t=n+j,i=2;i<t;t=t%i++<1?0:t);return f;}

रिटर्न 1/ 0सत्य / गलत मूल्यों के रूप में।

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

स्पष्टीकरण:

n->{              // Method with integer as both parameter and return-type
  int f=0,        //  Result-integer, starting at 0 (false)
      j=2,i,      //  Index integers
      t;          //  Temp integer
  for(;j-->-1;    //  Loop `j` downwards in range (2, -1]
      f=          //    After every iteration: Change `f` to:
        t>1?      //     If `t` is larger than 1 (`t` is a prime):
         1        //      Change `f` to 1 (true)
        :         //     Else:
         f)       //      Leave `f` the same
    for(t=n+j,    //   Set `t` to `n+j`
        i=2;i<t;  //   Inner loop `i` in the range [2, t)
      t=t%i++<1?  //    If `t` is divisible by `i`:
         0        //     Change `t` to 0
        :         //    Else:
         t);      //     Leave `t` the same
                  //   (If `t` is still the same after this inner loop, it's a prime;
                  //   if it's 0 or 1 instead, it's not a prime)
  return f;}      //  Return the result-integer (either 1/0 for true/false respectively)

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

1

जाप , 7 बाइट्स

´Uô2 dj
´Uô2    // Given the range [U-1..U+1],
     dj // sing "Daddy DJ", uh, I mean, check if any are a prime.

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

— लीख
स्रोत

0

आर, 68 वर्ण

f=function(n){library(gmp);i=isprime;ifelse(i(n-1)|i(n)|i(n+1),1,0)}

उपयोग (TRUE के लिए 1, FALSE के लिए 0):

f(7)
[1] 1
f(8)
[1] 1
f(15)
[1] 0

— पाओलो
स्रोत

1

मैं वास्तव में नहीं जानता कि आर कैसे काम करता है, लेकिन क्या आप i(n-1)|i(n)|i(n+1)इसके बजाय बस कर सकते हैं ifelse(i(n-1)|i(n)|i(n+1),1,0)?

— Ry-

आप सही हैं: g = function (n) {लाइब्रेरी (gmp); i = isprime; मैं (n-1) | i (n) | i (n + 1)} - नीचे 56 अक्षर तक! ;-)

— पाओलो

0

सी ++

k=3;cin>>i;i--;
while(k)
{l[k]=0;
  for(j=2;j<i;j++)
   if(!(i%j))
     l[k]++;
  k--;
  i++;
}
if(!l[1]|!l[2]|!l[3])
     cout<<"1";
else cout<<"0";

— ajobdesh
स्रोत

CodeGold.SE में आपका स्वागत है। यदि आप अन्य उत्तरों को देखते हैं, तो आप [कोड-गोल्फ] प्रश्नों के उत्तर के लिए उपयोग किए जाने वाले एक सामान्य प्रारूप को देखेंगे। आप इसे अपने उत्तरों पर भी लागू कर सकते हैं।

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा

0

क्यू, ४३ चर ३६

{any min each a mod 2_'til each a:x+-1 0 1}

{any(min')a mod 2_'(til')a:x+-1 0 1}

— tmartin
स्रोत

0

जे, 16 वर्ण

   (_2&<@-4 p:]-2:)

   (_2&<@-4 p:]-2:) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1

— randomra
स्रोत

0

अजगर, 69 67 चर

any(all(i%j for j in range(2,i))for i in range(input()-1,8**7)[:3])

8**7 > 2**20 लिखते समय थोड़ा कम है

— वैलेन्टिन ग्राहक
स्रोत

0

रूबी, 47 वर्ण लेकिन बहुत पठनीय

require'Prime'
f=->x{[x-1,x,x+1].any? &:prime?}

— दरवाज़े
स्रोत

0

सी ++ 97

बदसूरत मुझे चतुर समाधान के लिए हरा दिया है लगता है। तो वह लूप पर तीन बार दृष्टिकोण के लिए एक संक्षिप्त संस्करण है:

P(int k){int j=1;for(int i=2;i<k;){j=k%i++&&j;}return j;}
a(int b){return P(b)|P(b+1)|P(b-1);}

— नाथन कूपर
स्रोत

0

फोर्थ (gforth) , 104 बाइट्स

: p dup 1 > if 1 over 2 ?do over i mod 0> * loop else 0 then nip ;
: f dup 1- p over 1+ p rot p + + 0< ;

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

व्याख्या

प्रधान जांच (पी)

dup 1 > if          \ if number to check if greater than 1
   1 over 2 ?do     \ place a 1 on the stack to act as a boolean and loop from 2 to n
      over i  mod   \ take the modulo of n and i
      0> *          \ check if greater than 0 (not a divisor) and multiply result by boolean
   loop             \ end the loop, result will be -1 if no divisor was found (prime)
else                \ if n is less than 2
   0                \ put 0 on the stack (not prime)
then                \ end the loop
nip                 \ drop n from the stack

मुख्य समारोह (एफ)

dup 1- p             \ get n-1 and check if prime
over 1+ p            \ get n+1 and check if prime
rot p                \ rotate stack to put n on top and check if prime
+ + 0<               \ add the three results and check if less than 0 (at least 1 was prime)

— reffu
स्रोत

0

जूलिया 0.4 , 23 बाइट्स

n->any(isprime,n-1:n+1)

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

— gggg
स्रोत

0

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

‘r’ẒẸ

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

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

‘r’ẒẸ    Monadic main link. Input: integer n
‘r’      Generate range n-1..n+1
   ẒẸ    Is any of them a prime?

— bubbler
स्रोत

नॉट-क्वाइट-प्राइम नंबर खोजना

जे, १ 17

हास्केल, 47 वर्ण

अजगर 85 80

पायथन (2.x), 85 वर्ण

रूबी (55, या 50 लंबा के रूप में)

कॉफ़ीस्क्रिप्ट (53)

सी, ११२ 112२ 72 वर्ण

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

स्टैक्स , 6 बाइट्स

जावास्क्रिप्ट (71 73 80 )

रेगेक्स (ECMAScript), 20 बाइट्स

सी #, 96

गोल्फस्क्रिप्ट: 26

सी #, 87 97 चार्ट

CJam, 12 बाइट्स

एफ #, 68 बाइट्स (गैर-प्रतिस्पर्धात्मक)

APL (Dyalog Classic) , 20 बाइट्स

रेटिना , 22 बाइट्स

जावा 8, 83 बाइट्स

जाप , 7 बाइट्स

आर, 68 वर्ण

सी ++

क्यू, ४३ चर ३६

जे, 16 वर्ण

रूबी, 47 वर्ण लेकिन बहुत पठनीय

फोर्थ (gforth) , 104 बाइट्स

व्याख्या

जूलिया 0.4 , 23 बाइट्स

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

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