第三届蓝桥杯真题决赛java本科组

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值出现混沌现象
    
 */

 

/**
*@author 杨雨婷
*@date 2019年5月12日
*/
package 第三届蓝桥杯真题决赛java本科组;

import java.util.Scanner;


//0.3 - 0.9之间摆动
public class 数量周期 {
	static double r, n = 9000;
	static double x = 0.5;
	
 // x' = x * (1 - x) * r
	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		r = sca.nextDouble();
		f(0);
   
	}
	private static void f(int ns) {
		if(ns == n) {
			return;
		}
		double x1 = x * (1 - x) * r;
		x = x1;
		if(ns > n - 100)System.out.println(x1);
		f(ns + 1);
	}

}

运行结果：

3.62
0.41766244920110246
0.880458310376949
0.3810103361157241
0.8537460847971196
0.45200662111636697
0.8966618208116621
0.3354270276755642
0.8069549671446878
0.5639187062856371
0.890210124332109
0.35380453310476656
0.8276293253626106
0.5164256710880353
0.9040233143320938
0.31408988454351866
0.7798834928748671
0.6214281341065144
0.8516238538556254
0.45742560874697835
0.8984384647781534
0.3303133790225262
0.8007673513937148
0.5775311812149071
0.883239875700705
0.37332045557592775
0.8469073007487244
0.46935227536778723
0.9015997954490225
0.321157727548998
0.789215898536113
0.6022020738028947
0.8671881447196034
0.4169257762860997
0.8800171975426849
0.3822246850499304
0.854786890182051
0.4493370704489164
0.8957084286008732
0.3381617191139041
0.8101863024401958
0.5566997371580953
0.8933622060984545
0.3448635528243523
0.8178763115829373
0.5392158349346271
0.899432868211176
0.3274412493291879
0.7972089887922813
0.585233877471472
0.8787013737948647
0.3858386755388935
0.8578212350301753
0.44150954881655785
0.8926154989756936
0.34698811326992307
0.8202462523198737
0.5337412631077744
0.9008787283332889
0.3232524075149844
0.7919122445537181
0.5965298141561892
0.8712688218238771
0.4060172522282669
0.8730254200990148
0.40128437017503166
0.8697239124303006
0.4101613074495778
0.8757830137414072
0.39380939823199984
0.864179273068063
0.4248919145847744
0.8845787673290382
0.3695990016252326
0.8434439982347673
0.478007316676992
0.903249085206519
0.3163524345139821
0.7829103295216328
0.6152615185288595
0.8569075120940454
0.44387364067523666
0.8935963910759902
0.34419640897368137
0.8171253725043592
0.5409420231725764
0.8989319776735011
0.32888886342602347
0.7990099437641104
0.5813468537792644
0.8810453355563783
0.37939211714763194
0.8523425337098074
0.45559415495901073
0.8978617977528282
0.3319756833977734
0.802799541089884
0.5730910252550353
0.8856608813383474
0.3665817782712914

并没有找到什么规律，大概是：0.3 - 0.9之间无规律摆动

2 提取子串

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

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

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

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

//求最大(长度最大)镜像对称子串

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

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

/**
*@author 杨雨婷
*@date 2019年5月12日
*/
package 第三届蓝桥杯真题决赛java本科组;

public class two_提取子串 {

	public static void main(String[] args) {
      System.out.println(getMaxMirrorString("abcdeefghhgfeiieje444k444lmn"));
	}
	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(i - step + 1,i + step );     // 填空1
		
		
		// 第二种对称模式
		step = 0;
		try{
			for(;;)
			{
				if(s.charAt(i-step ) != s.charAt(i + step + 1 )) break;    // 填空2
				step++;
			}
		}catch(Exception e){}
		
		String s2 = s.substring(i-step+1,i+step+1);
		
		System.out.println("s1 : " + s1);
		System.out.println("s2:"  + s2 );
		if(s1.length() > max_s.length()) {
			max_s = s1;
			System.out.println("s1 ");
		}
		if(s2.length() > max_s.length()) {
			max_s = s2;
			System.out.println("s2"   );
		}
		
		System.out.println();
	}

	return max_s;				
	}


}

3 源码变换

/*
【编程题】(满分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>

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

/**
*@author 杨雨婷
*@date 2019年5月13日
*/
package 第三届蓝桥杯真题决赛java本科组;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

//"C:\\Users\\ASUS\\Desktop\\17 第三届决赛\\Java本科\\3\\a.txt"
public class three_源码变换2 {

	public static void main(String[] args) throws IOException {
		 
		File fileRead = new File("C:\\Users\\ASUS\\Desktop\\17 第三届决赛\\Java本科\\3\\a.txt");
		File fileWrite = new File("C:\\Users\\ASUS\\Desktop\\b2.html");
		FileReader fileReader = new FileReader(fileRead);
		BufferedReader bufferReader = new BufferedReader(fileReader);
		FileWriter fileWriter;
		//开始读取
		String str = new String();
		fileWriter = new FileWriter(fileWrite);//html开始
		fileWriter.write("<html><body>\n");
		while((str = bufferReader.readLine()) != null) {
			int len = str.length();//答应一行
			int i = 0;
			int flag = 0;
			while(i < len) {
				char c = str.charAt(i);
				//public static void class 要加粗
				if(c == 'p' && i + 6 <= len && str.substring(i, i + 6).contains("public")) {
					fileWriter.write("<b>public</b>");
					i = i + 6;
				}
				else if(c == 's' && i + 6 <= len && str.substring(i, i + 6).contains("static")){
					fileWriter.write("<b>static</b>");
					i = i + 6;
				}
				else if(c == 'v' && i + 4 <= len && str.substring(i, i + 4).contains("void")){
					fileWriter.write("<b>void</b>");
					i = i + 4;
				}
				else if(c == 'c' && i + 5 <= len && str.substring(i, i + 5).contains("class")){
					fileWriter.write("<b>class</b>");
					i = i + 5;
				}
				//注释
				else if(c == '/' && i + 2 <= len && str.substring(i, i + 2).contains("//") 
						&& (str.substring(0, i + 1).contains(";") || !str.substring(i, len).contains(";"))){
					fileWriter.write("<font color=green>//");
					flag = 1;
					i = i + 2;
				}
				else if(c == '&') {
					fileWriter.write("&amp;");
					i++;
				}
				else if(c == ' ') {
					fileWriter.write("&nbsp;");
					i++;
				}
				else if(c == '<') {
					fileWriter.write("&lt;");
					i++;
				}
				else if(c == '>') {
					fileWriter.write("&gt;");
					i++;
				}
				else if(c == '"') {
					fileWriter.write("&quot;");
					i++;
				}
				else if(c == '	') {
					fileWriter.write("&nbsp;&nbsp;&nbsp;&nbsp;");
					i++;
				}
				else {
					fileWriter.write(c);
					i ++;
				}
				
			
			}
			if(flag == 1) {
				fileWriter.write("</font>");
			}
			fileWriter.write("<br/>\n");
		}
		fileWriter.write("</body></html>");//html结束
		fileWriter.close();
		fileReader.close();
	}

}

主要考到文件读写，还有前端的知识。也可以检查考生对新事物的接受与处理能力。 

4 古代赌局

/*
【编程题】(满分23分)

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

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

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

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

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

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

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

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

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

【输入、输出格式要求】

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

【注意】

    请仔细调试！您的程序只有能运行出正确结果的时候才有机会得分！
    
    请把所有类写在同一个文件中，调试好后，存入与【考生文件夹】下对应题号的“解答.txt”中即可。
    
 */

/**
*@author 杨雨婷
*@date 2019年5月13日
*/
package 第三届蓝桥杯真题决赛java本科组;

import java.util.Random;


public class four_古代赌局 {
	static int n = 500000;
    static int sum = 0;
	public static void main(String[] args) {
		Long start = System.currentTimeMillis();		
        Random send = new Random();//随机种子
		int a,b,c,d,sum=0;		 
		 for(int i=0;i<500000;i++)		  
		{
		  /**
		   * Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值，是Java语言常用代码。例如：double a=Math.random()*(3-1)+1，设置一个随机1到3的变量。
		   */
			 a=(int) (Math.random()*6)+1; //玩家压的数
	
			 b=(int) (Math.random()*6)+1; //庄家投的三个骰子
	
	    	 c=(int) (Math.random()*6)+1;
		  
	    	 d=(int) (Math.random()*6)+1;

		if(a==b&&a==c&&a==d) {//如果玩家和庄家三个数都相等		  
		     sum-=6;		  
		}
		 else if((a==b&&a==c)||(a==c&&a==d)||(a==b&&a==d)) {//如果玩家和庄家两个数相等		  
		 sum-=2;		  
		}
		 else if(a==b||a==c||a==d) {//如果玩家和庄家一个数相等
			 sum-=1;	  
		}
		 else if((a*b==c*d)||(a*c==b*d)||(a*d==b*c)){	  
			 sum-=0;	  
		}
		 else{
			 sum+=1;
		  
		}
	}
	 
		  
	    System.out.printf("%.3f\n",sum/500000f);
	 
        Long end = System.currentTimeMillis();
        System.out.println("运行花费时间：" + (end - start) + "ms");
	}

	 

}

运行结果：

0.022
运行花费时间：152ms

5 火柴游戏

【编程题】(满分34分)

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

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

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

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

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

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

    游戏开始时可能已经放置了多根火柴。

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

    如图[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或更高版本。