कोड्स में पार्स आरएनए

Question

परिचय

आरएनए डीएनए का कम प्रसिद्ध चचेरा भाई है। इसका मुख्य उद्देश्य अनुवाद नामक एक प्रक्रिया के माध्यम से कोशिकाओं में प्रोटीन के उत्पादन को नियंत्रित करना है । इस चुनौती में, आपका कार्य इस प्रक्रिया के एक हिस्से को लागू करना है जहां आरएनए को कोडन में विभाजित किया गया है ।

यह चुनौती विषयगत रूप से संबंधित है, लेकिन अनुवाद प्रक्रिया के एक अन्य भाग पर केंद्रित है।

कोडोन

हम आरएनए को आधार जोड़े के वर्णमाला पर एक लंबी स्ट्रिंग के रूप में सोचेंगे AUCG। अनुवाद में, आरएनए को तीन बेस जोड़े के गैर-अतिव्यापी विखंडू में विभाजित किया जाता है, जिसे कोडन कहा जाता है। प्रक्रिया एक में शुरू होता है शुरूआती कोडोन , AUGहै, और एक पर समाप्त होता है स्टॉप कोडोन , में से एक UAA, UAGया UGA। प्रत्येक कोडन (स्टॉप कोडोन को छोड़कर) एक एमिनो एसिड से मेल खाती है, और परिणामस्वरूप एमिनो एसिड प्रोटीन का निर्माण करता है।

इनपुट

आपका इनपुट RNA का एक गैर-रिक्त स्ट्रिंग है।

उत्पादन

आपका आउटपुट कोडन की सूची है जिसमें आरएनए विभाजित है, किसी भी उचित प्रारूप में। इस सरलीकृत मॉडल में, प्रक्रिया सबसे बाईं ओर शुरू कोडन से शुरू AUGहोती है, जो आउटपुट में शामिल है। यह तब समाप्त होता है जब एक स्टॉप कोडन का सामना होता है, या जब हम आरएनए से बाहर निकलते हैं। यदि इनपुट में कोई प्रारंभ कोडन नहीं है, तो आउटपुट एक खाली सूची होगी।

उदाहरण

इनपुट अनुक्रम पर विचार करें

ACAUGGAUGGACUGUAACCCCAUGC

पार्सिंग सबसे बाईं ओर से शुरू होती है AUG, सूचकांक 2 पर। यह निम्नानुसार जारी है:

AC AUG GAU GGA CUG UAA CCCCAUGC
   *   ^   ^   ^   +

कोडन के साथ चिह्नित *प्रारंभ कोडन है, और जो चिह्नित ^हैं वे भी आउटपुट का हिस्सा हैं। स्टॉप कोडन के साथ चिह्नित है +। सही आउटपुट है

AUG,GAU,GGA,CUG

छोटे इनपुट के लिए

ACAUGGAUGGACUGU

प्रक्रिया चलती है

AC AUG GAU GGA CUG U
   *   ^   ^   ^

इस बार, स्टॉप कोडन का सामना नहीं किया गया है, इसलिए जब हम बेस पेयर से बाहर निकलते हैं तो यह प्रक्रिया रुक जाती है। आउटपुट ऊपर जैसा ही है।

नियम और स्कोरिंग

आप किसी फंक्शन का पूरा प्रोग्राम लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

GGUACGGAUU -> 
GGCGAAAUCGAUGCC -> AUG
ACAUGGAUGGACUGU -> AUG,GAU,GGA,CUG
AUGACGUGAUGCUUGA -> AUG,ACG
UGGUUAGAAUAAUGAGCUAG -> AUG,AGC
ACAUGGAUGGACUGUAACCCCAUGC -> AUG,GAU,GGA,CUG
CUAAGAUGGCAUGAGUAAUGAAUGGAG -> AUG,GCA
AAUGGUUUAAUAAAUGUGAUAUGAUGAUA -> AUG,GUU
UGUCACCAUGUAAGGCAUGCCCAAAAUCAG -> AUG
UAUAGAUGGUGAUGAUGCCAUGAGAUGCAUGUUAAU -> AUG,GUG,AUG,AUG,CCA
AUGCUUAUGAAUGGCAUGUACUAAUAGACUCACUUAAGCGGUGAUGAA -> AUG,CUU,AUG,AAU,GGC,AUG,UAC
UGAUAGAUGUAUGGAUGGGAUGCUCAUAGCUAUAAAUGUUAAAGUUAGUCUAAUGAUGAGUAGCCGAUGGCCUAUGAUGCUGAC -> AUG,UAU,GGA,UGG,GAU,GCU,CAU,AGC,UAU,AAA,UGU

Comments

आरएनए से प्रोटीन तक डीएनए का संबंध एक बार मुझे कंप्यूटिंग शब्दों में समझाया गया था जिसे मैं समझ सकता था: डीएनए एक हार्ड डिस्क पर एक कार्यक्रम के बराबर है; आरएनए स्मृति में लोड किए गए उस कार्यक्रम के बराबर है; और प्रोटीन उस प्रोग्राम के परिणामस्वरूप उत्पन्न आउटपुट डेटा के बराबर है।

— डिजिटल ट्रामा

आणविक जीव विज्ञान की हठधर्मिता है "डीएनए बनाता है आरएनए प्रोटीन बनाता है।" तो डीएनए काफी दुर्लभ है, और आरएनए कम प्रसिद्ध है, लेकिन कहीं अधिक सामान्य है। प्रोटीन सबसे आम है।

— लेवल रिवर सेंट

@ डायगेटल ट्रॉमा: एक आनुवांशिकता के रूप में मुझे यह इंगित करने की आवश्यकता है कि डीएनए कैसे काम करता है, इसकी वास्तविकता का वर्णन करने के लिए यह सादृश्य अपर्याप्त है। डीएनए कुछ मृत चीज नहीं है जो आरएनए में स्थानांतरित होने की प्रतीक्षा कर रहा है इसलिए यह कुछ कर सकता है।

— जैक एडली

वास्तव में व्यवहार में क्या होता है यदि एमआरएनए का एक टुकड़ा स्टॉप कोडन (सरल उदाहरण में) से पहले समाप्त हो जाता है, जिसका अर्थ है कि रिलीज कारक के लिए बाइंड स्टॉप ट्रिपल को बांधने के लिए नहीं?

— मोनिका को बहाल करना - Jan--

@ जेक हार्ड डिस्क की सामग्री जरूरी नहीं कि मृत चीजें हों - अपग्रेड, ऑटो अपडेट आदि, हालांकि निश्चित रूप से उस हद तक सेल्फ-हीलिंग नहीं कि मैं डीएनए को समझता हूं। लेकिन आप सही हैं - यह एक कमजोर सादृश्य है। हालाँकि मुझे लगता है कि यह मेरे गैर-आनुवंशिकीवादी स्वयं को एक आम आदमी की समझ से थोड़ा करीब है

— डिजिटल ट्रॉमा

Answer 1

रेटिना , 39 38 32 30 बाइट्स

M!`AUG|\B\G...
U(AA|AG|GA)\D*

अनुगामी लाइनफीड महत्वपूर्ण है।

एक लाइनफीड-पृथक सूची के रूप में आउटपुट।

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

व्याख्या

M!`AUG|\B\G...

यह मैच चरण है जो इनपुट को सभी मैचों की लाइनफीड-सेपरेटेड लिस्ट (कारण के अनुसार !) में बदल देता है। रेगेक्स खुद पहले से शुरू होने वाले हर कोडन से मेल खाता है AUG। हम इसे दो अलग-अलग विकल्पों के साथ हासिल करते हैं। AUGबिना शर्त मैच, ताकि यह मैचों की सूची शुरू कर सके। दूसरा मैच किसी भी कोडन ( ...किसी भी तीन वर्णों से मेल खाता) हो सकता है, लेकिन \Gएक विशेष एंकर है जो यह सुनिश्चित करता है कि यह केवल दूसरे मैच के लिए सही मैच हो सकता है। एकमात्र समस्या यह है कि \Gस्ट्रिंग की शुरुआत में भी मेल खाता है, जो हम नहीं चाहते हैं। चूंकि इनपुट में केवल शब्द वर्ण होते हैं, इसलिए हम \Bयह सुनिश्चित करने के लिए उपयोग करते हैं कि यह मिलान इनपुट की शुरुआत में उपयोग नहीं किया गया है।

U(AA|AG|GA)\D*

यह पहला स्टॉप कोडन, मिलान के U(AA|AG|GA)साथ-साथ उसके बाद सब कुछ पाता है और इसे स्ट्रिंग से हटा देता है। चूंकि पहले चरण में कोडों को अलग-अलग लाइनों में विभाजित किया गया था, इसलिए हम जानते हैं कि यह मैच स्टार्ट कोडन के साथ ठीक से संरेखित है। हम \Dकिसी भी वर्ण से मेल करने के लिए (गैर-अंक) का उपयोग करते हैं , क्योंकि .लाइनफ़ीड से आगे नहीं जाएंगे, और इनपुट में अंक नहीं होंगे।

Answer 2

हास्केल, 115 112 बाइट्स

import Data.Lists
fst.break(\e->elem e["UAA","UAG","UGA"]||length e<3).chunksOf 3.snd.spanList((/="AUG").take 3)

उपयोग उदाहरण:

*Main> ( fst.break(\e->elem e["UAA","UAG","UGA"]||length e<3).chunksOf 3.snd.spanList((/="AUG").take 3) ) "AUGCUUAUGAAUGGCAUGUACUAAUAGACUCACUUAAGCGGUGAUGAA"
["AUG","CUU","AUG","AAU","GGC","AUG","UAC"]

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

                spanList((/="AUG").take 3)  -- split input at the first "AUG"
             snd                            -- take 2nd part ("AUG" + rest)
     chunksOf 3                             -- split into 3 element lists
fst.break(\e->                              -- take elements from this list
           elem e["UAA","UAG","UGA"]||      -- as long as we don't see end codons
           length e<3)                      -- or run out of full codons 

Answer 3

जावास्क्रिप्ट 88 82 70 69 वर्ण

s=>/AUG(...)+?(?=(U(AA|AG|GA)|$))/.exec(s)[0].match(/.../g).join(",")

उपयोग उदाहरण:

(s=>/AUG(...)+?(?=(U(AA|AG|GA)|$))/.exec(s)[0].match(/.../g).join(","))("ACAUGGAUGGACUGUAACCCCAUGC")

Comments

क्या यह स्टॉप कोडन के बिना इनपुट के लिए विफल है?

— फ्लाम्बिनो

आप ठीक कह रहे हैं, मैंने नहीं देखा कि एक विकल्प था, फिक्सिंग

— बेंजामिन Gruenbaum

कोशिश करो s=>/AUG(...)+?(?=(U(AA|AG|GA)|$))/.exec(s)[0].match(/.../g)।

— मामा फन रोल

फिर भी कोडन को रोकने में विफल रहता है। (टेस्ट केस 3 की कोशिश करें)

— user81655

Answer 4

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

i=input()
o=[]
if i.find('AUG')>=0:i=map(''.join,zip(*[iter(i[i.find('AUG'):])]*3))
else:print "";exit()
for j in i:
 if j not in['UGA','UAA','UAG']:o+=[j]
 else:break
print ','.join(o)

व्याख्याi इनपुट पर सेट करें । इसे 'AUG' से अंत तक विभाजित करें। तीन के तारों में विभाजित करें। जाँच करें कि क्या कोडन को रोकें, और काटें।

इसे यहाँ आज़माएँ

Answer 5

MATL , 57 बाइट्स

j'AUG(...)*?(?=(UAA|UAG|UGA|.?.?$))'XXtn?1X)tnt3\-:)3[]e!

यह भाषा / संकलक के वर्तमान संस्करण (9.3.1) का उपयोग करता है ।

इनपुट और आउटपुट स्टड और स्टडआउट के माध्यम से हैं। आउटपुट को लाइनब्रेक द्वारा अलग किया जाता है।

उदाहरण

>> matl
 > j'AUG(...)*?(?=(UAA|UAG|UGA|.?.?$))'XXtn?1X)tnt3\-:)3[]e!
 >
> ACAUGGAUGGACUGUAACCCCAUGC
AUG
GAU
GGA
CUG

EDIT (12 जून, 2016): भाषा में परिवर्तन के अनुकूल होने के लिए []इसे हटा दिया जाना चाहिए। नीचे दिए गए लिंक में वह संशोधन शामिल है

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

व्याख्या

कोड नियमित अभिव्यक्ति पर आधारित है

AUG(...)*?(?=(UAA|UAG|UGA|.?.?$))

यह मैचों के साथ शुरू सबस्ट्रिंग AUG, तीन अक्षरों का समूह (युक्त ...) और या तो में समाप्त होने वाले UAA, UAGया UGA; या स्ट्रिंग के अंत में समाप्त होता है, और इस मामले में एक अंतिम अपूर्ण समूह ( .?.?$) हो सकता है । लुकहेड ( (?=...)) का उपयोग किया जाता है ताकि स्टॉप कोडन मैच का हिस्सा न हों। यदि कोई हो, तो पहले स्टॉप कोडन में मिलान खत्म करने के लिए मिलान आलसी ( *?) है।

j                                     % input string
'AUG(...)*?(?=(UAA|UAG|UGA|.?.?$))'   % regex
XX                                    % apply it. Push cell array of matched substrings
tn?                                   % if non-empty
1X)                                   % get first substring
tnt3\-:)                              % make length the largest possible multiple of 3
3[]e!                                 % reshape into rows of 3 columns
                                      % implicit endif
                                      % implicit display

Answer 6

रूबी, 97 95 78 75 62 बाइट्स

->(r){r.scan(/AUG|\B\G.../).join(?,).sub(/,U(AA|AG|GA).*/,'')}

मैं ज्यादा गोल्फ नहीं खेलता, इसलिए मुझे यकीन है कि इसमें सुधार किया जा सकता है।

संपादित करें: चुराया गया मार्टिन बंटनर की शानदार \B\Gचाल