基因组谜题的Java正则表达式

我被分配了一个问题，当给我一串字母a、C、G或T都排成一行时，比如ATGCTCTCTTTTTTTTTTTTTTTTATGTAGAGACATAAGA，我就要找到基因了。基因以ATG开始，以TAA、TAG或TGA结束（该基因不包括两个端点）。这个基因由三个字母组成，所以它的长度是三的倍数，并且这些三个字母中没有一个可以是上面列出的开始/结束三个字母。因此，上面的字符串中的基因是CTCT和CACA。事实上，我的正则表达式适用于特定的字符串。以下是我到目前为止所做的（我对自己走到这一步感到非常高兴）：

它还应该找到GGG，但没有：TTGCTTTTTTTGA（ATG | GGG | TAG）GA

---

我对regex基本上是新手，有点卡住了……只要一点提示就好了

问题是正则表达式使用了它匹配的字符，然后就不再使用它们了

您可以通过使用零宽度匹配（在这种情况下，您只获得匹配的索引，而不是匹配的字符）来解决此问题

或者，您可以使用三个类似的正则表达式，但每个表达式使用不同的偏移量：

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

（？=（{3}）+$）（？）？
你可能还想考虑使用一个不涉及正则表达式的不同方法，因为上面的正则表达式会很慢。
 < P>这样的问题是，你可以慢慢地建立正则表达式，直到有一些有用的东西。
然后你的需求发生了变化，你必须重新开始，因为对于普通人来说，要轻松地对复杂的正则表达式进行逆向工程几乎是不可能的

就我个人而言，我更愿意采用“老式”的方式——使用字符串操作。每个阶段都可以很容易地进行注释，如果需求有轻微变化，您可以调整特定阶段。
也许您应该尝试使用其他方法，如使用索引。例如：

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);
        }
}

public static final String genome=“atgctctcttgatttttttttgtagtagccatgcacataga”；
公共静态最终字符串start\u codon=“ATG”；
公共最终静态字符串[]end_密码子={“TAA”，“TAG”，“TGA”}；
公共静态void main（字符串[]args）{
Liststart_index=new ArrayList（）；
int curIndex=基因组indexOf（起始密码子）；
while（curIndex！=-1）{
开始索引。添加（curIndex）；
curIndex=基因组indexOf（起始密码子，curIndex+1）；
}
}

对其他密码子也这样做，看看索引是否符合三重态规则。顺便问一下，你确定一个基因排除了起始密码子吗？（可以在一个基因中找到一些ATG）
这里有一个可能的正则表达式：

(?=(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));
        }
    }
}

“ATGATGTAG”应该怎么办？匹配还是不匹配？+1-我现在没有时间考虑这个问题，我不知道这是否是正则表达式的适当用法，但我喜欢你将它应用于生物学中一个有趣的问题。好东西。“ATGATGTAG”不会匹配，因为ATG不可能是包含的三元组之一。实际上它是一个教科书上的问题，它告诉我排除ATG。而且，这个问题不需要正则表达式，你的解决方案是我应该做的，但我认为正则表达式将是一个有趣的挑战。
(?=(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