这是一种聪明的方法,不会核对任何东西,但只直接产生正确的案例:

1. 使用 N-2 日( s 3( N-2) 组合 ) 进行所有可能的变异 。 对于每次变异 如此获得的变异, N-1 最终字符串都会通过在每一个可能的位置上拼贴“ AA ” ( 加上在结尾的附加, 这就是为什么它是 N-1 ) 。

2. 重复 N-3 天, 并在“ LLLL” 中拼贴 。

3. 你们都完成了

EDIT

现在,我发现缺勤不必是连续的。这就使解决办法稍有改变:第一,你将独立地分为两个“A”,第一个是“A”,另一个是“A”。

EDIT 2

存在一个相当对称的额外检查, 该检查在切入时避免重复。 在两步中, 检查插入点左侧的字符。 在步骤1 中, 如果它是 an A, 则停止当前的切入迭代( 这也控制了第二个 A 的切入)。 在步骤2 中, 如果是 an L, 则转到下一个插入点( 跳过当前插入点 ) 。

这是与粗力相似的解决方案, 除非有某种优化。 想法是创建所有可能的序列组合( 不需要追加费用, 因为提醒字符串必须返回) 。 然后跟踪提醒条件( 绝对没有正则), 这样只需要检查当前字符( 见# 2) 。 一旦子字符串打开提醒, 以位置 i 表示, 函数可以在不检查提醒条件的情况下继续为 n- i 字符创建组合 。

1. Create a char array, size N, and a function that will compute the combination (3^N).
2. Create a variable numLate, which will keep track of the consecutive L in the series so far and a variable numAbsences which will keep track of the number of A in the series so far.
3. At each step during the combination, check the following:
   • If a match has already been found (match == true) continue.
   • Otherwise:
     • Check if the current character is an A , if so increment numAbsences. If numAbsences > 1, set match = true. Continue.
     • If the current character is L increment numLate, otherwise set numLate = 0. If numLate > 2, set match = true. Continue.

组合期间,当Nth字符设置时,如果 match=reaty 返回当前字符串。否则,跳过,它不是一个匹配的。如果您在最后一个字符上不检查缺勤情况,且到目前为止有0个缺勤情况,额外(最小)优化可以通过不检查缺勤情况来进行。或者,如果在最后一个字符上出现0个缺勤情况,或者,在最后两个组合字符上出现0个缺勤情况,且有0天的延迟时间。

编辑 : 我张贴一个递归( groovy) 解决方案。 例如, < code> Test. combination (0, new char[ 10], false, 0, 0, 0; 返回 55513 组合, 不确定它是否正确 。

class Test{
    public static final char[] rep = [ O ,  A ,  L ];

    public static void combination(int index, char[] arr, boolean match, int numLate, int numAbsence){
        if(index==arr.length){
            if(match)
                println arr;
            return;
        }
        for(int i=0;i<rep.length;i++){
            arr[index] = rep[i];
            if(!match){
                boolean tempMatch = match;
                int tempNumLate = numLate;
                int tempNumAbsence = numAbsence;
                switch(arr[index]){
                    case  L : tempNumLate++; break;
                    case  A : tempNumAbsence++; tempNumLate=0; break;
                    default: tempNumLate = 0; break;
                }
                if(tempNumLate > 2)
                    tempMatch = true;
                if(tempNumAbsence > 1)
                    tempMatch = true;

                combination(index+1, arr, tempMatch, tempNumLate, tempNumAbsence);
            }else{
                combination(index+1, arr, match, numLate, numAbsence);
            }
        }
    }
}

对于完全不同的事物, 这是一个生成所需的字符串, 而不是其它东西的方法。 把它看成国家机器, 并让每个函数都显示一个函数。 非常动听但直截了当 。 (如果你做了很多, 您可以很容易地安排自动生成这个代码 。)

因为我们被要求使用 Java 。 这是 Java 。 ( 我用 Perl 写了相同的代码 。 我刚刚做了一个字符串的 < code>. / code > 和 < code> > chop , 而不是 < code> StringBuilder , 它的运行速度比 Java 版本快3x。 Odd 。 )

import java.io.*;

public class ListAllAlarmedStrings {
    static StringBuilder builder;
    static int length;

    public static void main(String[] args) throws IOException {
        length = 5;
        if (args.length > 0) {
            try {
                length = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument" + " must be an integer");
                System.exit(1);
            }
        }
        builder = new StringBuilder(length);
        for (int i = 0; i < length; i++)
          builder.append("O");
        stateA(0,  A );
        stateL(0,  L );
        stateNone(0,  O );
    }

    static void stateNone (int pos, char chr) {
        if (length < pos + 3)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateNone " + pos + " " +builder.toString());
        stateA(pos + 1,  A );
        stateL(pos + 1,  L );
        stateNone(pos + 1,  O );
    }

    static void stateL (int pos, char chr) {
        if (length < pos + 3)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateL " + pos + " " +builder.toString());
        stateA(pos + 1,  A );
        stateLL(pos + 1,  L );
        stateNone(pos + 1,  O );
    }

    static void stateLL (int pos, char chr) {
        if (length < pos + 2)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateLL " + pos + " " +builder.toString());
        stateA(pos + 1,  A );
        stateAlarmed(pos + 1,  L );
        stateNone(pos + 1,  O );
    }

    static void stateA (int pos, char chr) {
        if (length < pos + 2)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateA " + pos + " " +builder.toString());
        stateAlarmed(pos + 1,  A );
        stateAL(pos + 1,  L );
        stateA(pos + 1,  O );
    }

    static void stateAL (int pos, char chr) {
        if (length < pos + 2)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateAL " + pos + " " +builder.toString());
        stateAlarmed(pos + 1,  A );
        stateALL(pos + 1,  L );
        stateA(pos + 1,  O );
    }

    static void stateALL (int pos, char chr) {
        if (length < pos + 2)
            return;
        builder.setCharAt(pos, chr);
        //System.out.println("stateALL " + pos + " " +builder.toString());
        stateAlarmed(pos + 1,  A );
        stateAlarmed(pos + 1,  L );
        stateA(pos + 1,  O );
    }

    static void stateAlarmed (int pos, char chr) {
        if (length <= pos)
            return;
        if (length == pos + 1) {
            builder.setCharAt(pos, chr);
            System.out.println(builder.toString());
            return;
        }
        builder.setCharAt(pos, chr);
        stateAlarmed(pos + 1,  A );
        stateAlarmed(pos + 1,  L );
        stateAlarmed(pos + 1,  O );
    }
}