प्रोटीन अनुवाद के लिए आरएनए


18

आरएनए , डीएनए की तरह, आनुवंशिक जानकारी एन्कोडिंग कोशिकाओं में पाया जाने वाला एक अणु है। इसमें न्यूक्लियोटाइड्स होते हैं , जो बेस एडेनिन (ए), साइटोसिन (सी), गुआनिन (जी) और यूरैसिल (यू) द्वारा दर्शाए जाते हैं। * एक कोडन तीन न्यूक्लियोटाइड का एक क्रम है।

प्रोटीन बड़े अणु होते हैं जो कि केरातिन जैसे कार्यों की एक विशाल श्रृंखला का प्रदर्शन करते हैं, जो बालों और नाखूनों और हीमोग्लोबिन में पाया जाता है जो रक्त कोशिकाओं में ऑक्सीजन पहुंचाता है। वे अमीनो एसिड से बने होते हैं , जो आरएनए अणुओं में कोडन के रूप में एन्कोडेड होते हैं। कभी-कभी अलग-अलग कोडन एक ही एमिनो एसिड के लिए सांकेतिक शब्दों में बदलना कर सकते हैं। प्रत्येक अमीनो एसिड को आमतौर पर एक अक्षर द्वारा दर्शाया जाता है, उदाहरण के लिए H का मतलब हिस्टिडीन होता है।

के एक क्रम को देखते हुए ACGU, क्या आप इसे संबंधित प्रोटीन स्ट्रिंग में अनुवाद कर सकते हैं?

* DNA में ACGT होता है, जहाँ T थाइमिन होता है। डीएनए से आरएनए प्रतिलेखन के दौरान, थाइमिन को यूरैसिल द्वारा प्रतिस्थापित किया जाता है।


इनपुट

इनपुट एक एकल स्ट्रिंग होगी जिसमें ACGUऊपरी मामले में केवल वर्ण होंगे । आप इस चुनौती के लिए एक कार्य या पूर्ण कार्यक्रम लिख सकते हैं।

उत्पादन

आप या तो मुद्रण या स्ट्रिंग वापस करने के माध्यम से आउटपुट चुन सकते हैं (बाद वाला विकल्प केवल एक फ़ंक्शन के मामले में उपलब्ध है)।

अनुवाद एक शुरू कोडन ( AUG, के रूप में प्रतिनिधित्व M) पर शुरू होना चाहिए और एक स्टॉप कोडन (एक UAA, UAGया UGA, के रूप में प्रतिनिधित्व *) में समाप्त होना चाहिए । चार मामले हैं जहां इनपुट अमान्य हो सकता है:

  • इनपुट एक प्रारंभ कोडन के साथ शुरू नहीं होता है
  • इनपुट एक स्टॉप कोडन के साथ समाप्त नहीं होता है
  • इनपुट की लंबाई 3 से अधिक नहीं है
  • इनपुट में अंत के अलावा कहीं और एक स्टॉप कोडन होता है

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

अन्यथा, आपको प्रत्येक कोडन को अपने संबंधित एमिनो एसिड में निम्न आरएनए कोडन तालिका के माध्यम से परिवर्तित करना चाहिए :

* UAA UAG UGA
A GCU GCC GCA GCG
C UGU UGC
D GAU GAC
E GAA GAG
F UUU UUC
G GGU GGC GGA GGG
H CAU CAC
I AUU AUC AUA
K AAA AAG
L UUA UUG CUU CUC CUA CUG
M AUG
N AAU AAC
P CCU CCC CCA CCG
Q CAA CAG
R CGU CGC CGA CGG AGA AGG
S UCU UCC UCA UCG AGU AGC
T ACU ACC ACA ACG
V GUU GUC GUA GUG
W UGG
Y UAU UAC

... और अनुवादित स्ट्रिंग आउटपुट।

उदाहरण

अमान्य मामले:

<empty string> -> Error
AUG -> Error
UAA -> Error
AUGCUAG -> Error
AAAAAAA -> Error
GGGCACUAG -> Error
AUGAACGGA -> Error
AUGUAGUGA -> Error
AUGUUUGUUCCGUCGAAAUACCUAUGAACACGCUAA -> Error

मान्य मामले:

AUGUGA -> M*
AUGAGGUGUAGCUGA -> MRCS*
AUGGGUGAGAAUGAAACGAUUUGCAGUUAA -> MGENETICS*
AUGCCAGUCGCACGAUUAGUUCACACGCUCUUGUAA -> MPVARLVHTLL*
AUGCUGCGGUCCUCGCAUCUAGCGUUGUGGUUAGGGUGUGUAACUUCGAGAACAGUGAGUCCCGUACCAGGUAGCAUAAUGCGAGCAAUGUCGUACGAUUCAUAG -> MLRSSHLALWLGCVTSRTVSPVPGSIMRAMSYDS*
AUGAAAAACAAGAAUACAACCACGACUAGAAGCAGGAGUAUAAUCAUGAUUCAACACCAGCAUCCACCCCCGCCUCGACGCCGGCGUCUACUCCUGCUUGAAGACGAGGAUGCAGCCGCGGCUGGAGGCGGGGGUGUAGUCGUGGUUUACUAUUCAUCCUCGUCUUGCUGGUGUUUAUUCUUGUUUUAA -> MKNKNTTTTRSRSIIMIQHQHPPPPRRRRLLLLEDEDAAAAGGGGVVVVYYSSSSCWCLFLF*

संपादित करें: अधिक परीक्षण मामलों को जोड़ा गया

स्कोरिंग

यह कोड गोल्फ है, इसलिए सबसे कम बाइट्स में कोड जीतता है।

नोट: मैं आणविक जीव विज्ञान में कोई विशेषज्ञ नहीं हूं, इसलिए अगर मैंने कुछ भी गलत किया है तो मुझे सही करने के लिए स्वतंत्र महसूस करें :)


1
एक उचित अनुवादक किसी भी स्ट्रिंग में खुले पढ़ने के फ्रेम को खोजने में सक्षम होना चाहिए, न कि केवल उन लोगों के साथ जो AUG से शुरू होते हैं!
कैनेडियन

@canadianer अहा यस मैं शुरू में उस पर विचार करता था, लेकिन मैं खुले रीडिंग फ्रेम (या यहां तक ​​कि एक ही स्ट्रिंग से कई प्रोटीनों का अनुवाद करके) प्रश्न को बहुत जटिल नहीं बनाना चाहता था :)
Sp3000 6

खाली स्ट्रिंग एक उपयोगी परीक्षण मामला होगा, क्योंकि यह परीक्षण के लिए कुछ दृष्टिकोणों को तोड़ देगा कि डिकोड किए गए अनुक्रम के साथ शुरू होता है Mऔर समाप्त होता है *
पीटर टेलर

@PeterTaylor जोड़ा गया, कुछ और छोटे परीक्षण मामलों के साथ :)
Sp3000 11

1
यदि आप एक वास्तविक दर्द बनना चाहते हैं, तो आप आरएनए के बजाय डीएनए का उपयोग कर सकते हैं, इसलिए आपके पास पीछे पढ़ने वाले फ्रेम भी हैं।
user137

जवाबों:


6

CJam ( 97 93 92 91 बाइट्स)

q"GACU"f#3/{4b"GGEDAAVVRSKNTTMIRRQHPPLLWC*YSSLF"{_s"MW""I*"er}%=}%s_'*/(1<"M"=*Qa=\"Error"?

यह मेरे गोल्फस्क्रिप्ट सॉल्यूशन का एक पोर्ट है, जो थोड़ा आश्चर्यचकित करने वाले हैश फ़ंक्शन के साथ है क्योंकि मेरे आश्चर्य की एक चीज जो सीजेएम ने गोल्फस्क्रिप्ट से उधार नहीं ली है, स्ट्रिंग्स को पूर्णांकों के सरणियों के रूप में मान रही है।

6 बाइट्स ने ऑप्टिमाइज़र के सुझावों के लिए धन्यवाद को बचाया (दो बाइट्स में से, जो मुझे लगा कि मैंने कोशिश की और काम नहीं किया - हुह)।


1
q"GACU"f#3/{4b"GGEDAAVVRSKNTTMIRRQHPPLLWC*YSSLF"{_s"MW""I*"er}%=}%s_'*/(1<"M"=*Q="Error"@?- 90
ऑप्टिमाइज़र

@ ऑप्टिमाइज़र, उनमें से कुछ एक सुधार प्रतीत होता है। हालाँकि, यह रनटाइम त्रुटि देता है, और इसके Qबजाय तुलना [Q]करना गलत है।
पीटर टेलर

1. आपने कोड को सही तरीके से कॉपी नहीं किया है, जब कोड टिप्पणियों में कई लाइनों को फैलाता है, तो यह लाइन ब्रेक पर एक अजीब यूनिकोड चरित्र प्राप्त करता है। फिर आपको कोड को मैन्युअल रूप से टाइप करना होगा। 2. तर्क देखें, इसे सही ढंग से काम करने के लिए बदल दिया गया है, इस प्रकार [Q]के Qपरिवर्तन सही है।
ऑप्टिमाइज़र

@ ओप्टिमाइज़र, परीक्षण के मामले की कोशिश करेंAUGUAGUGA
पीटर टेलर

1
आह ठीक है। फिर भी [Q]->Qa
ऑप्टिमाइज़र

10

जावास्क्रिप्ट (ES6) 167 177 चार्ट 167 177 बाइट्स के रूप में UTF8 में एन्कोड किए गए

... इसलिए मुझे उम्मीद है कि हर कोई खुश है।

संपादित में तथ्य, बहुत छोटा अंतिम ब्लॉक के लिए एक विशेष मामले के लिए कोई जरूरत नहीं। यदि अंतिम 2 (या 1) चार्ट मैप नहीं किए जाते हैं, तो परिणाम स्ट्रिंग '*' के साथ समाप्त नहीं होती है और यह वैसे भी त्रुटि देता है।

F=s=>/^M[^*]*\*$/.test(s=s.replace(/.../g,x=>
"KNKNTTTTRSRSIIMIQHQHPPPPRRRRLLLLEDEDAAAAGGGGVVVV*Y*YSSSS*CWCLFLF"
[[for(c of(r=0,x))r=r*4+"ACGU".search(c)]|r]))?s:'Error'

व्याख्या की

एक ट्रिपल में प्रत्येक चार में 4 मान हो सकते हैं, इसलिए वास्तव में 4 ^ 3 == 64 ट्रिपल हैं। C फ़ंक्शन 0 और 63 के बीच की संख्या के लिए प्रत्येक ट्रिपल मैप करता है। इनपुट चार्ट के रूप में आवश्यक कोई त्रुटि जांच केवल ACGU नहीं है।

C=s=>[for(c of(r=0,s))r=r*4+"ACGU".search(c)]|r

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

zz=["* UAA UAG UGA","A GCU GCC GCA GCG","C UGU UGC","D GAU GAC","E GAA GAG"
,"F UUU UUC","G GGU GGC GGA GGG","H CAU CAC","I AUU AUC AUA","K AAA AAG"
,"L UUA UUG CUU CUC CUA CUG","M AUG","N AAU AAC","P CCU CCC CCA CCG","Q CAA CAG"
,"R CGU CGC CGA CGG AGA AGG","S UCU UCC UCA UCG AGU AGC","T ACU ACC ACA ACG"
,"V GUU GUC GUA GUG","W UGG","Y UAU UAC"]
a=[],zz.map(v=>v.slice(2).split(' ').map(x=>a[C(x)]=v[0])),a.join('')

... "KNKNTTTRSRSIIMIQHQHPPPRRRRLLLLEDEDAAAAGGGGVVVV * Y * YSSSS * CWCLFLF" प्राप्त करना

इसलिए हम इनपुट स्ट्रिंग को स्कैन कर सकते हैं और कोड ०.६३ को प्राप्त करने के लिए सी फ़ंक्शन के समान तर्क का उपयोग कर सकते हैं, और कोड से एमिनोएसिड चार ले सकते हैं। प्रतिस्थापित फ़ंक्शन wil ने इनपुट स्ट्रिंग को 3 वर्ण ब्लॉक में विभाजित किया, अंततः 1 या 2 वर्णों को प्रबंधित नहीं किया (जो कि अमान्य परिणाम स्ट्रिंग देगा, '*' में समाप्त नहीं होगा)।

अंत में, जांचें कि क्या एन्कोडेड स्ट्रिंग एक रेगेक्सपी का उपयोग करके वैध है: इसे 'एम' से शुरू होना चाहिए, इसमें '*' नहीं होना चाहिए और '*' के साथ समाप्त होना चाहिए।

FireBug / FireFox कंसोल में टेस्ट करें

;['AUGCUAG','GGGCACUAG','AUGAACGGA','AUGUAGUGA','AAAAAAA',
'AUGUUUGUUCCGUCGAAAUACCUAUGAACACGCUAA',
'AUGAGGUGUAGCUGA','AUGCCAGUCGCACGAUUAGUUCACACGCUCUUGUAA',
'AUGCUGCGGUCCUCGCAUCUAGCGUUGUGGUUAGGGUGUGUAACUUCGAGAACAGUGAGUCCCGUACCAGGUAGCAUAAUGCGAGCAAUGUCGUACGAUUCAUAG']
.forEach(c=>console.log(c,'->',F(c)))

उत्पादन

AUGCUAG -> Error
GGGCACUAG -> Error
AUGAACGGA -> Error
AUGUAGUGA -> Error
AAAAAAA -> Error
AUGUUUGUUCCGUCGAAAUACCUAUGAACACGCUAA -> Error
AUGAGGUGUAGCUGA -> MRCS*
AUGCCAGUCGCACGAUUAGUUCACACGCUCUUGUAA -> MPVARLVHTLL*
AUGCUGCGGUCCUCGCAUCUAGCGUUGUGGUUAGGGUGUGUAACUUCGAGAACAGUGAGUCCCGUACCAGGUAGCAUAAUGCGAGCAAUGUCGUACGAUUCAUAG -> MLRSSHLALWLGCVTSRTVSPVPGSIMRAMSYDS*

अछा सुझाव! बस यही करने की सोच रहा था। आपने मुझे इसमें हरा दिया!
ऑप्टिमाइज़र

8

सी, 190 बाइट्स (फ़ंक्शन)

f(char*x){int a=0,i=0,j=0,s=1;for(;x[i];i%3||(s-=(x[j++]=a-37?a-9?"KNRSIITTEDGGVVAA*Y*CLFSSQHRRLLPP"[a/2]:77:87)==42,x[j]=a=0))a=a*4+(-x[i++]/2&3);puts(*x-77||i%3||s||x[j-1]-42?"Error":x);}

199 194 बाइट्स (कार्यक्रम)

a,i,j;char x[999];main(s){for(gets(x);x[i];i%3||(s-=(x[j++]=a-37?a-9?"KNRSIITTEDGGVVAA*Y*CLFSSQHRRLLPP"[a/2]:77:87)==42,x[j]=a=0))a=a*4+(-x[i++]/2&3);puts((*x-77||i%3||s||x[j-1]-42)?"Error":x);}

हैश सूत्र में सुधार करके कुछ बाइट्स को बचाया।

यहाँ एक मजेदार परीक्षण मामला है:

AUGUAUCAUGAGCUCCUUCAGUGGCAAAGACUUGACUGA --> MYHELLQWQRLD* 

व्याख्या

अक्षरों के ट्रिपल को आधार 4 नंबर में बदल दिया जाता है। प्रत्येक अक्षर निम्नानुसार हैशेड है।

x[i]       ASCII code       Hashed to (-x[i]/2&3) 
A        64+ 1  1000001            00   
G        64+ 7  1000111            01
U        64+21  1010101            10   
C        64+ 3  1000011            11

यह रेंज में एक नंबर देता है 0..63 । अब विचार यह है कि edc65 और ऑप्टिमाइज़र द्वारा उपयोग की जाने वाली समान लुकअप तालिका का उपयोग किया जाए। हालाँकि, हैश को इसलिए बनाया गया है ताकि G और A एक दूसरे के बगल में हों और U और C एक दूसरे के बगल में हों।

Https://en.wikipedia.org/wiki/Genetic_code#RNA_codon_table पर तालिका को देखते हुए, हम देखते हैं कि इस तरह से आदेश दिए गए अक्षरों के साथ, आमतौर पर अंतिम बिट को अनदेखा किया जा सकता है। केवल 32-वर्ण लुकअप तालिका की आवश्यकता है, दो विशेष मामलों को छोड़कर।

पहले दो अक्षरों के नीचे देखें, और संबंधित अमीनो एसिड (जहां 3 अक्षर जी / ए है, और जहां 3 अक्षर यू / सी है)। 32-वर्ण तालिका में फिट नहीं होने वाले दो विशेष मामलों के लिए सुधार हार्डकोड किए गए हैं।

     A/G U/C          A/G U/C            A/G U/C         A/G U/C  
AAX> K   N       AGX> R   S         AUX> I   I      ACX> T   T
GAX> E   D       GGX> G   G         GUX> V   V      GCX> A   A
UAX> *   Y       UGX> *   C         UUX> L   F      UCX> S   S
CAX> Q   H       CGX> R   R         CUX> L   L      CCX> P   P

Corrections for special cases (where last bit cannot be ignored)
AUG 001001=9 -->  M
UGG 100101=37-->  W

टिप्पणी कोड

गोल्फ संस्करण में i%3कोड forकोष्ठक की वृद्धि की स्थिति में होता है , लेकिन यह टिप्पणी कोड में अधिक पठनीय स्थिति में चला जाता है।

a,i,j;char x[999];                                                             //Array x used for storing both input and output. i=input pointer, j=output pointer.
main(s){                                                                       //s is commandline string count. if no arguments, will be set to zero. Will be used to count stops.
  for(gets(x);x[i];)                                                           //Get a string, loop until end of string (zero byte) found
    a=a*4+(-x[i++]/2&3),                                                       //Hash character x[i] to a number 0-3. leftshift any value already in a and add the new value. Increment i.
    i%3||(                                                                     //if i divisible by 3,
      s-=(x[j++]=a-37?a-9?"KNRSIITTEDGGVVAA*Y*CLFSSQHRRLLPP"[a/2]:77:87)==42,  //lookup the correct value in the table. for special cases a=24 and a=32 map to 'M' and 'W' (ASCII 77 and 87). If character is '*' (ASCII42) decrement s.   
      x[j]=a=0                                                                 //reset a to 0. clear x[j] to terminate output string.                                                     
    );   
  puts((*x-77||i%3||s||x[j-1]-42)?"Error":x);                                  //if first character not M or i not divisible by 3 or number of stops not 1 or last character not * print "Error" else print amino acid chain.
}

अगर केवल एक था O! मैंने MGENETICS*हालांकि इसके लिए एक परीक्षण मामला जोड़ा , क्योंकि यह सबसे विषयगत शब्द है जिसे मैं बना सकता था: P
Sp3000

6

CJam, 317 121 104 बाइट्स

q3/{{"ACGU"#}%4b"KN T RS IIMI QH P R L ED A G V *Y S *CWC LF"S/{_,4\/*}%s=}%_('M=\)'*=\'*/,1=**\"Error"?

यह अभी भी आगे गोल्फ हो सकता है।

अपडेट किया गयाEdc65 के उत्तर में प्रयुक्त होने वाले मैपिंग तंत्र को किया। हालाँकि मैं अपने साथ यह लेकर आया था, फिर भी उसने मुझे हरा दिया :)

अद्यतन : इसमें पैटर्न देखकर कोडन तालिका के नक्शे को छोटा किया।

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


यह टूट जाता है यदि इनपुट खाली स्ट्रिंग है।
पीटर टेलर

@PeterTaylor एक नियम जो उत्तर पोस्ट किए जाने के बाद आपके सुझाव पर जोड़ा गया था;)। मैं जल्द ही कोड को अपडेट करूंगा।
ऑप्टिमाइज़र

1
यह एक नियम नहीं था जिसे जोड़ा गया था, यह एक परीक्षण मामला था जो पहले से ही नियमों द्वारा आवश्यक था।
पीटर टेलर

3

गोल्फस्क्रिप्ट (103 बाइट्स)

{)7&2/}%3/{4base'GGEDAAVVRSKNTTMIRRQHPPLLWC*YSSLF'{..'MW'?'I*'@),+=}%=}%''+.'*'/(1<'M'=*['']=*'Error'or

ऑनलाइन डेमो (एनबी में दो सबसे बड़े परीक्षण मामले शामिल नहीं हैं क्योंकि इसे 15 सेकंड में चलाने की आवश्यकता है)।

विच्छेदन

जैसा कि स्टीव वेरिल ने सैंडबॉक्स में बताया है, लुकअप टेबल को 32 तत्वों और दो विशेष मामलों में कम किया जा सकता है। यह पता चलता है कि विशेष मामलों में दोनों वर्ण शामिल हैं ( Mऔर Wक्रमशः) जो केवल एक बार होते हैं, और वर्णों के सही मानचित्रण के साथ 4 अंकों के आधार पर एक नकल करके 32 तत्वों से पूर्ण 64-तत्व लुकअप तालिका बनाना संभव है। -और- tr:

'GGEDAAVVRSKNTTMIRRQHPPLLWC*YSSLF'  # 32-element lookup table
{                                   # Map over the 32 elements...
  .                                 #   Duplicate the element
  .'MW'?'I*'@),+=                   #   Apply tr/MW/I*/ to the duplicate
}%

फिर एक बार जब हमने डिकोड किया है, तो सत्यापन कई दृष्टिकोणों के लिए अनुमति देता है। सबसे छोटा मैंने पाया है

.'*'/       # Duplicate and split the copy around '*' retaining empty strings
(1<'M'=*    # Pull out the first string from the split (guarantee to exist even if input is
            # the empty string); if it starts with 'M' leave the rest of the split intact;
            # otherwise reduce it to the empty array
['']=       # Check whether we have ['']. If so, the split produced [prefix ''] where
            # prefix begins with 'M'. Otherwise we want an error.
*           # If we have an error case, reduce the original decoded string to ''
'Error'or   # Standard fallback mechanism

1 बाइट। चुनौती स्वीकार की गई!
ऑप्टिमाइज़र

@ ऑप्टिमाइज़र, सीजेएम के लिए एक सीधा अनुवाद कुछ अच्छे बाइट्स को बचाएगा क्योंकि इसमें बहुत सारे प्रासंगिक बिल्ट-इन हैं।
पीटर टेलर 15

मेरा हैशिंग फ़ंक्शन 57 बाइट्स लंबा है, जबकि आपका 52 साल का है। इसलिए मैं केवल 5 बाइट्स बचा सकता है ...
ऑप्टिमाइज़र

मुझे खुशी है कि सैंडबॉक्स में मेरी टिप्पणी उपयोगी थी। मुझे उम्मीद थी कि इस तथ्य का उपयोग करना संभव हो सकता है जो Mएक वैध शुरुआत के लिए परीक्षण करने के लिए विशेष मामलों में से एक था, लेकिन इसने उस तरह से काम नहीं किया है। उस तार में अभी भी 8 जोड़े समान अक्षर हैं। मुझे आश्चर्य है कि अगर उन्हें लोअरकेस अक्षरों के रूप में संकुचित किया जा सकता है: g-->GG a-->AAआदि। यदि विघटन को 8 वर्णों से कम में प्राप्त किया जा सकता है तो यह सार्थक होगा।
लेवल रिवर सेंट 20

1

पायथन, 473 बाइट्स

t={'U(A[AG]|GA)':'*','GC.':'A','UG[UC]':'C','GA[UC]':'D','GA[AG]':'E','UU[UC]':'F','GG.':'G','CA[UC]':'H','AU[UCA]':'I','AA[AG]':'K','(UU[AG]|CU.)':'L','AUG':'M','AA[UC]':'N','CC.':'P','CA[AG]':'Q','(CG.|AG[AG])':'R','(UC.|AG[UC])':'S','AC.':'T','GU.':'V','UGG':'W','UA[UC]':'Y'}
import re
i=raw_input()
a=''
for x in[i[y:y+3]for y in range(0,len(i),3)]:
 a+=[t[u]for u in t.keys()if re.match(u, x)][0]
print["Error",a][all((a[0]+a[-1]=="M*",len(i)%3==0,not"*"in a[1:-1]))]

1

पायथन 2, 370 358 354 बाइट्स

यह बिना किसी संपीड़न का उपयोग किए एक बहुत ही सीधा आगे का दृष्टिकोण है, बस जानकारी को काफी घनी रूप से पैक करने की कोशिश कर रहा है:

s=lambda x:x and[x[:3]]+s(x[3:])or[]
def f(I):O=''.join(d*any(0==x.find(p)for p in e)for x in s(I)for d,e in zip('*ACDEFGHIKLMNPQRSTVWY',map(s,'UAAUAGUGA,GC,UGUUGC,GAUGAC,GAAGAG,UUUUUC,GG,CAUCAC,AUUAUCAUA,AAAAAG,UUAUUGCU,AUG,AAUAAC,CC,CAACAG,AGAAGGCG,AGUAGCUC,AC,GU,UGG,UAUUAC'.split(','))));return['Error',O][len(I)%3==0==len(O)-O.find('*')-(O[0]=='M')]

संपादित करें: xnor के सुझाव के बाद कुछ पात्रों को शेव किया गया।


मेरा मानना ​​है कि आप sपुनरावर्ती रूप में कम लिख सकते हैं s=lambda x:x and[x[:3]]+s(x[3:])
xnor

@ एक्सनोर ग्रेट, मैंने ऐसा नहीं सोचा था। यह उस तरह से काफी काम नहीं करता है, क्योंकि पुनरावृत्ति के अंत में यह एक खाली स्ट्रिंग को आउटपुट करेगा न कि एक खाली सूची। लेकिन चार और किरदार के साथ मैं इसे काम कर सकता हूं। धन्यवाद!
एमिल

1

स्काला (317 वर्ण)

def g(c:Char)="ACGU"indexOf c;def h(s:String,i:Int)=g(s(i))*16+g(s(i+1))*4+g(s(i+2));def p(a:Int)=a!=48&&a!=50&&a!=56;def f(s:String)=if(s.length%3!=0||h(s,0)!=14||p(h(s,s.length-3)))"Error"else{var r="";for(i<-0 to s.length-3 by 3)r+="KNKNTTTTRSRSIIMIQHQHPPPPRRRRLLLLEDEDAAAAGGGGVVVV*Y*YSSSS*CWCLFLF"charAt h(s,i);r}

मुख्य कार्य है f। बेशक, एक बेहतर विकल्प एक वापसी होगी Option[String]


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.