标签：count Java int 蓝桥 宝贝 static 2014 public row

1. 猜年龄

小明带两个妹妹参加元宵灯会。别人问她们多大了，她们调皮地说：“我们俩的年龄之积是年龄之和的6倍”。小明又补充说：“她们可不是双胞胎，年龄差肯定也不超过8岁啊。”

请你写出：小明的较小的妹妹的年龄。
注意： 只写一个人的年龄数字，请通过浏览器提交答案。

package 蓝桥2014C组;

public class T1 {

	public static void main(String[] args) {

		for (int i = 1; i <= 50; i++) {// 循环小妹妹的年龄
			for (int j = i + 1; j <= i + 8; j++) {// 循环大妹妹的年龄
				if ((i * j == (i + j) * 6)) {
					System.out.print(i);
				}
			}
		}
	}
//10
}
//注意外层循环是小妹妹的年龄 大妹妹的年龄的起始值i+1 终止值是i+8

2. 等额本金

小明从银行贷款3万元。约定分24个月，以等额本金方式还款。
这种还款方式就是把贷款额度等分到24个月。每个月除了要还固定的本金外，还要还贷款余额在一个月中产生的利息。
假设月利率是：0.005，即：千分之五。那么，
第一个月，小明要还本金 1250, 还要还利息：30000 * 0.005，总计 1400
第二个月，本金仍然要还 1250, 但利息为：(30000-1250) * 0.005 总计 1393.75

请问：小明在第15个月，应该还款多少（本金和利息的总和）？

请把答案金额四舍五入后，保留两位小数。注意：32.5，一定要写为：32.50

通过浏览器提交答案，这是一个含有小数点和两位小数的浮点数字。不要写多余内容（例如：多写了“元”或添加说明文字）

public static void main(String[] args) {

		System.out.println((30000 - 1250 * 14) * 0.005 + 1250);
	}

3. 猜字母

 把abcd...s共19个字母组成的序列重复拼接106次，得到长度为2014的串。
接下来删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。
得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。
答案是一个小写字母，请通过浏览器提交答案。不要填写任何多余的内容。

package 蓝桥2014C组;

import java.util.ArrayList;
import java.util.List;

//删除第1个字母（即开头的字母a），以及第3个，第5个等所有奇数位置的字母。
//得到的新串再进行删除奇数位置字母的动作。如此下去，最后只剩下一个字母，请写出该字母。
/*分析：
 * 1.先得到长为2014的串
 * 2.将串中的每个字符放到集合中
 * 3.不停地对处于奇数位的元素删除，只剩下一个字母为止
 * 4. 奇数位就对应于下标为偶数 i=i+2
 *  			for(int i=0;i<list.size();i=i+2) {
 				list.remove(i);
 但若采用上述删除：
 因为每删除一个元素，list.size()减小，它后面的元素的下标会有变化，就不能够确保它删除的一定是原来位于奇数位的
 解决：
 先去将所有处于奇数位的进行标记一下，第一轮删除时，将标记过的，进行删除
 进入第二轮，再重新将所有处于奇数位的进行标记一下，
 */
public class T3 {

	public static void main(String[] args) {
		String string = "";
		for (int i = 0; i <= 106; i++) {
			string += "abcdefghijklmnopqrs";
		}
		// 2.将串中的每个字符放到集合中
		List<Character> list = new ArrayList<>();
		for (int i = 0; i < string.length(); i++) {
			list.add(string.charAt(i));
		}
		// 3.利用循环去删除奇数位置的字母
		while (true) {
			// 死循环结束条件
			if (list.size() == 1) {
				System.out.println(list.get(0));
				break;
			}

//			for(int i=0;i<list.size();i=i+2) {
//				list.remove(i);
//			}
			// (1)做标记,将奇数位变成0
			for (int i = 0; i < list.size(); i = i + 2) {
				list.set(i,'0');
			}
			// (2)删除元素内容为‘0’的元素
			for (int i = 0; i < list.size(); i++) {
				if (list.get(i) == '0') {
					list.remove(i);
				}
			}
		}
	}
//q
}

5.写日志

写日志是程序的常见任务。现在要求在 t1.log, t2.log, t3.log 三个文件间轮流写入日志。也就是说第一次写入t1.log，第二次写入t2.log，... 第四次仍然写入t1.log，如此反复。

下面的代码模拟了这种轮流写入不同日志文件的逻辑。

请填写划线部分缺失的代码。通过浏览器提交答案。

public class A
{
    private static int n = 1;
    
    public static void write(String msg)
    {
        String filename = "t" + n + ".log";
        n = ____________;
        System.out.println("write to file: " + filename + " " + msg);
    }
}

代码实现：

private static int n = 1;   
    public static void write(String msg)
    {
        String filename = "t" + n + ".log";
//        n = n==3?1:n+1;
          n=n%3+1;
        System.out.println("write to file: " + filename + " " + msg);
    }
 
	public static void main(String[] args) {
		write("text");
		write("text");
		write("text");
		write("text");
		write("text");
		write("text");
	}
/*
write to file: t1.log text
write to file: t2.log text
write to file: t3.log text
write to file: t1.log text
write to file: t2.log text
write to file: t3.log text*/
}//注意：此题中的n是全局变量   n = n==3?1:n+1;  和  n=n%3+1;

6.李白打酒

话说大诗人李白，一生好饮。
一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：

无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。 

请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

注意：通过浏览器提交答案。答案是个整数。不要书写任何多余的内容。

代码实现：

先来个简化版的：(与2013年的上台阶十分相似)

李白每走一步可能遇到店，也有可能遇到花，若李白一共走三步，求所有他遇到店和花的次序序列。

第一步：遇见花或者店

若花，第二步遇见花或者店

依次选下去，每一次两种选择，直到走3步

static char[] meet = new char[3];//记录每一次走法	
	public static void walk(int d,int h) {
		
		//递归出口
		if(d+h==3) {
			System.out.println(Arrays.toString(meet));
			return;
		}
		
		meet[d+h]='d';
		walk(d+1, h);//遇见店
		meet[d+h]='h';
		walk(d, h+1);//遇见花
	}
	
	public static void main(String[] args) {
	 
		int d =0;//遇到店的次数
		int h =0;//遇到花的次数
		walk(d, h);
	}
/*[d, d, d]
[d, d, h]
[d, h, d]
[d, h, h]
[h, d, d]
[h, d, h]
[h, h, d]
[h, h, h]*/
}

而此题除了考虑遇到店和花外，还有（1）酒的变化，不论遇到店和花，酒的量是都发生变化的（2）遇到店和花的次数有要求，一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。

package 蓝桥2014C组;

/*酒壶中有酒2斗,逢店加一倍，遇花喝一斗。一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。 
 请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b*/
/*fenxi:
 *  1. 只有遇到店的次数小于5次，才可能继续遇到店；遇到花的次数小于10次，才可能继续遇到花；
 *  2. 最后一次遇到的是花: 那就是遇到店5次，遇到花9次时，正好此时酒还剩1斗，这时只能遇到花，他正好把酒喝光了
 * */
public class T6 {

	static int count = 0;

	public static void walk(int wine, int d, int h) {

		// 递归出口
		if (d == 5 && h == 9&& wine==1) {
			count++;
			return;
		}
		if (d < 5) {
			walk(wine * 2, d + 1, h);// 遇见店,酒逢店加一倍，酒的量x2
		}
		if (h < 10) {
			walk(wine - 1, d, h + 1);// 遇花喝一斗。
		}
	}

	public static void main(String[] args) {

		int d = 0;// 遇到店的次数
		int h = 0;// 遇到花的次数
		int wine = 2;// 初始有有酒2斗
		walk(wine, d, h);
		System.out.println(count);
	}
//14
}

7.奇怪的分式:

上小学的时候，小明经常自己发明新算法。一次，老师出的题目是：

1/4 乘以 8/5 
小明居然把分子拼接在一起，分母拼接在一起，答案是：18/45 （参见图1.png）
老师刚想批评他，转念一想，这个答案凑巧也对啊，真是见鬼！
对于分子、分母都是 1~9 中的一位数的情况，还有哪些算式可以这样计算呢？
请写出所有不同算式的个数（包括题中举例的）。
显然，交换分子分母后，例如：4/1 乘以 5/8 是满足要求的，这算做不同的算式。
但对于分子分母相同的情况，2/2 乘以 3/3 这样的类型太多了，不在计数之列!
注意：答案是个整数（考虑对称性，肯定是偶数）。请通过浏览器提交。不要书写多余的内容。

package 蓝桥2014C组;

/*对于分子、分母都是 1~9 中的一位数的情况;把分子拼接在一起，分母拼接在一起
 *但对于分子分母相同的情况, 不在计数之列;请写出所有不同算式的个数,肯定是偶数
 *fenxi:
 *1. 与之前全排列的多重循环不同的是：
 *    不是这四个数字都不相同哦！！只是每一个分式的分子和分母不相同即可
 *2. ax/ay x bx/by
 *  (ax*bx)/(ay*by) 与  (ax*10+bx)/(ay*10+by)是否相等
 *   若直接看两边是否== ，不行，因为若有除不进的，会有误差
 *3. 要求每一个分式的最大公约数：然后对于约分后的两个分式，比较分子与分子  分母与分母*/
public class T7 {
	static int count = 0;

	public static void main(String[] args) {
		// ax ay第一个分式的分子和分母 bx by第二个分式的分子和分母
		for (int ax = 1; ax <= 9; ax++) {

			for (int ay = 1; ay <= 9; ay++) {
				if (ax == ay)
					continue;
				for (int bx = 1; bx <= 9; bx++) {

					for (int by = 1; by <= 9; by++) {
						if (bx == by)
							continue;
						// 求两个分式的最大公约数
						int g1 = gcd(ax * bx, ay * by);
						int g2 = gcd(ax * 10 + bx, ay * 10 + by);
						// 对于约分后的两个分式，比较分子与分子 分母与分母
						if ((ax * bx) / g1 == (ax * 10 + bx) / g2 && (ay * by) / g1 == (ay * 10 + by) / g2) {
							count++;
						}

					}
				}
			}
		}
		System.out.println(count);
	}

	// 求一个分式的最大公约数
	public static int gcd(int x, int y) {
		if (y == 0)
			return x;
		else
			return gcd(y, x % y);
	}
//14
}

补充：

判断两个分式相等，除了第一种方法：将两个分式分别求最大公约数，进行各自的约分，然后比对它们的分子，分母都对应相等外；

第二种方法：第一个分式的分子乘以第二个分式的分母所的结果 与 第二个分式的分子乘以第一个分式的分母所的结果 比较，相等，就代表两个分式相等；

8.兰顿蚂蚁

 平面上的正方形格子被填上黑色或白色。在其中一格正方形内有一只“蚂蚁”。
    蚂蚁的头部朝向为：上下左右其中一方。
蚂蚁的移动规则十分简单：
若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；
若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。

规则虽然简单，蚂蚁的行为却十分复杂。刚刚开始时留下的路线都会有接近对称，像是会重复，但不论起始状态如何，蚂蚁经过漫长的混乱活动后，会开辟出一条规则的“高速公路”。

蚂蚁的路线是很难事先预测的。
你的任务是根据初始状态，用计算机模拟兰顿蚂蚁在第n步行走后所处的位置。
【数据格式】

输入数据的第一行是 m n 两个整数（3 < m, n < 100），表示正方形格子的行数和列数。
接下来是 m 行数据。
每行数据为 n 个被空格分开的数字。0 表示白格，1 表示黑格。

接下来是一行数据：x y s k, 其中x y为整数，表示蚂蚁所在行号和列号（行号从上到下增长，列号从左到右增长，都是从0开始编号）。s 是一个大写字母，表示蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示。k 表示蚂蚁走的步数。

输出数据为两个空格分开的整数 p q, 分别表示蚂蚁在k步后，所处格子的行号和列号。

例如, 输入：
5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 3 L 5
程序应该输出：
1 3

代码实现：

package 蓝桥2014C组;
import java.util.Scanner;
public class T8 {

	static int row;
	static int col;
	static int[][] arr;
	static char dir;

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		int m = scanner.nextInt();// 方格的行数
		int n = scanner.nextInt();// 方格的列数
		arr = new int[m][n];// 定义二维数组保存方格
		// 初始化方格
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				arr[i][j] = scanner.nextInt();// 输入时，0 表示白格，1 表示黑格
			}
		}
		// 蚂蚁所在行号和列号，都是从0开始编号
		row = scanner.nextInt();
		col = scanner.nextInt();
		// 蚂蚁头的朝向，我们约定：上下左右分别用：UDLR表示
		dir = scanner.next().charAt(0);// 注意scanner.next()得到是String
		// 表示蚂蚁走的步数
		int k = scanner.nextInt();

		// 按照蚂蚁走的步数，进行循环，每走一步，都按照"规则"进行,将一步规则写进方法中
		for (int i = 1; i <= k; i++) {
			// 先转向，再移动
			move();
		}

		System.out.println(row + " " + col);
	}

//	每走一步，都按照"规则"进行；
	// （1）必须知道蚂蚁的位置(行号，列号) arr[row][col]，二维数组也需要 则这三个要改成全局静态变量
	// （2）获取当前格子的颜色:利用arr[row][col]是0或1，而知道
//	  若在黑格子里：若开始向上，则向右转；若开始向右，则向下转；
	public static void move() {
		if (arr[row][col] == 1) {// 若蚂蚁在黑格，右转90度，将该格改为白格，并向前移一格；
			if (dir == 'U') {
				dir = 'R';
			} else if (dir == 'R') {
				dir = 'D';
			} else if (dir == 'D') {
				dir = 'L';
			} else {
				dir = 'U';
			}
			arr[row][col] = 0;
		} else if (arr[row][col] == 0) {// 若蚂蚁在白格，左转90度，将该格改为黑格，并向前移一格。
			if (dir == 'U') {
				dir = 'L';
			} else if (dir == 'L') {
				dir = 'D';
			} else if (dir == 'D') {
				dir = 'R';
			} else {
				dir = 'U';
			}
			arr[row][col] = 1;
		}

		//// 先转向，再移动！！！！
		if (dir == 'U') {
			row--;
		} else if (dir == 'R') {
			col++;
		} else if (dir == 'D') {
			row++;
		} else {
			col--;
		}
	}
}

9.地宫取宝：

 X 国王有一个地宫宝库。是 n x m 个格子的矩阵。每个格子放一件宝贝。每个宝贝贴着价值标签。

    地宫的入口在左上角，出口在右下角。

    小明被带到地宫的入口，国王要求他只能向右或向下行走。

    走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

    当小明走到出口时，如果他手中的宝贝恰好是k件，则这些宝贝就可以送给小明。

    请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这k件宝贝。

【数据格式】

    输入一行3个整数，用空格分开：n m k (1<=n,m<=50, 1<=k<=12)

    接下来有 n 行数据，每行有 m 个整数 Ci (0<=Ci<=12)代表这个格子上的宝物的价值

    要求输出一个整数，表示正好取k个宝贝的行动方案数。该数字可能很大，输出它对 1000000007 取模的结果。

例如，输入：
2 2 2
1 2
2 1
程序应该输出：
2

再例如，输入：
2 3 2
1 2 3
2 1 5
程序应该输出：
14

代码：

package 蓝桥2014C组;

import java.util.Scanner;

/*分析：
 * 1.走到某个格子时：
 * 若此宝贝的价值大：有4种选择：向右走拿宝贝，向右走不拿宝贝，向下走拿宝贝，向下走不拿宝贝
 * 若此宝贝的价值小： 则不能那宝贝：向右走不拿宝贝，向下走不拿宝贝；
 * 2. 先判断宝贝的价值，大，则就写四个递归；小，则就写2个递归；*/
public class T9 {
	static int[][] digong;
	static int n;
	static int m;
	static int k;
	static long mount;// 方案的数量

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();// n 行
		m = scanner.nextInt();// m列
		k = scanner.nextInt();// 要取宝贝件数
		digong = new int[m][n];// 地宫矩阵
		// 初始化地宫格中宝贝的价值
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				digong[i][j] = scanner.nextInt();
			}
		}
		move(0, 0, -1, 0);// 注意此处的默认初始宝贝最大值，因为宝贝价值可以取到0; 开始时，若第一个宝贝价值就是0; 当max==0 ,则就不拿了；而实际上是可以拿的
		System.out.println(mount);
	}

	// 取宝贝的过程实现:
	// （1）小明的位置; （2）宝贝的最大值(判断当前宝贝的价值与手中所有宝贝进行比较，所以需要知道宝贝的最大值，是动态变化的)
	// (3) 小明手中宝贝的数量是动态变化的
	/**
	 * @param row   行走时的行
	 * @param col   行走时的列
	 * @param max   行走时的目前宝贝的最大价值
	 * @param count 行走时的宝贝的数量
	 */
	public static void move(int row, int col, int max, int count) {

		// 递归出口1：走出地宫外 或者 宝贝数量大于k
		if (row >= n || col >= m || count > k) {
			return;
		}
		// 递归出口2:
		// 不可以简单的认为只要k==count 因为小明若走到地宫的某处还未到出口时，就已经拿够了宝贝，就算接下来不拿，那可能也有多种方案走到出口
		// （1）当走到出口时，k==count
		// （2）当走到最后一个格子时，count=k-1,此时最后一个格子的价值又比较大，也符合条件

		if (row == n - 1 && col == m - 1) {// 走到最后一个格子
			if (count == k || (count == k - 1 && digong[row][col] > max)) {
				mount++;
				mount = mount % 1000000007;
			}
		}
		// 如果当前宝贝的价值大于目前宝贝的最大价值，有四种选择：
		if (digong[row][col] > max) {
			move(row, col + 1, digong[row][col], count + 1);// 拿了宝贝并向右走
			move(row, col + 1, max, count);// 右不拿
			move(row + 1, col, digong[row][col], count + 1);// 下拿
			move(row + 1, col, max, count);// 下不拿
		} else {// 如果当前宝贝的价值小于目前宝贝的最大价值，有2种选择：
			move(row, col + 1, max, count);// 右不拿
			move(row + 1, col, max, count);// 下不拿
		}
	}
}

标签：count,Java,int,蓝桥,宝贝,static,2014,public,row
来源： https://www.cnblogs.com/yang123-456/p/16060907.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。