introduzione

L'RNA è il cugino meno famoso del DNA. Il suo scopo principale è controllare la produzione di proteine ​​nelle cellule attraverso un processo chiamato traduzione . In questa sfida, il tuo compito è implementare una parte di questo processo in cui l'RNA è suddiviso in codoni .

Questa sfida è tematicamente correlata, ma si concentra su un'altra parte del processo di traduzione.

codoni

Penseremo di RNA come una lunga stringa su l'alfabeto di coppie di basi, AUCG. Nella traduzione, l'RNA è suddiviso in blocchi non sovrapposti di tre coppie di basi, chiamati codoni. Il processo inizia in un codone di inizio , AUGe termina in un codone di stop , uno UAA, UAGo UGA. Ogni codone (eccetto i codoni di stop) corrisponde a un amminoacido e la risultante serie di amminoacidi costituisce la proteina.

Ingresso

Il tuo input è una stringa non vuota di RNA.

Produzione

L'output è l'elenco di codoni in cui l'RNA è suddiviso, in qualsiasi formato ragionevole. In questo modello semplificato, il processo inizia dal codone di avvio più a sinistraAUG , incluso nell'output. Termina quando viene rilevato un codone di arresto o quando si esaurisce l'RNA. Se l'input non contiene alcun codone di avvio, l'output deve essere un elenco vuoto.

Esempi

Considera la sequenza di input

ACAUGGAUGGACUGUAACCCCAUGC

L'analisi inizia all'occorrenza più a sinistra di AUG, all'indice 2. Continua come segue:

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

Il codone contrassegnato con *è il codone iniziale e anche quelli contrassegnati con ^fanno parte dell'output. Il codone di arresto è contrassegnato da +. L'output corretto è

AUG,GAU,GGA,CUG

Per un input più breve

ACAUGGAUGGACUGU

il processo procede

AC AUG GAU GGA CUG U
   *   ^   ^   ^

Questa volta, non viene rilevato un codone di arresto, quindi il processo si interrompe quando si esauriscono le coppie di basi. L'output è lo stesso di sopra.

Regole e punteggio

È possibile scrivere un programma completo di una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

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

Retina , 39 38 32 30 byte

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

L'alimentazione di linea finale è significativa.

Output come elenco separato da avanzamento riga.

Provalo online.

Spiegazione

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

Questo è lo stadio delle partite che trasforma l'input in un elenco separato da avanzamenti di riga di tutte le partite (a causa del !). Il regex stesso corrisponde a ogni codone a partire dal primo AUG. Raggiungiamo questo obiettivo con due opzioni separate. AUGpartite incondizionatamente, in modo che possa iniziare l'elenco delle partite. La seconda corrispondenza può essere qualsiasi codone ( ...corrisponde a tre caratteri), ma \Gè un'ancora speciale che assicura che questa possa corrispondere solo dopo un'altra partita. L'unico problema è che \Gcorrisponde anche all'inizio della stringa, che non vogliamo. Poiché l'input è costituito solo da caratteri di parole, utilizziamo \B(qualsiasi posizione che non sia un limite di parole) per garantire che questa corrispondenza non venga utilizzata all'inizio dell'input.

U(AA|AG|GA)\D*

Questo trova il primo codone di stop, corrispondente U(AA|AG|GA)così come tutto ciò che lo segue e lo rimuove dalla stringa. Poiché il primo stadio ha diviso i codoni in righe separate, sappiamo che questa corrispondenza è correttamente allineata con il codone iniziale. Usiamo \D(non cifre) per abbinare qualsiasi carattere, poiché .non andrebbe oltre gli avanzamenti di riga e l'input non conterrà cifre.

Haskell, 115 112 byte

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

Esempio di utilizzo:

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

Come funziona:

                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 

JavaScript 88 82 70 69 caratteri

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

Esempio di utilizzo:

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

Python 2, 185 byte

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)

Spiegazione Impostare isu input. Dividilo da 'AGO' alla fine. Dividi in tre stringhe. Controllare se il codone di arresto e tagliare.

Provalo qui

MATL , 57 byte

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

Questo utilizza la versione corrente (9.3.1) del linguaggio / compilatore.

Input e output sono tramite stdin e stdout. L'output è separato da interruzioni di riga.

Esempio

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

EDIT (12 giugno 2016): per adattarsi ai cambiamenti nella lingua, []dovrebbe essere rimosso. Il link seguente include quella modifica

Provalo online!

Spiegazione

Il codice si basa sull'espressione regolare

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

Questo partite sottostringhe che iniziano con AUG, contenenti gruppi di tre caratteri ( ...) e termina in entrambi UAA, UAGo UGA; o termina alla fine della stringa e in questo caso potrebbe esserci un ultimo gruppo incompleto ( .?.?$). Lookahead ( (?=...)) viene utilizzato in modo che i codoni di arresto non facciano parte della corrispondenza. La corrispondenza è lazy ( *?) per finire al primo codone trovato, se presente.

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

Rubino, 97 95 78 75 62 byte

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

Non gioco molto a golf, quindi sono sicuro che può essere migliorato.

Modifica: rubato preso in prestito l'eccellente \B\Gtrucco di Martin Büttner