第三届蓝桥杯JavaB组国(决)赛真题

解题代码部分来自网友，如果有不对的地方，欢迎各位大佬评论

题目1、数量周期

【结果填空】(满分9分)

复杂现象背后的推动力，可能是极其简单的原理。科学的目标之一就是发现纷繁复杂的自然现象背后的简单法则。爱因斯坦的相对论是这方面的典范例证。

很早的时候，生物学家观察某区域某种昆虫的数量（称为虫口数）之逐年变化规律，就十分迷惑：有的时候是逐渐增多达到一个平衡值。有的时候在两个数字间周期跳动。有的时候则进入一片混乱，类似随机数字一样变化（称为混沌现象）。

慢慢地，人们从数学中更清晰地观察到了这一现象，并因此开创了：符号动力学、非线性动力学等研究领域。

一个著名的虫口数目简化模型如下：

x’ = x * (1 - x) * r

这里，x x’ r 都是浮点数。

其中，x 表示当年的虫口数，x’ 表示下一年的虫口数。它们的取值范围在 0 与 1 之间，实际上表示的是：虫口的总数占环境所能支持的最大数量的比率。

r 是常数（环境参数），r的取值范围在 [0,4]。

令人惊讶的是：这个简单的迭代公式有着不同寻常的神秘性质！

一般来说，多次迭代后，虫口数的稳定模式与x的初始值无关，而与 r 有关！

例如：无论x初始值是多少，当 r = 2.5 的时候，x 多次迭代后会趋向于 0.6。

而当 r = 3.2 的时候，x 的值会趋向于在 0.799 与 0.513 之间周期性摆动。

那么，r = 3.62 的时候，你观察到有什么周期现象发生吗？

不需要提交源代码，只要写出你的结论即可！

答案写在：“解答.txt”中，不要写在这里。

x值出现混沌现象

public class Main {

    public static void main(String[] args) {
        double r = 3.62;
        double x = 0.1;
        for(int i = 1;i < 2000;i++) {
            x = x * (1 - x) * r;
            System.out.println("x = "+x);
        }
    }
}

题目2、提取子串

【代码填空】(满分12分)

    串“abcba”以字母“c”为中心左右对称；串“abba” 是另一种模式的左右对称。这两种情况我们都称这个串是镜像串。特别地，只含有1个字母的串，可以看成是第一种模式的镜像串。 

    一个串可以含有许多镜像子串。我们的目标是求一个串的最大镜像子串（最长的镜像子串），如果有多个最大镜像子串，对称中心靠左的优先选中。例如：“abcdeefghhgfeiieje444k444lmn”的最大镜像子串是：“efghhgfe”

    下面的静态方法实现了该功能，请仔细阅读并分析代码，填写空白处的代码，使得程序的逻辑合理，结果正确。

// 求最大(长度最大)镜像对称子串
public static String getMaxMirrorString(String s)
{
    String max_s = "";  // 所求的最大对称子串

    for(int i=0; i<s.length(); i++)
    {
        // 第一种对称模式
        int step = 1;
        try{
            for(;;)
            {
                if(s.charAt(i-step) != s.charAt(i+step)) break;
                step++;
            }
        }catch(Exception e){}

        String s1 = s.substring(_____________________________);     // 填空1

        // 第二种对称模式
        step = 0;
        try{
            for(;;)
            {
                if(_________________________________) break;    // 填空2
                step++;
            }
        }catch(Exception e){}

        String s2 = s.substring(i-step+1,i+step+1);

        if(s1.length() > max_s.length()) max_s = s1;
        if(s2.length() > max_s.length()) max_s = s2;
    }

    return max_s;
}

【注意】
    只填写缺少的部分，不要抄写已有的代码。
    所填写代码不超过1条语句（句中不会含有分号）
    所填代码长度不超过256个字符。
    答案写在“解答.txt”中，不要写在这里！

i-step+1, i+step
s.charAt(i-step) != s.charAt(i+step+1)

题目3、源码变换

这道题因为有一些html语言在编写的时候不会显示出来，所以就用代码格式把题目写出来

【编程题】(满分22分)

    超文本标记语言（即HTML），是用于描述网页文档的一种标记语言。

    HTML通过文本来描述文档显示出来应该具有的“样子”。它主要通过标签来定义对象的显示属性或行为。

    如果把java的源文件直接拷贝到HTML文档中，用浏览器直接打开，会发现本来整齐有序的源文件变成了一团遭。这是因为，文本中的许多回车和空格都被忽略了。而有些符号在html中有特殊的含义，引起了更复杂的局面。

    为了源文件能正常显示，我们必须为文本加上适当的标签。对特殊的符号进行转义处理。

    常用的有：
    HTML 需要转义的实体：
    &     --->  &
    空格  --->   
    <     --->  &lt;
    >     --->  &gt;
    "     --->  &quot;
    此外，根据源码的特点，可以把 TAB 转为4个空格来显示。
    TAB   --->  &nbsp;&nbsp;&nbsp;&nbsp;

    为了显示为换行，需要在行尾加<br/>标签。

    为了显示美观，对关键字加粗显示，即在关键字左右加<b>标签。比如：

    <b>public</b>

    对单行注释文本用绿色显示，可以使用<font>标签，形如：

    <font color=green>//这是我的单行注释！</font>

    注意：如果“//”出现在字符串中，则注意区分，不要错误地变为绿色。

    不考虑多行注释的问题（/* .... */ 或 /** .... */）

    你的任务是：编写程序，把给定的源文件转化为相应的html表达。

【输入、输出格式要求】

    与你的程序同一目录下，存有源文件 a.txt，其中存有标准的java源文件。要求编写程序把它转化为b.html。

    例如：目前的 a.txt 文件与 b.html 文件就是对应的。可以用记事本打开b.html查看转换后的内容。用浏览器打开b.html则可以看到显示的效果。

    注意：实际评测的时候使用的a.txt与示例是不同的。    

【注意】

    请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

    请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

    相关的工程文件不要拷入。

    请不要使用package语句。

    源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.PrintWriter;

public class Main {

    public static String process(String s) {
        StringBuilder t = new StringBuilder("");
        char[] A = s.toCharArray();
        for(int i = 0;i < A.length;i++) {
            if(A[i] == '&')
                t.append("&amp;");
            else if(A[i] == ' ')
                t.append("&nbsp;");
            else if(A[i] == '>')
                t.append("&gt;");
            else if(A[i] == '<')
                t.append("&lt;");
            else if(A[i] == '"')
                t.append("&quot;");
            else if(A[i] == '\t')
                t.append("&nbsp;&nbsp;&nbsp;&nbsp;");
            else
                t.append(A[i]);
        }
        String r = t.toString();
        r = r.replaceAll("public", "<b>public</b>");
        r = r.replaceAll("static", "<b>static</b>");
        r = r.replaceAll("class", "<b>class</b>");
        r = r.replaceAll("void", "<b>void</b>");
        int n = r.lastIndexOf("//");
        if(n != -1) {
            String temp = r.substring(n);
            r = r.replaceAll(temp, "<font color=green>"+temp+"</font>");
        }
        r = r + "<br/>\n";
        return r;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader read = new BufferedReader(new FileReader("a.txt"));
        PrintWriter psw = new PrintWriter("b.html");
        String s;
        psw.write("<html><body>\n");
        while((s = read.readLine()) != null) {
            psw.write(process(s));
        }
        psw.write("</body></html>");
        read.close();
        psw.close();
        //System.out.println("转换成功！！！");
    }
}

题目4、古代赌局

【编程题】(满分23分)

俗话说：十赌九输。因为大多数赌局的背后都藏有阴谋。不过也不尽然，有些赌局背后藏有的是：“阳谋”。

有一种赌局是这样的：桌子上放六个匣子，编号是1至6。多位参与者（以下称玩家）可以把任意数量的钱押在某个编号的匣子上。所有玩家都下注后，庄家同时掷出3个骰子（骰子上的数字都是1至6）。输赢规则如下：

1. 若某一个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目赔付（即1比1的赔率）。

1. 若有两个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的2倍赔付（即1比2的赔率）。

2. 若三个骰子上的数字都与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的6倍赔付（即1比6的赔率）。

3. 若玩家所押注匣子号与某个骰子示数乘积等于另外两个骰子示数的乘积，则玩家拿回自己的押注，庄家也不赔付（流局）。

4. 若以上规则有同时满足者，玩家可以选择对自己最有利的规则。规则执行后，则庄家收获所有匣子上剩余的押注。

乍一看起来，好像规则对玩家有利，庄家吃亏。但经过大量实战，会发现局面很难说，于是怀疑是否庄家做了手脚，庄家则十分爽快地说：可以由玩家提供骰子，甚至也可以由玩家来投掷骰子。

你的任务是：通过编程模拟该过程。模拟50万次，假定只有1个玩家，他每次的押注都是1元钱，其押注的匣子号是随机的。再假定庄家有足够的资金用于赔付。最后计算出庄家的盈率（庄家盈利金额/押注总金额）。

【输入、输出格式要求】

程序无输入，程序运行输出庄家的盈率，四舍五入保留到小数后3位。

【注意】

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

请不要使用package语句。

源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

public class Main {

    public boolean judge1(int[] A, int x) {
        for(int i = 0;i < A.length;i++)
            if(A[i] == x)
                return true;
        return false;
    }

    public boolean judge2(int[] A, int x) {
        int count = 0;
        for(int i = 0;i < A.length;i++)
            if(A[i] == x)
                count++;
        if(count >= 2)
            return true;
        return false;
    }

    public boolean judge3(int[] A, int x) {
        int count = 0;
        for(int i = 0;i < A.length;i++)
            if(A[i] == x)
                count++;
        if(count == 3)
            return true;
        return false;
    }

    public boolean judge4(int[] A, int x) {
        if(x * A[0] == A[1] * A[2])
            return true;
        if(x * A[1] == A[0] * A[2])
            return true;
        if(x * A[2] == A[0] * A[1])
            return true;
        return false;
    }

    public void getResult() {
        double won = 0;
        for(int i = 1;i <= 500000;i++) {
            int[] A = new int[3];
            for(int j = 0;j < 3;j++)
                A[j] = (int) (Math.random() * 6) + 1;
            int x = (int) (Math.random() * 6) + 1;
            if(judge3(A, x)) {
                won -= 6;
                continue;
            } else if(judge2(A, x)) {
                won -= 2;
                continue;
            } else if(judge1(A, x)) {
                won -= 1;
                continue;
            } else if(!judge4(A, x))
                won += 1;
        }
        won = won / 500000;
        System.out.printf("%.3f", won);
    }

    public static void main(String[] args) {
        Main test = new Main();
        test.getResult();
    }
}

题目5、火柴游戏

【编程题】(满分34分)

这是一个纵横火柴棒游戏。如图[1.jpg]，在3x4的格子中，游戏的双方轮流放置火柴棒。其规则是：

1. 不能放置在已经放置火柴棒的地方（即只能在空格中放置）。

2. 火柴棒的方向只能是竖直或水平放置。

3. 火柴棒不能与其它格子中的火柴“连通”。所谓连通是指两根火柴棒可以连成一条直线，且中间没有其它不同方向的火柴“阻拦”。

例如：图[1.jpg]所示的局面下，可以在C2位置竖直放置（为了方便描述格子位置，图中左、下都添加了标记），但不能水平放置，因为会与A2通。同样道理，B2，B3，D2此时两种方向都不可以放置。但如果C2竖直放置后，D2就可以水平放置了，因为不再会与A2连通（受到了C2的阻挡）。

1. 游戏双方轮流放置火柴，不可以弃权，也不可以放多根。直到某一方无法继续放置，则该方为负（输的一方）。
   
   游戏开始时可能已经放置了多根火柴。

你的任务是：编写程序，读入初始状态，计算出对自己最有利的放置方法并输出。

如图[1.jpg]的局面表示为：

00-1

-000

0100

即用“0”表示空闲位置，用“1”表示竖直放置，用“-”表示水平放置。

【输入、输出格式要求】

用户先输入整数 n(n<100), 表示接下来将输入 n 种初始局面，每种局面占3行(多个局面间没有空白行)。

程序则输出：每种初始局面情况下计算得出的最佳放置法（行号+列号+放置方式）。

例如：用户输入：

2

0111

-000

-000

1111

0010

则程序可以输出：

00-

211

不难猜出，输出结果的含义为：

对第一个局面，在第0行第0列水平放置

对第二个局面，在第2行第1列垂直放置

注意：

行号、列号都是从0开始计数的。

对每种局面可能有多个最佳放置方法（解不唯一），只输出一种即可。

例如，对第一个局面，001 也是正解；最第二个局面，201也是正解。

【注意】

请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！

请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。

相关的工程文件不要拷入。

请不要使用package语句。

源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

import java.util.Scanner;

public class Main {
    public static String[] result;

    public char[] check(char[][] map, int i, int j) {
        char[] r = {'+', '+'};
        //检测行
        boolean ring = true;
        if(j == 0) {
            if(map[i][j + 1] == '-' || (map[i][j + 1] == '0' && map[i][j + 2] == '-'))
                ring = false;
        } else if(j == 1) {
            if(map[i][j - 1] == '-' || map[i][j + 1] == '-')
                ring = false;
        } else if(j == 2) {
            if(map[i][j - 1] == '-' || (map[i][j - 1] == '0' && map[i][j - 2] == '-'))
                ring = false;
        }
        //检测列
        boolean row = true;
        if(i == 0) {
            if(map[i + 1][j] == '1' || (map[i + 1][j] == '0' && map[i + 2][j] == '1'))
                row = false;
        } else if(i == 1) {
            if(map[i - 1][j] == '1' || map[i - 1][j] == '1')
                row = false;
        } else if(i == 2) {
            if(map[i - 1][j] == '1' || (map[i - 1][j] == '0' && map[i - 2][j] == '1'))
                row = false;
        }

        if(ring == true && row == true) {
            r[0] = '1';
            r[1] = '-';
        }
        if(ring == true && row == false) {
            r[0] = '-';
            r[1] = '+';
        }
        if(ring == false && row == true) {
            r[0] = '1';
            r[1] = '+';
        }
        if(ring == false && row == false){
            r[0] = '+';
            r[1] = '+';
        }
        return r;
    }

    public int getCount(char[][] tempMap) {
        int count = 0;
        for(int i = 0;i < 3;i++)
            for(int j = 0;j < 3;j++) {
                char[] r = check(tempMap, i, j);
                if(r[0] != '+')
                    count++;
            }
        return count;
    }

    public void getResult(char[][] map, int x) {
        char[][] tempMap = new char[3][3];
        int min = Integer.MAX_VALUE;
        for(int i = 0;i < 3;i++)
            for(int j = 0;j < 3;j++)
                tempMap[i][j] = map[i][j];
        for(int i = 0;i < 3;i++) {
            for(int j = 0;j < 3;j++) {
                if(map[i][j] == '0') {
                    char[] r = check(map, i, j);
                    for(int k = 0;k < 2;k++) {
                        if(r[k] != '+') {
                            tempMap[i][j] = r[k];
                            int count = getCount(tempMap);
                            tempMap[i][j] = '0';
                            if(count < min) {
                                min = count;
                                result[x] = "" + i+ j + r[k];
                            }
                        }
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        result = new String[n];
        for(int i = 0;i < n;i++) {
            char[][] map = new char[3][3];
            String[] temp = new String[3];
            for(int j = 0;j < 3;j++) {
                temp[j] = in.next();
                map[j] = temp[j].toCharArray();
            }
            test.getResult(map, i);
        }
        for(int i = 0;i < result.length;i++)
            System.out.println(result[i]);
    }
}