introduction

L'ARN est le cousin moins connu de l'ADN. Son objectif principal est de contrôler la production de protéines dans les cellules grâce à un processus appelé traduction . Dans ce défi, votre tâche consiste à mettre en œuvre une partie de ce processus où l'ARN est divisé en codons .

Ce défi est thématique, mais se concentre sur une autre partie du processus de traduction.

Codons

Nous penserons à ARN comme une longue chaîne sur l'alphabet de paires de bases, AUCG. En traduction, l'ARN est divisé en morceaux non chevauchants de trois paires de bases, appelés codons. Le processus commence à un codon de départ , AUGet se termine à un codon d'arrêt , l' un UAA, UAGou UGA. Chaque codon (à l'exception des codons d'arrêt) correspond à un acide aminé, et la chaîne résultante d'acides aminés forme la protéine.

Contribution

Votre entrée est une chaîne d'ARN non vide.

Production

Votre sortie est la liste des codons dans lesquels l'ARN est divisé, dans n'importe quel format raisonnable. Dans ce modèle simplifié, le processus commence au codon de départ le plus à gaucheAUG , qui est inclus dans la sortie. Il se termine lorsqu'un codon d'arrêt est rencontré ou lorsque nous manquons d'ARN. Si l'entrée ne contient aucun codon de démarrage, la sortie doit être une liste vide.

Exemples

Considérez la séquence d'entrée

ACAUGGAUGGACUGUAACCCCAUGC

L'analyse commence à l'occurrence la plus à gauche de AUG, à l'index 2. Elle se poursuit comme suit:

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

Le codon marqué avec *est le codon de départ, et ceux marqués avec ^font également partie de la sortie. Le codon d'arrêt est marqué d'un +. La sortie correcte est

AUG,GAU,GGA,CUG

Pour l'entrée plus courte

ACAUGGAUGGACUGU

le processus continue

AC AUG GAU GGA CUG U
   *   ^   ^   ^

Cette fois, aucun codon d'arrêt n'est rencontré, donc le processus s'arrête lorsque nous manquons de paires de bases. La sortie est la même que ci-dessus.

Règles et notation

Vous pouvez écrire un programme complet d'une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Cas de 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

Rétine , 39 38 32 30 octets

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

Le saut de ligne arrière est important.

Sortie sous forme de liste séparée par des sauts de ligne.

Essayez-le en ligne.

Explication

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

Il s'agit d'une étape de correspondance qui transforme l'entrée en une liste séparée par des sauts de ligne de toutes les correspondances (en raison de !). Le regex lui-même correspond à chaque codon à partir du premier AUG. Nous y parvenons avec deux options distinctes. AUGcorrespond inconditionnellement, afin qu'il puisse commencer la liste des correspondances. La deuxième correspondance peut être n'importe quel codon ( ...correspond à trois caractères), mais \Gc'est une ancre spéciale qui garantit que cela ne peut correspondre que juste après une autre correspondance. Le seul problème est qu'il \Gcorrespond également au début de la chaîne, ce que nous ne voulons pas. Étant donné que l'entrée se compose uniquement de caractères de mot, nous utilisons \B(toute position qui n'est pas une limite de mot) pour nous assurer que cette correspondance n'est pas utilisée au début de l'entrée.

U(AA|AG|GA)\D*

Ceci trouve le premier codon d'arrêt, mis en correspondance U(AA|AG|GA)ainsi que tout ce qui se trouve après et le supprime de la chaîne. Puisque la première étape a divisé les codons en lignes distinctes, nous savons que cette correspondance est correctement alignée avec le codon de départ. Nous utilisons \D(non-chiffres) pour faire correspondre n'importe quel caractère, car .ne dépasserait pas les sauts de ligne et l'entrée ne contiendrait pas de chiffres.

Haskell, 115 112 octets

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

Exemple d'utilisation:

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

Comment ça fonctionne:

                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 caractères

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

Exemple d'utilisation:

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

Python 2, 185 octets

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)

Explication Définir isur entrée. Séparez-le de «AUG» jusqu'à la fin. Divisé en chaînes de trois. Vérifiez si arrêter le codon et coupez.

Essayez-le ici

MATL , 57 octets

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

Cela utilise la version actuelle (9.3.1) du langage / compilateur.

L'entrée et la sortie se font via stdin et stdout. La sortie est séparée par des sauts de ligne.

Exemple

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

EDIT (12 juin 2016): s'adapter aux changements de langue, [] doit être supprimé. Le lien ci-dessous inclut cette modification

Essayez-le en ligne!

Explication

Le code est basé sur l'expression régulière

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

Cela correspond à des sous - chaînes commençant par AUG, contenant des groupes de trois caractères ( ...) et se terminant par une ou l' autre UAA, UAGou UGA; ou se terminant à la fin de la chaîne, et dans ce cas, il peut y avoir un dernier groupe incomplet ( .?.?$). Lookahead ( (?=...)) est utilisé pour que les codons d'arrêt ne fassent pas partie de la correspondance. L'appariement est paresseux ( *?) afin de terminer au premier codon d'arrêt trouvé, le cas échéant.

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

Rubis, 97 95 78 75 62 octets

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

Je ne joue pas beaucoup au golf, donc je suis sûr que cela peut être amélioré.

Edit: Stole Borrowed Martin Büttner's excellent \B\Gtrick