Introducción

El ARN es el primo menos famoso del ADN. Su objetivo principal es controlar la producción de proteínas en las células a través de un proceso llamado traducción . En este desafío, su tarea es implementar una parte de este proceso donde el ARN se divide en codones .

Este desafío está relacionado temáticamente, pero se concentra en otra parte del proceso de traducción.

Codones

Vamos a pensar en el ARN como una larga cadena sobre el alfabeto de pares de bases, AUCG. En la traducción, el ARN se divide en trozos no superpuestos de tres pares de bases, llamados codones. El proceso comienza en un codón de inicio , AUGy termina en un codón de parada , uno de UAA, UAGo UGA. Cada codón (excepto los codones de parada) corresponde a un aminoácido, y la cadena de aminoácidos resultante forma la proteína.

Entrada

Su entrada es una cadena de ARN no vacía.

Salida

Su salida es la lista de codones en los que se divide el ARN, en cualquier formato razonable. En este modelo simplificado, el proceso comienza en el codón de inicio más a la izquierdaAUG , que se incluye en la salida. Termina cuando se encuentra un codón de parada o cuando se nos acaba el ARN. Si la entrada no contiene codón de inicio, la salida será una lista vacía.

Ejemplos

Considere la secuencia de entrada

ACAUGGAUGGACUGUAACCCCAUGC

El análisis comienza en la aparición más a la izquierda de AUG, en el índice 2. Continúa de la siguiente manera:

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

El codón marcado con *es el codón de inicio, y los marcados con ^también son parte de la salida. El codón de parada está marcado con +. La salida correcta es

AUG,GAU,GGA,CUG

Para la entrada más corta

ACAUGGAUGGACUGU

el proceso va

AC AUG GAU GGA CUG U
   *   ^   ^   ^

Esta vez, no se encuentra un codón de parada, por lo que el proceso se detiene cuando nos quedamos sin pares de bases. El resultado es el mismo que el anterior.

Reglas y puntaje

Puede escribir un programa completo de una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.

Casos de prueba

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 bytes

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

El avance de línea final es significativo.

Salida como una lista separada por salto de línea.

Pruébalo en línea.

Explicación

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

Esta es una etapa de coincidencia que convierte la entrada en una lista separada por saltos de línea de todas las coincidencias (debido a !). La expresión regular en sí coincide con cada codón a partir del primero AUG. Logramos esto con dos opciones separadas. AUGcoincide incondicionalmente, para que pueda iniciar la lista de coincidencias. La segunda coincidencia puede ser cualquier codón ( ...coincide con cualquiera de los tres caracteres), pero \Ges un ancla especial que garantiza que esto solo coincida inmediatamente después de otra coincidencia. El único problema es que \Gtambién coincide al principio de la cadena, que no queremos. Dado que la entrada consta solo de caracteres de palabras, usamos \B(cualquier posición que no sea un límite de palabra) para asegurar que esta coincidencia no se use al comienzo de la entrada.

U(AA|AG|GA)\D*

Esto encuentra el primer codón de parada, que coincide U(AA|AG|GA)y todo lo que está después, y lo elimina de la cadena. Dado que la primera etapa divide los codones en líneas separadas, sabemos que esta coincidencia está correctamente alineada con el codón de inicio. Usamos \D(sin dígitos) para que coincida con cualquier carácter, ya .que no pasaría los avances de línea, y la entrada no contendrá dígitos.

Haskell, 115 112 bytes

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

Ejemplo de uso:

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

Cómo funciona:

                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 caracteres

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

Ejemplo de uso:

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

Python 2, 185 bytes

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)

Explicación Establecer icomo entrada. Dividirlo desde 'AGO' hasta el final. Dividido en cuerdas de tres. Compruebe si detiene el codón y corte.

Pruébalo aquí

MATL , 57 bytes

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

Esto usa la versión actual (9.3.1) del lenguaje / compilador.

La entrada y salida son a través de stdin y stdout. La salida está separada por saltos de línea.

Ejemplo

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

EDITAR (12 de junio de 2016): para adaptarse a los cambios en el idioma, []debe eliminarse. El siguiente enlace incluye esa modificación

Pruébalo en línea!

Explicación

El código se basa en la expresión regular.

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

Esto coincide con subcadenas empezando con AUG, que contienen grupos de tres caracteres ( ...) y terminando en cualquiera UAA, UAGo UGA; o terminando al final de la cadena, y en este caso puede haber un último grupo incompleto ( .?.?$). Lookahead ( (?=...)) se usa para que los codones de detención no formen parte de la coincidencia. La coincidencia es perezosa ( *?) para terminar en el primer codón de parada encontrado, si lo hay.

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

Ruby, 97 95 78 75 62 bytes

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

No juego mucho golf, así que estoy seguro de que se puede mejorar.

Editar: Robó el excelente \B\Gtruco de Martin Büttner