डीएनए गोल्फ के लिए पाठ

चुनौती

इनपुट को डीएनए आउटपुट में परिवर्तित करें।

कलन विधि

ASCII कोड बिंदुओं में पाठ परिवर्तित करें (जैसे codegolf-> [99, 111, 100, 101, 103, 111, 108, 102])
स्ट्रिंग ASCII कोड एक साथ (जैसे 99111100101103111108102)
बाइनरी में कनवर्ट करें (उदाहरण के लिए 10100111111001101001011010001000011001101011011110000110010111111011000000110)
0वर्णों की एक समान संख्या बनाने के लिए अंत में पैड s (जैसे 101001111110011010010110100010000110011010110111100001100101111110110000001100)
बदलें 00के साथ A, 01के साथ C, 10के साथ G, और 11साथ T(जैसे GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA)
उत्पादन

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

codegolf > GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA
ppcg > GGCTAATTGTCGCACTT
} > TTGG (padding)

विशेष विवरण

यह कोड-गोल्फ है
आपके प्रोग्राम को इनपुट में रिक्त स्थान स्वीकार करना चाहिए।
आपके कार्यक्रम के लिए काम करना चाहिए codegolf।

code-golf string conversion

— यहाँ कोई नहीं हे
स्रोत

2

मुझे लगता है कि आपको एक परीक्षण मामला जोड़ना चाहिए जिसमें गद्दी व्यवहार की आवश्यकता होती है। आलसी पसंद वह होगा }जो मैं मानता हूं TTGG।

— FryAmTheEggman

3

हमें कितना बड़ा इनपुट चाहिए? 99111100101103111108102उदाहरण के लिए uint-64 से बड़ा है, इसलिए कुछ भाषाएं बड़े रूपांतरण के साथ संघर्ष कर सकती हैं।

— AdmBorkBork

4

यह नहीं है कि आप ASCII कोड को एक साथ कैसे स्ट्रिंग करते हैं यदि आप कभी भी उन्हें फिर से डिकोड करने में सक्षम होना चाहते हैं।

— user253751

@ नौबत मुझे पता है।

— NoOneIsHere

17

जेली , 15 13 बाइट्स

OVBs2UḄị“GCTA

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

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

OVBs2UḄị“GCTA    Main link. Argument: s (string)

O                Ordinal; replace each character with its code point.
 V               Eval. This converts the list to a string before evaluating, so it
                 returns the integer that results of concatenating all the digits.
  B              Binary; convert from integer to base 2.
   s2            Split into chunks of length 2.
     U           Upend; reverse the digits of each chunk.
                 Reversing means that we would have to conditionally PREPEND a zero
                 to the last chunk, which makes no difference for base conversion.
      Ḅ          Unbinary; convert each chunk from base 2 to integer.
                 `UḄ' maps:
                     [0, 1   ] -> [1,    0] -> 2
                     [1, 0(?)] -> [0(?), 1] -> 1
                     [1, 1   ] -> [1,    1] -> 3
                     [0, 0(?)] -> [0(?), 0] -> 0
       ị“GCTA    Replace each number by the character at that index.
                 Indexing is 1-based, so the indices are [1, 2, 3, 0].

— डेनिस
स्रोत

9

CJam, 24 23 बाइट्स

डेनिस के लिए धन्यवाद वास्तव में एक चतुर तरीके से 1 बाइट बचाने के लिए। :)

l:isi2b2/Wf%2fb"AGCT"f=

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

व्याख्या

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

l          e# Read input.
:i         e# Convert to character codes.
si         e# Convert to flat string and back to integer.
2b         e# Convert to binary.
2/         e# Split into pairs.
Wf%        e# Reverse each pair.
2fb        e# Convert each pair back from binary, to get a value in [0 1 2 3].
"AGCT"f=   e# Select corresponding letter for each number.

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

मुझे सीजेएम के बारे में कुछ नहीं पता है, लेकिन आपको प्रत्येक जोड़ी को उलटने की आवश्यकता क्यों है? क्या आप उन्हें सीधे बाइनरी से वापस नहीं बदल सकते हैं?

— वैल्यू इंक

@ केविनलाउ-केकेनी ने प्रत्येक जोड़ी को उलटते हुए एक समान लंबाई पाने के लिए आकर्षक शून्य से परहेज किया। उल्टे जोड़े में, आपको ज़ीरो प्रीपेंड करना होगा , जो आधार रूपांतरण के लिए कोई मायने नहीं रखता है।

— डेनिस

अच्छी चाल! यह शायद मेरे खुद के समाधान पर एक टन बाइट्स बचा सकता है अगर मैंने उस चाल के बारे में सोचा था

— मूल्य इंक

6

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

lambda s,j=''.join:j('ACGT'[int(j(t),2)]for t in
zip(*[iter(bin(int(j(`ord(c)`for c in s))*2)[2:])]*2))

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

— डेनिस
स्रोत

4

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

$_='%b0'.%$_.bytes*''
gsub(/../){:ACGT[$&.hex%7]}
chomp'0'

एक पूरा कार्यक्रम। -pझंडे के साथ भागो ।

— xsot
स्रोत

आपने भी कैसे किया ... मुझे समझ में नहीं आता

— वैल्यू इंक

4

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

तिजोरी के लिए धन्यवाद 2 बाइट्स सहेजे गए।
केविन लाउ के लिए 6 बाइट्स बचाए गए - केनी नहीं।

मुझे नफरत है कि अजगर में बाइनरी में बदलना कितना कठिन है।

def f(x):c=bin(int(''.join(map(str,map(ord,x)))))[2:];return''.join('ACGT'[int(z+y,2)]for z,y in zip(*[iter(c+'0'*(len(c)%2))]*2))

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

assert f('codegolf') == 'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'
assert f('ppcg') == 'GGCTAATTGTCGCACTT'

— मॉर्गन थ्रैप
स्रोत

ऐसा लगता है कि आपके पास दूसरे के बाद 1 अतिरिक्त जोड़ी कोष्ठक हैं''.join

— 19

@vaultah उफ़, हाँ, तुम सही हो।

— मॉर्गन थ्राप्प

का प्रयोग करें 'ACGT'[int(z+y,2)]बजाय, सीधे द्विआधारी से बाहर परिवर्तित करने के बजाय अपनी लंबे समय तक स्ट्रिंग का उपयोग और आधार 10 इसके अलावा से परिवर्तित, अनिश्चित कितना अंतर यह होगा लेकिन का उपयोग करने में लग रहे re.subअपने गन्दा के बजाय चाल में शामिल होने?

— मूल्य स्याही 19

@ केविनलाउ-केकेनी ओउओ, धन्यवाद। मैं भूल गया आप के साथ एक आधार निर्दिष्ट कर सकते हैं int। मैं देखूंगा re.sub, सुझाव के लिए धन्यवाद।

— मॉर्गन थ्राप्प

अच्छा तरीका है, मैं आपके साथ देखे बिना लगभग (समान) बिल्कुल समान कोड के साथ आया था। :)

— बाइट कमांडर

3

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

->s{s=s.bytes.join.to_i.to_s 2;s+=?0*(s.size%2)
s.gsub(/../){"ACGT"[$&.to_i 2]}}

— मूल्य स्याही
स्रोत

समस्या जितनी सीधी है, उतनी ही अधिक बाइट्स को

— निचोड़ना संभव है

3

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

{"A","C","G","T"}[[IntegerDigits[Mod[Floor@Log2@#,2,1]#&@FromDigits[""<>ToString/@ToCharacterCode@#],4]+1]]&

इनपुट के रूप में एक स्ट्रिंग लेता है, और ठिकानों की एक सूची आउटपुट करता है।

— LegionMammal978
स्रोत

3

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

lambda v:"".join(["ACGT"[int(x,2)]for x in map(''.join,zip(*[iter((bin(int("".join([str(ord(i))for i in v])))+"0")[2:])]*2))])

— हंटर वीएल
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! मामले में आप नीचे के बारे में सोच रहे हैं, यह वही हुआ है ।

— डेनिस

2

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

sm@"ACGT"id2Pc.B*4sjkCMQ2

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

व्याख्या

Martins CJam उत्तर से गद्दी चाल को तोड़ना ।

sm @ "ACGT" id2Pc.B * 4sjkCMQ2 # Q = इनपुट

                     CMQ # Q के प्रत्येक वर्ण को उसके वर्ण कोड में मैप करता है
                  sjk # एक स्ट्रिंग में शामिल हों और एक पूर्णांक में परिवर्तित करें
              .B * 4 # मूल रूप से 4 के साथ और बाइनरी में कनवर्ट करें
             c 2 # जोड़े में विभाजित करें
            P # अंतिम जोड़ी को त्यागें
 एम # नक्शा प्रत्येक जोड़ी डी
         id2 # बाइनरी से दशमलव में जोड़े को कन्वर्ट करें
  @ "ACGT" # परिणाम का उपयोग करें ^ अनुक्रमणिका के रूप में लुकअप स्ट्रिंग में
s # परिणामी सूची को स्ट्रिंग में शामिल करें

— Denker
स्रोत

2

05AB1E , 23 बाइट्स

कोड:

SÇJb00«2÷¨C3210"TGCA"‡á

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

2

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

String a(int[]a){String s="",r=s;for(int i:a)s+=i;s=new BigInteger(s).toString(2)+0;for(int i=0,y,n=48;i<(s.length()/2)*2;r+=s.charAt(i++)==n?y==n?'A':'G':y==n?'C':'T')y=s.charAt(i++);return r;}

Ungolfed

String a(int[] a) {
    String s = "", r = s;
    for (int i : a) s += i;
    s = new BigInteger(s).toString(2) + 0;
    for (int i = 0, y, n = 48; i < (s.length() / 2) * 2; 
        r += s.charAt(i++) == n 
                 ? y == n 
                 ? 'A' 
                 : 'G' 
                 : y == n 
                 ? 'C' 
                 : 'T')
        y = s.charAt(i++);
    return r;
}

ध्यान दें

इनपुट वर्णों की एक सरणी है (जिसे स्ट्रिंग के एक रूप के रूप में गिना जाना चाहिए), पैरामीटर प्रकार का है, int[]क्योंकि एक बाइट को बचाया है char[]।

उत्पादन

Input:  codegolf
Output: GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

Input:  .
Output: GTG

Input:  }
Output: TTGG

Input:  wow
Output: TGATAGTTGTGCTG

Input:  programming puzzles
Output: GTGTCAGAGTTGAAGGCCGTTCCGCAGTGCATTTGGCTCGTCTGGTGTCTACTAGCCTGCGAGAGGAGTTACTTTGGATCCTTGACTTGT

— मार्व
स्रोत

2

MATL , 21 बाइट्स

'CGTA'joV4Y2HZa2e!XB)

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

व्याख्या

'CGTA'   % Push string to be indexed into
j        % Take input string
o        % Convert each char to its ASCII code
V        % Convert to string (*). Numbers are separated by spaces
4Y2      % Push the string '0123456789'
H        % Push number 2
Za       % Convert string (*) from base '0123456789' to base 2, ignoring spaces
2e       % Reshape into a 2-column matrix, padding with a trailing 0 if needed
!        % Transpose
XB       % Convert from binary to decimal
)        % Index into string with the DNA letters. Indexing is 1-based and modular

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

1

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

sm@"AGCT"i_d2c.BsjkCMQ2

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

व्याख्या

डेनिस के जेली जवाब से चाल उधार लेना ।

sm@"AGCT"i_d2c.BsjkCMQ2
                   CMQ   convert each character to its byte value
                sjk      convert to a string and then to integer
              .B         convert to binary
             c        2  chop into pairs
 m         d             for each pair:
          _                  reverse it
         i  2                convert from binary to integer
  @"AGCT"                    find its position in "AGCT"
s                        join the string

— लीक नन
स्रोत

1

ग्रूवी, 114 बाइट्स

{s->'ACGT'[(new BigInteger(((Byte[])s).join())*2).toString(2).toList().collate(2)*.with{0.parseInt(it.join(),2)}]}

स्पष्टीकरण:

{s->
    'ACGT'[ //access character from string
        (new BigInteger( //create Big Integer from string
           ((Byte[])s).join() //split string to bytes and then join to string
        ) * 2) //multiply by 2 to add 0 at the end in binary
        .toString(2) //change to binary string
        .toList() //split to characters
        .collate(2) //group characters by two
        *.with{
            0.parseInt(it.join(),2) //join every group and parse to decimal
        }
     ]
}

— क्रेज़्सटेस्टोफ़ अटालसिक
स्रोत

बहुत बढ़िया जवाब! क्या आप कृपया एक स्पष्टीकरण जोड़ सकते हैं?

— NoOneIsHere

पहला संस्करण काम नहीं कर रहा था, क्योंकि मैं एपेंड करना भूल गया था। 0. मैंने इसे ठीक कर दिया, और बाइट्स के साथ नीचे चला गया।

— Krzysztof Atłasik

1

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

s->replace(bin(BigInt(join(int(s)))),r"..?",t->"AGCT"[1+int("0b"reverse(t))])

यह अनाम फ़ंक्शन इनपुट के रूप में एक चरित्र सरणी लेता है और एक स्ट्रिंग लौटाता है।

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

— डेनिस
स्रोत

1

पायथन 2.7, 135 बाइट्स

def f(A):g=''.join;B=bin(int(g(map(str,map(ord,A)))))[2:];B+=len(B)%2*'0';return g('ACGT'[int(B[i:i+2],2)] for i in range(len(B))[::2])

Ungolfed:

def f(A):
    g = ''.join
    B = bin(int(g(map(str,map(ord,A)))))[2:] # convert string input to binary
    B += len(B)%2 * '0' # add extra 0 if necessary
    return g('ACGT'[int(B[i:i+2],2)] for i in range(len(B))[::2]) # map every two characters into 'ACGT'

उत्पादन

f('codegolf')
'GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA'

— deustice
स्रोत

@DrGreenEggsand HamDDJ में मेरा g(...)दो बार फंक्शन है, इसलिए मेरा मानना है कि इसे join2 बाइट्स के साथ बदलना होगा?

— deustice

आह, मुझे वह याद आया। मेरी गलती!

— DJMcMayhem

1

जावास्क्रिप्ट ईएस 7, 105 103 बाइट्स

s=>((+[for(c of s)c.charCodeAt()].join``).toString(2)+'0').match(/../g).map(x=>"ACGT"['0b'+x-0]).join``

ES7 हिस्सा for(c of s)हिस्सा है।

ईएस 6 संस्करण, 107 105 बाइट्स

s=>((+[...s].map(c=>c.charCodeAt()).join``).toString(2)+'0').match(/../g).map(x=>"ACGT"['0b'+x-0]).join``

अघोषित कोड

dna = (str)=>{
  var codes = +[for(c of str)c.charCodeAt()].join``;
  var binaries = (codes.toString(2)+'0').match(/../g);
  return binaries.map(x=>"ACGT"['0b'+x-0]).join``
}

पीपीसीजी पर गोल्फिंग में यह मेरा पहला प्रयास है, कुछ गलत होने पर मुझे सही करने के लिए स्वतंत्र महसूस करें।

छोटे सुधार के लिए धन्यवाद @AlexA।

— BusyBeingDelicious
स्रोत

1

यह एक अच्छा पहला गोल्फ है! चूंकि फ़ंक्शन पुनरावर्ती नहीं है और हमें नाम के लिए फ़ंक्शन की आवश्यकता नहीं है, इसलिए आपको f=2 बाइट्स को सहेजने में सक्षम होना चाहिए । :)

— एलेक्स ए

1

जे, 52 बाइट्स

 3 :'''ACGT''{~#._2,\#:".,&''x''":(,&:(":"0))/3&u:y'

उपयोग: 3 :'''ACGT''{~#._2,\#:".,&''x''":(,&:(":"0))/3&u:y' 'codegolf'==>GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA

— ljeabmreosn
स्रोत

1

आम लिस्प (लिस्पवर्क्स), 415 बाइट्स

(defun f(s)(labels((p(e f)(concatenate'string e f)))(let((b"")(d""))(dotimes(i(length s))(setf b(p b(write-to-string(char-int(elt s i))))))(setf b(write-to-string(parse-integer b):base 2))(if(oddp #1=(length b))(setf b(p b"0")))(do((j 0(+ j 2)))((= j #1#)d)(let((c(subseq b j(+ j 2))))(cond((#2=string="00"c)(setf d(p d"A")))((#2#"01"c)(setf d(p d"C")))((#2#"10"c)(setf d(p d"G")))((#2#"11"c)(setf d(p d"T")))))))))

ungolfed:

(defun f (s)
  (labels ((p (e f)
             (concatenate 'string e f)))
  (let ((b "") (d ""))
    (dotimes (i (length s))
      (setf b
            (p b
               (write-to-string
                (char-int (elt s i))))))
    (setf b (write-to-string (parse-integer b) :base 2))
    (if (oddp #1=(length b))
        (setf b (p b "0")))
      (do ((j 0 (+ j 2)))
          ((= j #1#) d)
        (let ((c (subseq b j (+ j 2))))
          (cond ((#2=string=  "00" c)
                 (setf d (p d "A")))
                ((#2# "01" c)
                 (setf d (p d "C")))
                ((#2# "10" c)
                 (setf d (p d "G")))
                ((#2# "11" c)
                 (setf d (p d "T")))))))))

उपयोग:

CL-USER 2060 > (f "}")
"TTGG"

CL-USER 2061 > (f "golf")
"TAAAAATTATCCATAAATA"

— sadfaf
स्रोत

0

पर्ल, 155 148 137 + 1 ( `-p`ध्वज) = 138 बाइट्स

#!perl -p
s/./ord$&/sge;while($_){/.$/;$s=$&%2 .$s;$t=$v="";$t.=$v+$_/2|0,$v=$_%2*5
for/./g;s/^0// if$_=$t}$_=$s;s/(.)(.)?/([A,C],[G,T])[$1][$2]/ge

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

— डेनिस इबाव
स्रोत

0

पर्ल 6, 57 + 1 ( `-p`ध्वज) = 58 बाइट्स

$_=(+[~] .ords).base(2);s:g/..?/{<A G C T>[:2($/.flip)]}/

कदम से कदम स्पष्टीकरण:

-pध्वज के कारण पर्ल 6 दुभाषिया कोड लाइन को लाइन से चलाता है, वर्तमान लाइन डालता है $_, और अंत में इसे पीछे से डालता है $_।

.ords- यदि पीरियड से पहले कुछ नहीं होता है, तो एक तरीका कहा जाता है $_। ordsविधि एक स्ट्रिंग में कोडपॉइंट्स की सूची देता है।

[~]- []एक कमी ऑपरेटर है, जो अपने कमी ऑपरेटर को कोष्ठक के बीच संग्रहीत करता है। इस मामले में, यह ~एक स्ट्रिंग संघनन ऑपरेटर है। उदाहरण के लिए, [~] 1, 2, 3के बराबर है 1 ~ 2 ~ 3।

+अपने तर्क को एक संख्या में परिवर्तित करता है, आवश्यकता होती है क्योंकि baseविधि केवल पूर्णांकों के लिए परिभाषित की जाती है।

.base(2) - आधार 2 में एक पूर्णांक को एक स्ट्रिंग में कनवर्ट करता है

$_=- के लिए परिणाम प्रदान करता है $_।

s:g/..?/{...}/- यह :gरेगेक्स ..?(एक या दो वर्णों) के किसी भी ( , वैश्विक मोड) उदाहरण की जगह एक नियमित अभिव्यक्ति है । दूसरा तर्क एक प्रतिस्थापन पैटर्न है, जो इस मामले में कोड में (पर्ल 6 में, तार और प्रतिस्थापन पैटर्न में घुंघराले ब्रैकेट को कोड के रूप में निष्पादित किया जाता है)।

$/ - एक रेगेक्स मैच चर

.flip- एक स्ट्रिंग को निष्क्रिय करता है। यह स्पष्ट रूप से $/(एक रेगेक्स मैच ऑब्जेक्ट) को एक स्ट्रिंग में परिवर्तित करता है । इसका कारण यह है कि एक एकल वर्ण 1का विस्तार किया जाना चाहिए 10, जैसा कि विरोध किया गया है 01। उस फ्लिप के कारण, सरणी में तत्वों के क्रम में जी और सी उलट गया है।

:2(...) - एक पूर्णांक में एक आधार -2 स्ट्रिंग को पार्स करता है।

<A G C T> - चार तत्वों की सरणी।

...[...] - सरणी पहुंच ऑपरेटर।

इसका क्या मतलब है? कार्यक्रम एक स्ट्रिंग में सभी कोडपॉइंट्स की सूची प्राप्त करता है, उन्हें एक साथ समेटता है, उन्हें आधार 2 में परिवर्तित करता है। फिर, यह दो या एक वर्ण के सभी उदाहरणों को एक अक्षर A, G, C, T में बदल देता है, एक संख्या के फ़्लिप प्रतिनिधित्व के आधार पर बाइनरी में।

— कोनराड बोरोस्की
स्रोत

0

हून , 148 138 बाइट्स

|*
*
=+
(scan (reel +< |=({a/@ b/tape} (weld <a> b))) dem)
`tape`(flop (turn (rip 1 (mul - +((mod (met 0 -) 2)))) |=(@ (snag +< "ACGT"))))

"एबीसी" परमाणुओं की एक सूची है। <a>सूची में गुना करते हुए, उन्हें एक नए स्ट्रिंग में एक साथ जोड़कर स्ट्रिंग्स ( ) में इंटरपोल करें । ++demएक परमाणु पर वापस लाने के लिए संख्या को पार्स करें ।

इसे पैड करने के लिए (बिट वाइज लंबाई + 1)% 2 से संख्या को गुणा करें। ++ripपरमाणु की प्रत्येक दो बाइट जोड़ी को एक सूची में अलग करने के लिए उपयोग करें , सूची पर नक्शा करें और स्ट्रिंग "एसीजीटी" में एक सूचकांक के रूप में संख्या का उपयोग करें।

> =a |*
  *
  =+
  (scan (reel +< |=({a/@ b/tape} (weld <a> b))) dem)
  `tape`(flop (turn (rip 1 (mul - +((mod (met 0 -) 2)))) |=(@ (snag +< "ACGT"))))
> (a "codegolf")
"GGCTTGCGGCCGGAGACGCGGTCTGACGCCTTGTAAATA"
> (a "ppcg")
"GGCTAATTGTCGCACTT"
> (a "}")
"TTGG"

— RenderSettings
स्रोत

डीएनए में गोल्फ टेक्स्ट

डीएनए गोल्फ के लिए पाठ

चुनौती

कलन विधि

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

विशेष विवरण

जेली , 15 13 बाइट्स

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

CJam, 24 23 बाइट्स

व्याख्या

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

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

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

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

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

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

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

व्याख्या

05AB1E , 23 बाइट्स

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

Ungolfed

ध्यान दें

उत्पादन

MATL , 21 बाइट्स

व्याख्या

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

व्याख्या

ग्रूवी, 114 बाइट्स

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

पायथन 2.7, 135 बाइट्स

उत्पादन

जावास्क्रिप्ट ईएस 7, 105 103 बाइट्स

ईएस 6 संस्करण, 107 105 बाइट्स

अघोषित कोड

जे, 52 बाइट्स

आम लिस्प (लिस्पवर्क्स), 415 बाइट्स

पर्ल, 155 148 137 + 1 ( -pध्वज) = 138 बाइट्स

पर्ल 6, 57 + 1 ( -pध्वज) = 58 बाइट्स

हून , 148 138 बाइट्स

पर्ल, 155 148 137 + 1 ( `-p`ध्वज) = 138 बाइट्स

पर्ल 6, 57 + 1 ( `-p`ध्वज) = 58 बाइट्स