蓝桥杯专题-真题版含答案-【制作表格】【5位黑洞数】【泊松分酒】【亲密数】

2023-12-15 16:14:30
Unity3D特效百例案例项目实战源码Android-Unity实战问题汇总
游戏脚本-辅助自动化Android控件全解手册再战Android系列
Scratch编程案例软考全系列Unity3D学习专栏
蓝桥系列ChatGPT和AIGC

👉关于作者

专注于Android/Unity和各种游戏开发技巧,以及各种资源分享(网站、工具、素材、源码、游戏等)
有什么需要欢迎底部卡片私我,获取更多支持,交流让学习不再孤单

CSDN-芝麻粒儿

👉实践过程

😜制作表格

在中文Windows环境下,控制台窗口中也可以用特殊符号拼出漂亮的表格来。
比如:
┌─┬─┐
│││
├─┼─┤
│││
└─┴─┘
其实,它是由如下的符号拼接的:
左上 = ┌
上 = ┬
右上 = ┐
左 = ├
中心 = ┼
右 = ┤
左下= └
下 = ┴
右下 = ┘
垂直 = │
水平 = ─
本题目要求编写一个程序,根据用户输入的行、列数画出相应的表格来。
例如用户输入:
3 2
则程序输出:
┌─┬─┐
│││
├─┼─┤
│││
├─┼─┤
│││
└─┴─┘
用户输入:
2 3
则程序输出:
┌─┬─┬─┐
││││
├─┼─┼─┤
││││
└─┴─┴─┘
要求考生把所有类写在一个文件中。调试好后,存入与考生文件夹下对应题号的“解答.txt”中即可。相关的工程文件不要拷入。请不要使用package语句。
另外,源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

package Question20_29;
import java.util.Scanner;
publicclass Question28 {
	publicstaticvoid main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		int hang=scanner.nextInt(),lie=scanner.nextInt();
		for (int i = 0; i < hang; i++) {
			if(i==0){
				System.out.print("┌─");
				for (int j = 0; j < lie-1; j++) {
					System.out.print("┬─");
				}
				System.out.println("┐");
				for (int j = 0; j < lie; j++) {
					System.out.print("│ ");
				}
				System.out.println("│");
			}else {
				System.out.print("├─");
				for (int j = 0; j < lie-1; j++) {
					System.out.print("┼─");
				}
				System.out.println("┤");
				
				for (int j = 0; j < lie; j++) {
					System.out.print("│ ");
				}
				System.out.println("│");
			}
		}
		System.out.print("└─");
		for (int j = 0; j < lie-1; j++) {
			System.out.print("┴─");
		}
		System.out.println("┘");
		//System.out.print("┌");System.out.print("─");System.out.print("┬");System.out.print("─");System.out.print("┐");
	}
}
运行结果:
请输出两个数,行和列 ,: 3 4 
3 4
┌─┬─┬─┬─┐
│││││
├─┼─┼─┼─┤
│││││
├─┼─┼─┼─┤
│││││
└─┴─┴─┴─┘

import java.util.Scanner;
public class WinGraph {
	//使用字符数组存放基本图形
	public static char[] gr={'┌','┬','┐','├','┼','┤','└','┴','┘','│','─'};
	public static void paintGraph(int row,int col){
		//打印表格上边框
		System.out.print(gr[0]);
		System.out.print(gr[10]);
		for(int i=1;i<col;i++){
			System.out.print(gr[1]);
			System.out.print(gr[10]);
			}
		System.out.println(gr[2]);
		//打印表格中间部分
		for(int i=0;i<=col;i++){
			System.out.print(gr[9]);
			System.out.print(" ");
			}
		System.out.println();
		for(int i=1;i<row;i++){
			System.out.print(gr[3]);
			System.out.print(gr[10]);
			for(int j=1;j<col;j++){
				System.out.print(gr[4]);
				System.out.print(gr[10]);
			}
			System.out.println(gr[5]);
			for(int k=0;k<=col;k++){
				System.out.print(gr[9]);
				System.out.print(" ");
				}
			System.out.println();
		}
		//打印表格下边框
			System.out.print(gr[6]);
		System.out.print(gr[10]);
		for(int i=1;i<col;i++){
			System.out.print(gr[7]);
			System.out.print(gr[10]);
			}
		System.out.println(gr[8]);
	}
	//main 方法
	public static void main(String args[]){
		int row, col;
		System.out.println("请输入表格列数 :");
		Scanner sc=new Scanner(System.in);
		row=sc.nextInt();
		System.out.println("请输入表格列数 :");
		col=sc.nextInt();
		paintGraph(row,col);
	}
}

😜5位黑洞数

任意一个5位数,比如:34256,把它的各位数字打乱,重新排列,可以得到
一个最大的数:65432,一个最小的数23456。
求这两个数字的差,得:41976,把这个数字再次重复上述过程(如果不足5位,则前边补0)。如此往复,数字会落入某个循环圈(称为数字黑洞)。
比如,刚才的数字会落入:[82962,75933, 63954, 61974]这个循环圈。
请编写程序,找到5位数所有可能的循环圈,并输出,每个循环圈占1行。
其中5位数全都相同则循环圈为[0],这个可以不考虑。循环圈的输出格式仿照:
[82962,75933, 63954, 61974]其中数字的先后顺序可以不考虑。

package Question30_39;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Question30TooDifficultMustRemember{
	public static int  MaxSubMin(int n) {
		StringBuffer sb=new StringBuffer(""+n);
		while (sb.length()<5) {
			sb.insert(0, '0');
		}
		char ch[]=(sb.toString()).toCharArray();
		Arrays.sort(ch);
		int max=(ch[4]-'0')*10000+(ch[3]-'0')*1000+(ch[2]-'0')*100+(ch[1]-'0')*10+ch[0]-'0';
		int min=(ch[0]-'0')*10000+(ch[1]-'0')*1000+(ch[2]-'0')*100+(ch[3]-'0')*10+ch[4]-'0';
		return max-min;
	}
	public static Set<Integer> blackHole(int n) {
		Set<Integer> set=new LinkedHashSet<Integer>();
		set.add(n);
		while(true){
			n=MaxSubMin(n);
			if(set.add(n)==false){
				Set<Integer>tSet=new LinkedHashSet<Integer>();
				for (Iterator iterator = set.iterator(); iterator.hasNext();) {
					Integer integer = (Integer) iterator.next();
					if(integer==n){
						break;
					}else {
						tSet.add(integer);
					}
				}
				set.removeAll(tSet);
				break;
			}
		}
		return set;
	}
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
	//	int n=scanner.nextInt();
		Set<Set<Integer>>set=new LinkedHashSet<>();
		for (int i = 10000; i < 100000; i++) {
			set.add(blackHole(i));
		}
		
		for (Iterator iterator = set.iterator(); iterator.hasNext();) {
			Set<Integer> set2 = (Set<Integer>) iterator.next();
			System.out.println(set2);
		}
		
	}
}
运行结果:
[0]
[74943, 62964, 71973, 83952]
[63954, 61974, 82962, 75933]
[53955, 59994]

/* 
 * 任意一个5位数,比如:34256,把它的各位数字打乱,重新排列,可以得到 
 * 一个最大的数:65432,一个最小的数23456。 
 * 求这两个数字的差,得:41976,把这个数字再次重复上述过程(如果不足5位,则前边补0)。 
 * 如此往复,数字会落入某个循环圈(称为数字黑洞)。 
    比如,刚才的数字会落入:[82962,75933, 63954, 61974]这个循环圈。 
    请编写程序,找到5位数所有可能的循环圈,并输出,每个循环圈占1行。 
    其中5位数全都相同则循环圈为[0],这个可以不考虑。循环圈的输出格式仿照: 
    [82962,75933, 63954, 61974] 
    其中数字的先后顺序可以不考虑。 
 */  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.Iterator;  
import java.util.LinkedHashSet;  
import java.util.List;  
import java.util.Set;  
  
public class BlackHole {  
    static Set<List<Integer>> sets = new LinkedHashSet<List<Integer>>();// 记录每个 循环圈   
    static int start = 0;   // 记录循环圈的开始位置   
    // 得到最大的数   
    public static int max(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        StringBuffer sb = new StringBuffer(new String(c));  
        return Integer.parseInt(sb.reverse().toString());  
    }  
    // 得到最小的数   
    public static int min(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        return Integer.parseInt(new String(c));  
    }  
    // 补零   
    public static String fillZero(String s){  
        if(s.length()<5) return s;   // 如果够五位的话,直接返回原数   
        StringBuffer sb = new StringBuffer(s);  
        int len = 5 - sb.length();  // 需要补 len 个零   
        for(int i=0;i<len;i++){  
            sb.insert(0, "0");  
        }  
        return sb.toString();  
    }  
    // 查找是否有循环圈   
    public static boolean find(int n,List<Integer> lis){  
        for(int i=0;i<lis.size();i++){  
            if(n==lis.get(i)){  
                start = i;  // 设置循环圈的开始   
                return true;  
            }  
        }  
        return false;  
    }  
    // 这个数字的五位是否都一样如:11111,22222,...   
    public static boolean same(int n){  
        char[] c = (""+n).toCharArray();  
        char t = c[0];  
        for(int i=1;i<c.length;i++){  
            if(t!=c[i]){  
                return false;  
            }  
        }  
        return true;  
    }  
    // 判断是否在sets元素里重复   
    public static boolean contain(List<Integer> tt){  
        boolean flag = false;  
        // 从sets头到尾扫描是是否包含tt元素组   
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            if(iter.next().containsAll(tt)){  
                flag = true;  
            }  
        }  
        return flag;  
    }  
    // 输出循环圈   
    public static void print(){  
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            System.out.println(iter.next());  
        }  
    }  
    // 进入黑洞测试*********   
    public static void bl(int n,List<Integer> lis){  
        String tt = fillZero(String.valueOf(n));  
        int a = max(tt);    // 得到最大的数   
        int b = min(tt);    // 得到最小的数   
        int c = a - b;      // 得到五位数 结果   
        if(find(c,lis)){    // 找到循环圈   
            lis.add(c);     // 把最后一个元素添加进去   
            List<Integer> temp = new ArrayList(); // 开辟新空间 并copy记录   
            temp.addAll(lis.subList(start, lis.size()-1));  
            if(!contain(temp)){ // 去重   
                sets.add(temp); // 记录一个循环圈   
            }  
            lis.clear();    // 清空   
            return ;  
        }  
        lis.add(c);  
        bl(c,lis);  // 递归探测   
    }  
    // 主函数============   
    public static void main(String[] args){  
        List<Integer> lis = new ArrayList();  // 保存记录   
        for(int i=10000;i<99999;i++){  
            if(!same(i))    //去掉不符合条件的元素:如(11111,22222,...)   
                bl(i,lis);  // 进入黑洞测试   
        }  
        print();        // 输出循环圈   
    }  
}  


运行结果:
[0]  
[74943, 62964, 71973, 83952]  
[63954, 61974, 82962, 75933]  
[53955, 59994] 

😜泊松分酒

泊松是法国数学家、物理学家和力学家。他一生致力科学事业,成果颇多。
有许多著名的公式定理以他的名字命名,比如概率论中著名的泊松分布。
有一次闲暇时,他提出过一个有趣的问题,后称为:“泊松分酒”。
在我国古代也提出过类似问题,遗憾的是没有进行彻底探索,其中流传较多是:“韩信走马分油”问题。
有3个容器,容量分别为12升,8升,5升。其中12升中装满油,另外两个空着。
要求你只用3个容器操作,最后使得某个容器中正好有6升油。
下面的列表是可能的操作状态记录:
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每行3个数据,分别表示12,8,6升容器中的油量
第一行表示初始状态,第二行表示把12升倒入8升容器后的状态,第三行是8升倒入5升,…
当然,同一个题目可能有多种不同的正确操作步骤。
本题目的要求是,请你编写程序,由用户输入:各个容器的容量,开始的状态,
和要求的目标油量,程序则通过计算输出一种实现的步骤(不需要找到所有可能的方法)。
如果没有可能实现,则输出:“不可能”。
例如,用户输入:
12,8,5,12,0,0,6
用户输入的前三个数是容器容量(由大到小),接下来三个数是三个容器开始时的油量配置,
最后一个数是要求得到的油量(放在哪个容器里得到都可以)
则程序可以输出(答案不唯一,只验证操作可行性):
12,0,0
4,8,0
4,3,5
9,3,0
9,0,3
1,8,3
1,6,5
每一行表示一个操作过程中的油量状态。
注意:
请仔细调试!您的程序只有能运行出正确结果的时候才有机会得分!
请把所有类写在同一个文件中,调试好后,存入与【考生文件夹】下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。
请不要使用package语句。

package Question30_39;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question36TooDifficultMustRemember {
	public static List<Integer> distribute(List<Integer> capacityList,List<Integer> oilSizeList,int where,int to) {
		List<Integer>tList =new ArrayList<Integer>();
		tList.addAll(oilSizeList);
		if(oilSizeList.get(where)==0){
			return null;
		}else if (oilSizeList.get(where)>=capacityList.get(to)-oilSizeList.get(to)) {
			tList.set(to, capacityList.get(to));
			tList.set(where, oilSizeList.get(where)-(capacityList.get(to)-oilSizeList.get(to)));
			return tList;
		}else if(oilSizeList.get(where)<=capacityList.get(to)-oilSizeList.get(to)){
			tList.set(to, oilSizeList.get(to)+oilSizeList.get(where));
			tList.set(where, 0);
			return tList;
		}
		return null;
	}
	public static boolean exeForward(Set<List<Integer>>set,List<Integer> capacityList,List<Integer> oilSizeList,int NeedOilSize) {
		
//		for (List<Integer> list : set) {
//			System.out.print(list+"  ");
//		}
//		System.out.println();
		
		
		for (Integer integer : oilSizeList) {
			if(integer==NeedOilSize){
				for (List<Integer> list : set) {
				//	System.out.print(list+" ");
				//	System.out.print(list.size()+" ");
					for (Iterator iterator = list.iterator(); iterator
							.hasNext();) {
						Integer integer2 = (Integer) iterator.next();
						System.out.print(integer2);
						if(iterator.hasNext()){
							System.out.print(",");
						}else {
							System.out.print("\n");
						}
						
					}
				}
				
				return true;
			}
		}
		Vector<List<Integer>>vector=new Vector<List<Integer>>();
		vector.add(distribute(capacityList, oilSizeList, 0, 1));
		vector.add(distribute(capacityList, oilSizeList, 0, 2));
		vector.add(distribute(capacityList, oilSizeList, 1, 0));
		vector.add(distribute(capacityList, oilSizeList, 1, 2));
		vector.add(distribute(capacityList, oilSizeList, 2, 0));
		vector.add(distribute(capacityList, oilSizeList, 2, 1));
		for (int i = 0; i < vector.size(); i++) {
			if(vector.get(i)!=null){
				
				if(set.add(vector.get(i))){
					
					if(exeForward(set, capacityList, vector.get(i), NeedOilSize)==true){
						return true;
					}
					set.remove(vector.get(i));
				}
			}
		}
		return false;
	}
	public static void main(String[] args){
		Scanner scanner=new Scanner(System.in);
		Set<List<Integer>>set=new LinkedHashSet<List<Integer>>();
		List<Integer>tList=new ArrayList<Integer>();
		for (int i = 0; i < 3; i++) {
			tList.add(0);
		}
		List<Integer> capacityList=new ArrayList<>(tList);
		List<Integer> oilSizeList=new ArrayList<>(tList);
		int NeedOilSize;
		
		String ts=scanner.nextLine();
		
		String tss[]=ts.split("\\,");
		for (int i = 0; i < capacityList.size(); i++) {
			capacityList.set(i, Integer.parseInt(tss[i]));
		}
		int totalOil=0;
		for (int i = 0; i < capacityList.size(); i++) {
			oilSizeList.set(i, Integer.parseInt(tss[i+3]));
			totalOil+=Integer.parseInt(tss[i+3]);
		}
		NeedOilSize=Integer.parseInt(tss[6]);
		
		if(NeedOilSize>totalOil){
			System.out.println("不可能");
			return;
		}
		boolean posible=false;
		for (int i = 0; i < capacityList.size(); i++) {
			if(capacityList.get(i)>NeedOilSize){
				posible=true;
				break;
			}
		}
		if(posible==false){
			System.out.println("不可能");
			return;
		}
		exeForward(set, capacityList, oilSizeList, NeedOilSize);
	}
}
运行结果:
输入数据(格式为7个数字用","号隔开,例:)12,8,5,12,0,0,6
12,8,5,12,0,0,6
12	0	0	
4	8	0	
4	3	5	
9	3	0	
9	0	3	
1	8	3	
1	6	5	
记录数:(7)

import java.util.Scanner;
public class C33 {
	public static void main(String[] args){
		int num[] = getNum();
		int d = gcd(num[1], num[2]);//中瓶和小瓶容量的最大公约数
		if(num[0]/2 <= num[1] + num[2] && (num[0]/2)%d == 0)
		{
			System.out.println(num[3] + " " + num[4] + " " + num[5]);
			fenjiu(num[3], num[4], num[5],num);	
		}
		else 
		{		
			System.out.println("不可能");
		}
	}
	static int[] getNum()
	{
		Scanner readerScanner = new Scanner(System.in);
		String string[] = readerScanner.nextLine().split(",");
		int i = 0;
		int num[] = new int[7];
		while(i < 7)
		{
			num[i] = Integer.parseInt(string[i]);
			i++;
		}
		return num;
	}
	static void fenjiu(int num1,int num2,int num3,int num[])
	{
		//C2*X - C3*Y = 1
		int b1 = num[1],c1 = num[2];
		int a = num1,b = num2,c = num3,result = num[6];
		if(b == result||c == result||a == result)
			System.out.print("");
		else {
			//12,8,5,12,0,0,6
//			1. 大瓶子只能倒入中瓶子
//			2. 中瓶子只能倒入小瓶子
//			3. 小瓶子只能倒入大瓶子
//			4. 小瓶子只有在已经装满的情况下才能倒入大瓶
//			5. 若小瓶子被倒空,则无论中瓶子是否满,应马上从中瓶子倒入小瓶子
			if(c == c1)
			{//		4. 小瓶子只有在已经装满的情况下才能倒入大瓶子
				a = a + c;
				c = 0;
				System.out.println(a + " " + b + " " + c);
				fenjiu(a, b, c, num);	
			}
			else {
				if(c == 0 && b > 0)
			{//		5. 若小瓶子被倒空,则无论中瓶子是否满,应马上从中瓶子倒入小瓶子
					if(b > c1)
					{
						c = c1;
						b = b - c1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
					else {
						c = b;
						b = 0;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
			}
				else {
					if(b != b1)
					{
						a = a - b1 + b;
						b = b1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
					else {
						b = b - c1 + c;
						c = c1;
						System.out.println(a + " " + b + " " + c);
						fenjiu(a, b, c, num);
					}
				}
			}			
		}			
	}
	public static int gcd(int m, int n) 
	{  
		int a  = n, b = m;
		while (true)
		{ 
			if ((a = a % b) == 0) 
				return b; 
			if ((b = b % a) == 0)  
				return a; 
		} 
		
	} 
}

😜亲密数

假设有a、b两个数,若a的所有因子之和等于b,b的所有因子之和等于a,
并且a不等于b,则称a和b是一对亲密数。如284和220就是一对亲密数。
分析:
若要找出10000以内的亲密数,可使用以下算法:
(1)对每一个数i,将其因子分解出来,并将因子保存到一个数组中,再将因子之和保存到变量b1。
(2)将因子之和b1再进行因子分解,并将因子保存到一个数组中,将因子之和保存到变量b2中。
(3)若b2等于i,并且b1不等于b2,则找到一对亲密数为i和b1,可将其输出。
(4)重复步骤(1)~(3),即可找出指定范围的亲密数。

package Question40_49;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.Vector;
public class Question48 {
	public static int obtain(int n) {
		int sum = 0;
		for (int i = 1; i < n; i++) {
			if (n % i == 0) {
				sum += i;
			}
		}
		return sum;
	}
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Set<Set<Integer>> sets = new LinkedHashSet<Set<Integer>>();
		for (int i = 1; i <= n; i++) {
			int t = obtain(i);
			if (i != t) {
				if (obtain(t) == i) {
					Set<Integer> set = new LinkedHashSet<Integer>();
					set.add(i);
					set.add(t);
					sets.add(set);
				}
			}
		}
		for (Iterator iterator = sets.iterator(); iterator.hasNext();) {
			Set<Integer> set = (Set<Integer>) iterator.next();
			for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
				Integer integer = (Integer) iterator2.next();
				System.out.print(integer);
				if (iterator2.hasNext() == false) {
					System.out.println();
				} else {
					System.out.print("   ");
				}
			}
		}
	}
}
运行结果:
10000
220   284
1184   1210
2620   2924
5020   5564
6232   6368

👉其他

📢作者:小空和小芝中的小空
📢转载说明-务必注明来源:https://zhima.blog.csdn.net/
📢这位道友请留步??,我观你气度不凡,谈吐间隐隐有王者霸气💚,日后定有一番大作为📝!!!旁边有点赞👍收藏🌟今日传你,点了吧,未来你成功??,我分文不取,若不成功??,也好回来找我。

温馨提示点击下方卡片获取更多意想不到的资源。
空名先生

文章来源:https://blog.csdn.net/qq_27489007/article/details/135012370
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。