Вступление

РНК является менее известным двоюродным братом ДНК. Его основная цель - контролировать производство белков в клетках с помощью процесса, называемого трансляцией . В этой задаче ваша задача - реализовать часть этого процесса, где РНК делится на кодоны .

Эта проблема тематически связана, но концентрируется на другой части процесса перевода.

кодоны

Мы будем думать о РНК как о длинной строке над алфавитом пар оснований AUCG. В переводе РНК делится на непересекающиеся куски из трех пар оснований, называемых кодонами. Процесс начинается на старт - кодона , AUGи заканчивается на стоп - кодон , один из UAA, UAGили UGA. Каждый кодон (кроме стоп-кодонов) соответствует аминокислоте, и получающаяся последовательность аминокислот образует белок.

вход

Ваш ввод является непустой строкой РНК.

Выход

Ваш вывод - это список кодонов, в которых РНК разделена, в любом приемлемом формате. В этой упрощенной модели процесс начинается с крайнего левого стартового кодона AUG, который включен в выходные данные. Он заканчивается, когда встречается стоп-кодон или когда у нас заканчивается РНК. Если на входе нет стартового кодона, на выходе должен быть пустой список.

Примеры

Рассмотрим последовательность ввода

ACAUGGAUGGACUGUAACCCCAUGC

Разбор начинается с самого левого вхождения AUG, в индексе 2. Он продолжается следующим образом:

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

Кодон, помеченный знаком, *является стартовым кодоном, и те, которые отмечены знаком ^, также являются частью выходных данных. Стоп-кодон отмечен значком +. Правильный вывод

AUG,GAU,GGA,CUG

Для более короткого ввода

ACAUGGAUGGACUGU

процесс идет

AC AUG GAU GGA CUG U
   *   ^   ^   ^

На этот раз стоп-кодон не встречается, поэтому процесс останавливается, когда у нас заканчиваются пары оснований. Вывод такой же, как указано выше.

Правила и оценки

Вы можете написать полную программу функции. Побеждает меньшее количество байтов, и стандартные лазейки запрещены.

Контрольные примеры

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

Сетчатка , 39 38 32 30 байт

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

Конечный перевод строки является значительным.

Вывести в виде списка, разделенного переводом строки.

Попробуйте онлайн.

объяснение

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

Это стадия совпадения, которая превращает ввод в список всех совпадений, разделенных переводом строки (из-за !). Само регулярное выражение соответствует каждому кодону, начиная с первого AUG. Мы достигаем этого с двумя отдельными вариантами. AUGсовпадения безоговорочно, так что он может начать список совпадений. Второе совпадение может быть любым кодоном ( ...соответствует любым трем символам), но \Gэто специальный якорь, который гарантирует, что он может совпадать только сразу после другого совпадения. Единственная проблема состоит в том, что \Gтакже совпадает в начале строки, что нам не нужно. Поскольку входные данные состоят только из символов слова, мы используем \B(любую позицию, не являющуюся границей слова), чтобы гарантировать, что это совпадение не используется в начале ввода.

U(AA|AG|GA)\D*

Он находит первый стоп-кодон, соответствующий ему, а U(AA|AG|GA)также все после него и удаляет его из строки. Поскольку на первом этапе кодоны разбиты на отдельные строки, мы знаем, что это совпадение правильно выровнено с начальным кодоном. Мы используем \D(не цифры), чтобы соответствовать любому символу, так .как не будет проходить после перевода строки, и ввод не будет содержать цифр.

Haskell, 115 112 байтов

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

Пример использования:

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

Как это устроено:

                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 символов

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

Пример использования:

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

Python 2, 185 байт

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)

Набор объясненийi для ввода. Разделите его от 'AUG' до конца. Разделить на три строки. Проверьте, не остановился ли кодон, и отрежьте.

Попробуй здесь

MATL , 57 байт

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

При этом используется текущая версия (9.3.1) языка / компилятора.

Ввод и вывод осуществляется через stdin и stdout. Вывод разделен переносами строк.

пример

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

РЕДАКТИРОВАТЬ (12 июня 2016 г.): чтобы адаптироваться к изменениям в языке, []должны быть удалены. Ссылка ниже включает эту модификацию

Попробуйте онлайн!

объяснение

Код основан на регулярном выражении

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

Это соответствует подстроки, начинающиеся с AUG , содержащие группы из трех символов ( ...) и заканчивающиеся в любом UAA, UAGили UGA; или заканчивается в конце строки, и в этом случае может быть одна последняя неполная группа ( .?.?$). Lookahead ( (?=...)) используется для того, чтобы стоп-кодоны не были частью совпадения. Соответствие выполняется lazy ( *?), чтобы завершить поиск первого найденного стоп-кодона, если он есть.

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

Рубин, 97 95 78 75 62 байта

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

Я не очень много играю в гольф, поэтому я уверен, что это можно улучшить.

Редактировать: украл отличную \B\Gуловку Мартина Бюттнера