บทนำ

RNA เป็นลูกพี่ลูกน้องที่มีชื่อเสียงน้อยกว่าของ DNA วัตถุประสงค์หลักคือการควบคุมการผลิตโปรตีนในเซลล์ผ่านกระบวนการที่เรียกว่าการแปล ในความท้าทายนี้งานของคุณคือการดำเนินการเป็นส่วนหนึ่งของกระบวนการนี้ที่อาร์เอ็นเอที่มีการแบ่งเป็นcodons

ความท้าทายนี้เกี่ยวข้องกับหัวเรื่อง แต่มุ่งเน้นที่ส่วนอื่นของกระบวนการแปล

codons

เราจะคิดว่า RNA เป็นสายยาวกว่าตัวอักษรของคู่ฐาน, AUCG. ในการแปล RNA ถูกแบ่งออกเป็นกลุ่มที่ไม่ทับซ้อนกันของคู่ฐานสามคู่ที่เรียกว่า codons กระบวนการเริ่มต้นที่codon เริ่มต้น , AUGและสิ้นสุดที่หยุด codon , หนึ่งUAA, หรือUAG UGAโคดอนแต่ละตัว (ยกเว้นสต็อปแบบหยุด) ตรงกับกรดอะมิโนและสตริงที่เกิดจากกรดอะมิโนจะเป็นโปรตีน

อินพุต

ข้อมูลที่คุณป้อนเป็นสตริงที่ไม่ว่างของ RNA

เอาท์พุต

เอาต์พุตของคุณคือรายการของ codons ที่ RNA ถูกแบ่งในรูปแบบที่เหมาะสม ในรูปแบบที่เรียบง่ายนี้กระบวนการเริ่มต้นที่codon เริ่มซ้ายสุดAUGซึ่งรวมอยู่ในผลลัพธ์ มันจะสิ้นสุดลงเมื่อพบกับการหยุด codon หรือเมื่อเราไม่มี RNA หากอินพุตไม่มีโค้ดเริ่มต้นเอาต์พุตจะเป็นรายการว่างเปล่า

ตัวอย่าง

พิจารณาลำดับการป้อนข้อมูล

ACAUGGAUGGACUGUAACCCCAUGC

การแยกวิเคราะห์เริ่มต้นที่การเกิดขึ้นซ้ายสุดAUGที่ดัชนี 2 ซึ่งจะดำเนินการดังนี้:

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

codon ที่ถูกทำเครื่องหมายด้วย*คือ codon เริ่มต้นและที่ถูกทำเครื่องหมายด้วย^นั้นก็เป็นส่วนหนึ่งของผลลัพธ์เช่นกัน หยุด codon +ถูกทำเครื่องหมายด้วย ผลลัพธ์ที่ถูกต้องคือ

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

Retina , 39 38 32 30 ไบต์

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

ตัวป้อนบรรทัดต่อท้ายมีความสำคัญ

เอาต์พุตเป็นรายการที่คั่นด้วย linefeed

ลองออนไลน์

คำอธิบาย

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

นี่คือขั้นตอนการจับคู่ซึ่งเปลี่ยนอินพุตเป็นรายการที่คั่นด้วยการป้อนบรรทัดของการแข่งขันทั้งหมด (เนื่องจาก!) regex ตัวเองตรง codon AUGเริ่มจากคนแรกที่ทุก เราบรรลุสิ่งนี้ด้วยสองตัวเลือกที่แยกจากกัน AUGจับคู่โดยไม่มีเงื่อนไขเพื่อที่จะสามารถเริ่มรายการของการแข่งขัน คู่ที่สองสามารถเป็น codon ใดก็ได้ ( ...ตรงกับตัวละครสามตัว) แต่ตัว\Gยึดนั้นพิเศษซึ่งทำให้แน่ใจได้ว่าสิ่งนี้สามารถจับคู่ได้หลังจากการจับคู่ครั้งอื่นเท่านั้น ปัญหาเดียวคือ\Gยังตรงกับจุดเริ่มต้นของสตริงที่เราไม่ต้องการ เนื่องจากอินพุตประกอบด้วยอักขระคำเท่านั้นเราจึงใช้\B(ตำแหน่งใด ๆ ที่ไม่ใช่ขอบเขตของคำ) เพื่อให้แน่ใจว่าจะไม่ใช้การจับคู่นี้ที่จุดเริ่มต้นของอินพุต

U(AA|AG|GA)\D*

สิ่งนี้จะพบ codon หยุดตัวแรกจับคู่U(AA|AG|GA)กับทุกอย่างหลังจากนั้นและลบมันออกจากสตริง เนื่องจากขั้นตอนแรกแบ่ง codon ออกเป็นบรรทัดแยกเรารู้ว่าการจับคู่นี้สอดคล้องกับ codon เริ่มต้นอย่างเหมาะสม เราใช้\D(ไม่ใช่ตัวเลข) เพื่อจับคู่อักขระใด ๆ เนื่องจาก.จะไม่ผ่าน linefeeds และอินพุตจะไม่มีตัวเลข

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' ถึงท้าย แบ่งออกเป็นสามสาย ตรวจสอบว่าหยุด codon และตัดไหม

ลองที่นี่

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 ( (?=...)) ใช้เพื่อให้ codons หยุดไม่ได้เป็นส่วนหนึ่งของการแข่งขัน การจับคู่เป็นสันหลังยาว ( *?) เพื่อให้เสร็จสิ้นในการหยุด codon แรกถ้าพบ

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 ไบต์

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

ฉันไม่ค่อยเล่นกอล์ฟมากนักดังนั้นฉันมั่นใจว่ามันจะดีขึ้นแล้ว

แก้ไข: Stole Borrowed \B\Gเคล็ดลับที่ยอดเยี่ยมของ Martin Büttner