DNA 와 같은 RNA 는 유전 정보를 암호화하는 세포에서 발견되는 분자입니다. 염기는 아데닌 (A), 사이토 신 (C), 구아닌 (G) 및 우라실 (U)로 표시되는 뉴클레오티드 로 구성됩니다 . * 코돈 은 3 개의 뉴클레오티드 시퀀스입니다.

단백질 은 모발과 손톱에서 발견되는 각질 및 혈액 세포에서 산소를 운반하는 헤모글로빈과 같은 광범위한 기능을 수행하는 큰 분자입니다. 그들은 아미노산으로 구성 되어 있으며 RNA 분자에서 코돈으로 인코딩됩니다. 때때로 다른 코돈이 동일한 아미노산을 암호화 할 수 있습니다. 각 아미노산은 일반적으로 단일 문자로 표시됩니다. 예를 들어 H는 히스티딘을 나타냅니다.

의 시퀀스가 ​​주어지면 ACGU해당 단백질 문자열로 번역 할 수 있습니까?

^{* DNA는 ACGT로 구성되며 T는 티민입니다. DNA에서 RNA로 전사하는 동안 티민은 우라실로 대체됩니다.}

입력

입력은 ACGU대문자 로만 구성된 단일 문자열 입니다. 이 도전에 대한 함수 또는 전체 프로그램을 작성할 수 있습니다.

산출

인쇄 또는 문자열 반환을 통해 출력하도록 선택할 수 있습니다 (후자의 선택은 기능의 경우에만 사용 가능).

번역은 개시 코돈 (에서 시작해야한다 AUG,로 표현 M정지 코돈)과 끝 (중 하나 UAA, UAG또는 UGA,로 표현 *). 입력이 유효하지 않은 경우가 4 가지 있습니다.

• 입력이 시작 코돈으로 시작하지 않습니다
• 입력이 정지 코돈으로 끝나지 않습니다
• 입력 길이가 3의 배수가 아닙니다
• 입력에 끝 이외의 어딘가에 정지 코돈이 포함되어 있습니다.

이 모든 경우에 Error출력해야합니다. 정지 코돈과는 달리, 시작 코돈은 스트링 시작 후 나타날 수 있습니다.

그렇지 않으면 다음 RNA 코돈 표 를 통해 각 코돈을 해당 아미노산으로 변환해야 합니다 .

* 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*

편집 : 더 많은 테스트 사례 추가

채점

이것은 코드 골프이므로 가장 적은 바이트의 코드가 이깁니다.

^{참고 : 나는 분자 생물학의 전문가가 아니므로 아무것도 놓친 경우 자유롭게 수정하십시오. :)}

CJam ( 97 93 92 91 바이트)

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

CJam이 GolfScript에서 빌리지 않은 한 가지 놀랍게도 문자열을 정수 배열로 취급하기 때문에 이것은 약간 해시 함수가있는 내 GolfScript 솔루션의 포트입니다.

Optimizer의 제안 덕분에 6 바이트가 절약되었습니다 (내가 시도했지만 작동하지 않았다고 생각한 것에서 2 바이트 포함).

자바 스크립트 (ES6) 167 177 문자로는 UTF8에 인코딩 (167) 177 바이트

... 나는 모두가 행복하기를 바랍니다.

편집 실제로 마지막 블록에 대한 특별한 경우가 너무 짧을 필요는 없습니다. 마지막 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('')

... "KNKNTTTTRSRSIIMIQHQHPPPPRRRRLLLLEDEDAAAAGGGGVVVV * Y * YSSSS * CWCLFLF"획득

따라서 입력 문자열을 스캔하고 C 함수와 동일한 논리를 사용하여 코드 0..63과 코드에서 아미노산 char을 얻을 수 있습니다. replace 함수는 입력 문자열을 3 문자 블록으로 분할하여 결국 1 또는 2 문자를 관리하지 않습니다 ( '*'로 끝나지 않는 잘못된 결과 문자열을 제공함).

마지막으로 정규 표현식을 사용하여 인코딩 된 문자열이 유효한지 확인하십시오. 'M'으로 시작하고 '*'를 포함하지 않아야하며 '*'로 끝나야합니다.

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*

C, 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 및 Optimizer에서 사용되는 것과 유사한 룩업 테이블을 사용하는 것입니다. 그러나 해시는 G와 A가 서로 옆에 있고 U와 C가 서로 옆에 있도록 설계되었습니다.

https://en.wikipedia.org/wiki/Genetic_code#RNA_codon_table 의 테이블을 보면 이런 방식으로 정렬 된 문자를 사용하면 일반적으로 마지막 비트를 무시할 수 있습니다. 두 가지 특수한 경우를 제외하고 32 자 조회 테이블 만 필요합니다.

아래의 첫 두 글자와 해당 아미노산 (여기서 세 번째 글자는 G / A, 세 번째 글자는 U / C)을 참조하십시오. 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.
}

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의 답변에 사용 된 매핑 메커니즘을 했습니다. 나는 이것을 내 자신으로 생각해 냈지만 그는 나를 이겼다. :)

업데이트 : 패턴을 관찰하여 코돈 테이블 맵을 줄였습니다.

여기에서 온라인으로 사용해보십시오

GolfScript (103 바이트)

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

온라인 데모 (NB는 15 초 안에 실행되어야하므로 두 가지 가장 큰 테스트 사례는 포함하지 않습니다).

해부

Steve Verrill이 샌드 박스에서 지적했듯이 조회 테이블을 32 개의 요소와 2 개의 특수한 경우로 줄일 수 있습니다. 특수한 경우에는 한 번만 발생 하는 문자 ( 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

파이썬, 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]))]

파이썬 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의 제안에 따라 몇 글자를 깎았습니다.

스칼라 (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]입니다.

자바 스크립트 (ES6), 143 바이트

s=>/^M\w*\*$/.test(s=s.replace(/.../g,c=>"PVLVLHDVLGRGRAPGR*KYNVL*KTSTSGRTSILIFYNMLR*SCTSRWEQDHIFEQPAPASC.A"[parseInt(c,36)%128%65]))?s:'Error'

온라인으로 사용해보십시오!