जीनोम पहेली

Question

के लिए जावा रेगेक्स मुझे एटीजीसीटीसीटीटीजीएटीटीटीटीटीटीएटीएटीजीटीजीएसीसीटीटीटीसीएटीएसीएसीएसीएटीएजीएएए जैसे ए, सी, जी, या टी अक्षरों की एक स्ट्रिंग दी गई थी, जब मुझे जीन खोजने में समस्या थी। एटीजी के साथ एक जीन शुरू किया जाता है, और टीएए, टैग, या टीजीए के साथ समाप्त होता है (जीन दोनों अंतराल को छोड़ देता है)। जीन में अक्षरों के तीन गुना होते हैं, इसलिए इसकी लंबाई तीन में से एक है, और उनमें से कोई भी तीनों ऊपर सूचीबद्ध स्टार्ट/एंड ट्रिपलेट नहीं हो सकता है। इसलिए, इसमें जीन के ऊपर की स्ट्रिंग के लिए सीटीसीटीसीटी और सीएसीएसीएसीसीएसीएसीए हैं। और वास्तव में मेरा regex उस विशेष स्ट्रिंग के लिए काम करता है। यहाँ मैं अब तक राशि है (और मैं अपने आप को साथ बहुत खुश मैं अब तक यह मिल गया है कि कर रहा हूँ):

(?<=ATG)(([ACGT]{3}(?<!ATG))+?)(?=TAG|TAA|TGA) 

हालांकि, अगर वहाँ एक ATG और अंत त्रिक एक और परिणाम के भीतर है, और तीनो के साथ गठबंधन नहीं उस परिणाम के, यह विफल रहता है। उदाहरण के लिए:

Results for TCGAATGTTGCTTATTGTTTTGAATGGGGTAGGATGACCTGCTAATTGGGGGGGGGG : 
TTGCTTATTGTTTTGAATGGGGTAGGA 
ACCTGC 

यह भी एक GGG खोजना चाहिए लेकिन नहीं करता है: TTGCTTATTGTTTTGA (ATG | GGG | टीएजी) जीए

मैं सामान्य और एक छोटे से अटक में regex के लिए नया हूँ ... बस थोड़ा संकेत अद्भुत होगा!

Answer 1

यहाँ एक संभव regex है:

(?=(ATG((?!ATG)[ATGC]{3})*(TAA|TAG|TGA))) 

एक छोटी सी परीक्षण रिग:

public class Main { 
    public static void main(String[]args) { 
     String source = "TCGAATGTTGCTTATTGTTTTGAATGGGGTAGGATGACCTGCTAATTGGGGGGGGGGATGATGTAG"; 
     Matcher m = Pattern.compile("(?=(ATG((?!ATG)[ATGC]{3})*(TAA|TAG|TGA)))").matcher(source); 
     System.out.println("source : "+source+"\nmatches:"); 
     while(m.find()) { 
      System.out.print("   "); 
      for(int i = 0; i < m.start(); i++) { 
       System.out.print(" "); 
      } 
      System.out.println(m.group(1)); 
     } 
    } 
} 

जो पैदा करता है:

source : TCGAATGTTGCTTATTGTTTTGAATGGGGTAGGATGACCTGCTAATTGGGGGGGGGGATGATGTAG 
matches: 
      ATGTTGCTTATTGTTTTGAATGGGGTAGGATGACCTGCTAATTGGGGGGGGGGATGA 
           ATGGGGTAG 
              ATGACCTGCTAA 
                    ATGTAG 

Answer 2

समस्या यह है कि नियमित अभिव्यक्ति उन पात्रों का उपभोग करती है जो इससे मेल खाते हैं और फिर उनका उपयोग नहीं किया जाता है।

आप शून्य-चौड़ाई मैच का उपयोग करके इसे हल कर सकते हैं (इस मामले में आपको केवल मिलान का सूचकांक मिलता है, मिलान किए गए वर्ण नहीं)।

वैकल्पिक रूप से आप तीन समान रेगुलर एक्सप्रेशन का उपयोग कर सकते हैं, लेकिन प्रत्येक एक अलग का उपयोग कर ऑफसेट:

(?=(.{3})+$)(?<=ATG)(([ACGT]{3}(?<!ATG))+?)(?=TAG|TAA|TGA) 
(?=(.{3})+.$)(?<=ATG)(([ACGT]{3}(?<!ATG))+?)(?=TAG|TAA|TGA) 
(?=(.{3})+..$)(?<=ATG)(([ACGT]{3}(?<!ATG))+?)(?=TAG|TAA|TGA) 

तुम भी एक अलग दृष्टिकोण है कि ऊपर नियमित अभिव्यक्ति के रूप में नियमित अभिव्यक्ति को शामिल नहीं करता उपयोग करने पर विचार करना चाह सकते हैं होगा धीमा हो

Answer 3

इस तरह की चीजों के साथ समस्या यह है कि आप धीरे-धीरे एक नियम, नियम द्वारा नियम बना सकते हैं, जब तक कि आपके पास कुछ काम न हो।

तब आपकी आवश्यकताएं बदलती हैं और आपको फिर से शुरू करना होगा, क्योंकि केवल प्राणियों के लिए यह लगभग असंभव है कि वे एक जटिल रेगेक्स इंजीनियर को आसानी से उलट दें।

व्यक्तिगत रूप से, मैं इसे 'पुराने फैशन' तरीके से करना चाहता हूं - स्ट्रिंग मैनिपुलेशन का उपयोग करें। प्रत्येक चरण को आसानी से टिप्पणी की जा सकती है, और यदि आवश्यकताओं में मामूली परिवर्तन होता है तो आप केवल एक विशेष चरण को ट्विक कर सकते हैं।

Answer 4

शायद आपको इंडेक्स के साथ काम करने जैसी अन्य विधियों के साथ प्रयास करना चाहिए। की तरह कुछ:

public static final String genome="ATGCTCTCTTGATTTTTTTATGTGTAGCCATGCACACACACACATAAGA"; 
public static final String start_codon = "ATG"; 
public final static String[] end_codons = {"TAA","TAG","TGA"}; 

public static void main(String[] args) { 
    List<Integer>start_indexes = new ArrayList<Integer>(); 
    int curIndex = genome.indexOf(start_codon); 
     while(curIndex!=-1){ 
      start_indexes.add(curIndex); 
      curIndex = genome.indexOf(start_codon,curIndex+1); 
     } 
} 

अन्य कोडोन के लिए भी ऐसा ही है, और अगर अनुक्रमित त्रिक नियम से मेल देखें। वैसे, क्या आप निश्चित हैं कि एक जीन एक प्रारंभ कोडन को बाहर कर देता है? (कुछ ATG एक जीन में पाया जा सकता)