用程序解决经典题之十连环，JAVA版本

作为一个CRUD程序员，每天处理的事情只有增删查改。用不到任何的设计模式，程序也不能帮助我解决任何生活中的问题。

一次在算法书中看到了下面的问题。于是努力思考，并通过面向对象的思想，并最后用程序解决了问题。

题目：

1.第一个答案是B：的问题是哪一个?
A：第2题 B：第3题 C：第4题 D：第5题 E：第6题
2.唯一的连续两个具有相同答案的题是?
A：第2、3题 B：第3、4题 C：第4、5题 D：第5、6题 E：第6、7题
3.本题答案与哪一个相同?
A：第1题 B：第2题 C：第4题 D：第7题 E：第6题
4.
A：0个 B：1个 C：2个 D：3个 E：4个
5.本题答案与哪一个相同?
A：第10题 B：第9题 C：第8题 D：第7题 E：第6题
6.答案是A的题目的个数与答案是什么的个数相同?
A：B B：C C：D D：E E：都不是
7.按字母顺序,本题与下一题相差几个字母（A与B相差1个）
A：4个 B：3个 C：2个 D：1个 E：0个
8.答案是元音字母的题的个数是?
A：2个 B：3个 C：4个 D：5个 E：6个
9.答案是辅音字母的题的个数是?
A：质数 B：阶乘数 C：平方数 D：立方数 E：5的倍数
10. 
A：A B：B C：C D：D E：E

首先万物皆对象。我们分析一下这个问题涉及到什么对象，以及他们的行为

1. 试卷
   1. 检查是否所有的问题都是正确答案
   2. 如果有不符合，就尝试下一种可能性
2. 问题，
   1. 每个选项的内容的定义（JAVA语言描述）

首先定义一个Quiz 试卷的类。

public class Quiz {

    protected List<BaseProblem> problemList = new ArrayList<>();

    //按照序号取, 屏蔽细节
    protected BaseProblem getProblem(int index) {
        return problemList.get(index - 1);
    }

    public boolean tryAnswer() {

        boolean answer = true;

        for (BaseProblem p : problemList) {
            if (!p.tryAnswer()) {


                //System.out.printf("When the answer is %s.", problemList.stream().map(pt -> String.valueOf(pt.getAnswer())).collect(Collectors.joining(", ")));
                //System.out.printf(" The answer %d is incorrect. \n\n", p.index);
                return false;
            }
        }

        return answer;
    }

    public void addProgram(BaseProblem p) {
        problemList.add(p);
    }

    public static void main(String[] args) throws Exception {

        Quiz quiz = new Quiz();

        Program1 p1 = new Program1(quiz);
        Program2 p2 = new Program2(quiz);
        Program3 p3 = new Program3(quiz);
        Program4 p4 = new Program4(quiz);
        Program5 p5 = new Program5(quiz);
        Program6 p6 = new Program6(quiz);
        Program7 p7 = new Program7(quiz);
        Program8 p8 = new Program8(quiz);
        Program9 p9 = new Program9(quiz);
        Program10 p10 = new Program10(quiz);

        quiz.addProgram(p1);
        quiz.addProgram(p2);
        quiz.addProgram(p3);
        quiz.addProgram(p4);
        quiz.addProgram(p5);
        quiz.addProgram(p6);
        quiz.addProgram(p7);
        quiz.addProgram(p8);
        quiz.addProgram(p9);
        quiz.addProgram(p10);

        while (!quiz.tryAnswer()) {
            p1.testNextOption();
        }

        for (BaseProblem p : quiz.problemList) {
            System.out.printf("program %d answer is \t %s \n", p.index, p.getAnswer());
        }
    }

}

定义一个BaseProblem类

public abstract class BaseProblem {

    
    //1 for A, 2 for B, 3 for C ...
	protected int answer = 1;
	
	//0 for 1st problem
	protected int index = 0;
	protected Quiz quiz;

	public BaseProblem(Quiz quiz) {
		this.quiz = quiz;
	}

	protected BaseProblem getNextProblem() throws Exception {
		if (index == 9) {
			throw new Exception("no answer");
		}

		return quiz.getProblem(index + 1);
	}

	protected void testNextOption() throws Exception {
		if (index == 9 && this.answer == 5) {
			throw new Exception("no answer");
		}

		else if (this.answer != 5) {
			this.answer++;
		}

		else {
			this.answer = 1;
			getNextProblem().testNextOption();
		}
	}

	protected BaseProblem getProblem(int index) {
		return quiz.problemList.get(index - 1);
	}

	public char getAnswer() {
		return (char) ('A' - 1 + answer);
	}

	protected abstract boolean tryAnswer();
}

然后去实现每一道提的具体逻辑

public class Program1 extends BaseProblem {

//第一个答案是B：的问题是哪一个

	public Program1(Quiz quiz) {
		super(quiz);
		super.index = 1;
	}

	@Override
	protected boolean tryAnswer() {

        // 如果这道题的答案是A, 那么第二道问题的答案就应该是B, 如果不是的话这个选项就不对。
		if (this.answer == 1) {
			if (super.getProblem(2).answer == 2) {
				return true;
			}
		}

		if (this.answer == 2) {
			if (super.getProblem(3).answer == 2) {
				return true;
			}
		}

		if (this.answer == 3) {
			if (super.getProblem(4).answer == 2) {
				return true;
			}
		}

		if (this.answer == 4) {
			if (super.getProblem(5).answer == 2) {
				return true;
			}
		}

		if (this.answer == 5) {
			if (super.getProblem(6).answer == 2) {
				return true;
			}
		}

		return false;
	}

}

代码的面向对象程序还可以有优化的地方。但是由于当时只是想把问题解出来，就没有仔细的打磨代码。后来优化了一下抽象类的代码，但是并没有去一一实现Problem代码了。

现在已经给了第一个问题的例子代码，后面的代码就不一一贴上了。如果都实现了，最后执行main方法就可以得到最终的答案了。下面是最后的答案，如果不是这个答案，可以检查一下，自己的类是否有实现错误的地方。这个代码自己还是挺满意的。 最后找个美女当封面吧。

program 1 answer is      C 
program 2 answer is      D 
program 3 answer is      E 
program 4 answer is      B 
program 5 answer is      E 
program 6 answer is      E 
program 7 answer is      D 
program 8 answer is      C 
program 9 answer is      B 
program 10 answer is      A