蓝桥杯专题-真题版含答案-【信用卡号校验】【数量周期】【取球博弈】【Playfair密码】

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

👉关于作者

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

CSDN-芝麻粒儿

👉实践过程

😜信用卡号校验

当你输入信用卡号码的时候,有没有担心输错了而造成损失呢?其实可以不必这么担心,
因为并不是一个随便的信用卡号码都是合法的,它必须通过Luhn算法来验证通过。
该校验的过程:
1、从卡号最后一位数字开始,逆向将奇数位(1、3、5等等)相加。
2、从卡号最后一位数字开始,逆向将偶数位数字,先乘以2(如果乘积为两位数,则将其减去9),再求和。
3、将奇数位总和加上偶数位总和,结果应该可以被10整除。
例如,卡号是:5432123456788881
则奇数、偶数位(用红色标出)分布:5432123456788881
奇数位和=35
偶数位乘以2(有些要减去9)的结果:1 6 2 6 1 5 7 7,求和=35。
最后35+35=70 可以被10整除,认定校验通过。
请编写一个程序,从键盘输入卡号,然后判断是否校验通过。通过显示:“成功”,否则显示“失败”。
比如,用户输入:356827027232780
程序输出:成功

package Question20_29;
import java.io.InputStreamReader;
import java.util.Scanner;
public class Question23 {
	public static String judge(String s) {
		int count=1;
		int sum=0;
		for (int i = s.length()-1; i >=0 ; i--,count++) {
			if(count%2==1){
				sum+=(s.charAt(i)-'0');
			}else {
				sum+=(s.charAt(i)-'0')*2>=10?(s.charAt(i)-'0')*2-9:(s.charAt(i)-'0')*2;
			}
			
		}
		if(sum%10==0){
			return "成功";
		}else {
			return "失败";
		}
	}
	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		String s=scanner.nextLine();
		System.out.println(judge(s));
	}
}
运行结果:
输入卡号:5432123456788881
成功

public class Card {
    public static int getOddSum(String str){
    	int[] a;
    	int sum=0;
    	int length=str.length();
    	a=new int[(length+1)/2];
    	int j=0;
    	System.out.println("奇数位为:");
    	for(int i=length-1;i>=0;i=i-2){
    		System.out.println(str.substring(i, i+1));
    		a[j++]=Integer.parseInt(str.substring(i, i+1));
    	}
    	for(int i=0;i<a.length;i++){sum+=a[i];}
    	System.out.println(sum);
    	return sum;
    }
  public static int getEvenSum(String str){
    	int[] a;
    	int sum=0;
    	int length=str.length();
    	a=new int[length/2];
    	int j=0;
    	System.out.println("偶数位为:");
    	for(int i=length-2;i>=0;i=i-2){
    		System.out.println(str.substring(i, i+1));
    		a[j++]=Integer.parseInt(str.substring(i, i+1));
    	}
    	for(int i=0;i<a.length;i++){sum=sum+(a[i]*2)%9;}
    	System.out.println(sum);
    	return sum;
    }
    public static void main(String args[]){
        Scanner scanner=new Scanner(System.in);
        System.out.println("please input your name:");
        String str=scanner.next();
    	if((Card.getOddSum(str)+Card.getEvenSum(str))%10==0)System.out.println("成功!");
    	else System.out.print("失败!");
    }
}

😜数量周期

复杂现象背后的推动力,可能是极其简单的原理。科学的目标之一就是发现纷
繁复杂的自然现象背后的简单法则。爱因斯坦的相对论是这方面的典范例证。
很早的时候,生物学家观察某区域某种昆虫的数量(称为虫口数)之逐年变化规律,
就十分迷惑:有的时候是逐渐增多达到一个平衡值。有的时候在两个数字间周期跳动。
有的时候则进入一片混乱,类似随机数字一样变化(称为混沌现象)。
慢慢地,人们从数学中更清晰地观察到了这一现象,并因此开创了:符号动力学、非线性动力学等研究领域。
一个著名的虫口数目简化模型如下:
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 的时候,你观察到有什么周期现象发生吗?

public class Demo01 {
	staticintcount = 100;	// 执行100次退出
	publicstaticvoid f(double x,double r){
		if(count<=0) return;
		x = x * (1 - x) * r;
		System.out.println(x);
		count--;
		f(x,r);
	}
	publicstaticvoid main(String[] args){
		double x = 0.2;
		double r = 3.62;
		f(x,r);
		System.out.println("网络某某结论:虫口数目函数呈锯齿状变化," +
				"虫口数目不存在连续两年增加和连续两年减少的情况。");
	}
}
运行结果:
0.5792000000000002
……
……
……
0.878401825611548
网络某某结论:虫口数目函数呈锯齿状变化,虫口数目不存在连续两年增加和连续两年减少的情况。

😜取球博弈

今盒子里有n个小球,A、B两人轮流从盒中取球,每个人都可以看到另一个人取了多少个,
也可以看到盒中还剩下多少个,并且两人都很聪明,不会做出错误的判断。
我们约定:
每个人从盒子中取出的球的数目必须是:1,3,7或者8个。
轮到某一方取球时不能弃权!
A先取球,然后双方交替取球,直到取完。
被迫拿到最后一个球的一方为负方(输方)
请编程确定出在双方都不判断失误的情况下,对于特定的初始球数,A是否能赢?
程序运行时,从标准输入获得数据,其格式如下:
先是一个整数n(n<100),表示接下来有n个整数。然后是n个整数,每个占一行(整数<10000),表示初始球数。
程序则输出n行,表示A的输赢情况(输为0,赢为1)。
例如,用户输入:
4
1
2
10
18
则程序应该输出:
0
1
1
0

package Question10_19;
import java.util.Scanner;
publicclass Question18Think2MustRemember {
	publicstaticbooleanarray[]=newboolean[10020];
	publicstaticvoid main(String[] args) {
		array[0]=true;
		for (int i = 1; i <array.length; i++) {
			array[i]=(i>=8&&!array[i-8])||(i>=7&&!array[i-7])||(i>=3&&!array[i-3])||(i>=1&&!array[i-1]);
		}
		Scanner scanner=new Scanner(System.in);
		int n=scanner.nextInt();
		int total;
		scanner.nextLine();
		while ((n--)>0) {
			total=scanner.nextInt();
			System.out.println(array[total]?1:0);
		}
	}
}
运行结果:
4
1
2
10
18
输出结果:
0
1
1
0

public class Ball
{
	// 按规则取,还剩下n个球时,先取的人能赢吗?
	static boolean f(int n)
	{
		if(n==1) return false;
		if(n>8)return !f(n-8)||!f(n-7)||!f(n-3)||!f(n-1);
		if(n>7)return !f(n-7)||!f(n-3)||!f(n-1);
		if(n>3)return !f(n-3)||!f(n-1);
		else return !f(n-1);
	}
	
	public static void main(String[] args)
	{
		System.out.println(f(10));
	}
}

😜Playfair密码

一种Playfair密码变种加密方法如下:首先选择一个密钥单词(称为pair)(字母不重复,且都为小写字母),
然后与字母表中其他字母一起填入至一个5x5的方阵中,填入方法如下:
1.首先按行填入密钥串。
2.紧接其后,按字母序按行填入不在密钥串中的字母。
3.由于方阵中只有25个位置,最后剩下的那个字母则不需变换。
如果密钥为youandme,则该方阵如下:
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
在加密一对字母时,如am,在方阵中找到以这两个字母为顶点的矩形(红色字体):
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
这对字母的加密字母为该矩形的另一对顶点,如本例中为ob。
请设计程序,使用上述方法对输入串进行加密,并输出加密后的串。
另外有如下规定:
1、一对一对取字母,如果最后只剩下一个字母,则不变换,直接放入加密串中;
2、如果一对字母中的两个字母相同,则不变换,直接放入加密串中;
3、如果一对字母中有一个字母不在正方形中"如z",则不变换,直接放入加密串中;
4、如果字母对出现在方阵中的同一行或同一列,如df或hi,则只需简单对调这两个字母,即变换为fd或ih;
5、如果在正方形中能够找到以字母对为顶点的矩形,假如字母对为am,则该矩形的另一对顶点字母中,
与a同行的字母应在前面,在上例中应是ob;同样若待变换的字母对为ta,则变换后的字母对应为wo;
6、本程序中输入串均为小写字母,并不含标点、空格或其它字符。
解密方法与加密相同,即对加密后的字符串再加密,将得到原始串。
要求输入形式如下:
从控制台输入两行字符串,第一行为密钥单词(长度小于等于25),第二行为待加密字符串(长度小于等于50),
两行字符串末尾都有一个回车换行符,并且两行字符串均为小写字母,不含其它字符。
在标准输出上输出加密后的字符串。
例如,若输入:
youandme
welcometohangzhou
则表示输入的密钥单词为youandme,形成的正方形如上所示;待加密字符串为welcometohangzhou。
在正方形中可以找到以第一对字母we为顶点的矩形,对应另一对顶点字母为vb,因此加密后为vb,
同理可找到与字母对lc,et,oh,ho对应的顶点字母对。而字母对om位于上述正方形中的同一列,
所以直接以颠倒这两个字母来加密,即为mo,字母对an同理。字母对gz中的z不在上述正方形中,
因此原样放到加密串中。最后剩一个字母u也原样输出。
因此输出的结果为:
vbrmmomvugnagzguu
vbrmmomvugnagzguu
vbrmmomvugnagzguu
要求考生把所有类写在一个文件中。调试好后,存入与考生文件夹下对应题号的“解答.txt”中即可。
相关的工程文件不要拷入。请不要使用package语句。
另外,源程序中只能出现JDK1.5中允许的语法或调用。不能使用1.6或更高版本。

package Question20_29;
import java.util.Scanner;
import java.util.Vector;
public class Question26 {
	public static char initArray(char[][] array, String pair) {
		Vector<Character>vector=new Vector<Character>();
		for (char i = 'a'; i <='z'; i++) {
			vector.add(i);
		}
		for (int i = 0; i < pair.length(); i++) {
			vector.remove((Character)pair.charAt(i));
			array[i/5][i%5]=pair.charAt(i);
		}
		for (int i = 0,j=pair.length() ; i < vector.size()-1; i++,j++) {
			array[j/5][j%5]=vector.elementAt(i);
		}
		return vector.elementAt(vector.size()-1);
	}
	public static String passwordAfterChange(char[][] array,String password,char unUsedch) {
		StringBuffer sb=new StringBuffer();
		for (int i = 0; i < password.length(); i+=2) {
			if(i+1<password.length()){
				if(password.charAt(i)==unUsedch||password.charAt(i+1)==unUsedch){//如果一对字母中有一个字母不在正方形中"如z",则不变换,直接放入加密串中
					sb.append(password.charAt(i));
					sb.append(password.charAt(i+1));
				}else if (password.charAt(i)==password.charAt(i+1)) {//如果一对字母中的两个字母相同,则不变换,直接放入加密串中
					sb.append(password.charAt(i));
					sb.append(password.charAt(i+1));
				}else {
					int ch1i=0,ch1j=0,ch2i=0,ch2j = 0;
					for (int j = 0; j < array.length; j++) {
						for (int j2 = 0; j2 < array.length; j2++) {
							if(array[j][j2]==password.charAt(i)){
								ch1i=j;ch1j=j2;
							}else if(array[j][j2]==password.charAt(i+1)){
								ch2i=j;ch2j=j2;
							}
						}
					}
					if(ch1i==ch2i||ch1j==ch2j){//如果字母对出现在方阵中的同一行或同一列,如df或hi,则只需简单对调这两个字母,即变换为fd或ih
						sb.append(password.charAt(i+1));
						sb.append(password.charAt(i));
					}else {
						sb.append(array[ch1i][ch2j]);
						sb.append(array[ch2i][ch1j]);
					}
					
				}
			}else {//一对一对取字母,如果最后只剩下一个字母,则不变换,直接放入加密串中
				sb.append(password.charAt(i));
			}
		}
		return sb.toString();
	}
	public static void main(String[] args) {
		char array[][]=new char[5][5];
		Scanner scanner = new Scanner(System.in);
		String pair = scanner.nextLine();
		String password=scanner.nextLine();
		char unUsedch=initArray(array, pair);
		System.out.println(passwordAfterChange(array, password, unUsedch));
	}
}
运行结果:
输入密钥单词:youandme
输入待加密字符:welcometohangzhou
y o u a n
d m e b c
f g h i j
k l p q r
s t v w x
加密结果:vbrmommvugnagzguu
解密结果:welcometohangzhou

import java.util.Scanner;  
public class Demo09 {  
    static char a = 'a';  
    // 返回不包含在key里的元素   
    public static char contains(String k){  
        if(k.indexOf(a)>0){  // 如果 k 包含  c 则 a++ 再进行测试   
            a++;  
            contains(k);  
        }  
        return a;   // 返回不包含在key里的元素   
    }  
    // 显示矩阵   
    public static void show(char[][] m){  
        for(int i=0;i<5;i++){  
            for(int j=0;j<5;j++){  
                System.out.print(" "+m[i][j]);  
            }  
            System.out.println();  
        }  
    }  
    // 完成矩阵添加元素   
    public static void fillmatrix(String key, char[][] m) {  
        int len = 0;  
        for(int i=0;i<5;i++){  
            for(int j=0;j<5;j++){  
                if(len<key.length()){  
                    m[i][j] = key.charAt(len);  
                    len++;  
                }else{  // 添加  (a~z在key里不包含)的元素   
                    m[i][j] = contains(key);  
                    a++;  
                }  
            }  
        }  
    }  
    // 待加密的字符串分对(2个字符一对)   
    public static String[] pair(String str){  
        String[] ss = new String[(str.length()+1)/2];  
        StringBuffer sb = new StringBuffer(str);  
        int i = 0;  
        while(sb.length()!=0){  
            if(sb.length()<=1){  
                ss[i] = sb.toString();  
                break;  
            }else{  
                ss[i++] = sb.substring(0,2);  
                sb.delete(0, 2);  
            }  
        }  
        return ss;  
    }  
    public static String find(String ss,char[][] m){  
        char[] c = ss.toCharArray();  
        if(c.length==1) return ss;  // 如果是一个字符,则直接返回   
        int count = 0;  // 统计c里的两个字符中否都存在   
        int[] f = new int[4];   // 保存下标   
        StringBuffer sb = new StringBuffer();  
        for(int i=0;i<m.length;i++){  
            for(int j=0;j<m[i].length;j++){  
                if(m[i][j]==c[0]){  
                    f[0] = i;   // f[0,1]保存第一个字符的位置   
                    f[1] = j;  
                    count++;    // 存在加1   
                }else if(m[i][j]==c[1]){  
                    f[2] = i;   // f[0,1]保存第二个字符的位置   
                    f[3] = j;  
                    count++;    // 存在加1   
                }  
            }  
        }  
        if(count!=2) return ss; //count!=2说明有一个字符在矩阵里不存在   
        sb.append(m[f[0]][f[3]]);   // 添加加密后的第一个字符   
        sb.append(m[f[2]][f[1]]);   // 添加加密后的第二个字符   
        return sb.toString();  
    }  
    // 加密   
    public static String encry(String str,char[][] m){  
        StringBuffer sb = new StringBuffer();  
        String[] ss = pair(str);  
        for(int i=0;i<ss.length;i++){  
            sb.append(find(ss[i],m));  
        }  
        return sb.toString();  
    }  
    public static void main(String[] args){  
        Scanner scan = new Scanner(System.in);  
        System.out.print("输入密钥单词:");  
        String key = scan.nextLine();  
        System.out.print("输入待加密字符:");  
        String str = scan.nextLine();  
        char[][] m = new char[5][5];  
        fillmatrix(key, m); // 完成矩阵添加元素   
        show(m);    // 显示矩阵   
        String e = encry(str,m);    // 加密   
        System.out.println("加密结果:"+e);  // 输出加密后的字符串   
        String d = encry(e,m);  // 解密   
        System.out.println("解密结果:"+d);  // 输出加密后的字符串   
    }  
}  

运行结果:
输入密钥单词:youandme  
输入待加密字符:welcometohangzhou  
 y o u a n  
 d m e b c  
 f g h i j  
 k l p q r  
 s t v w x  
加密结果:vbrmommvugnagzguu  
解密结果:welcometohangzhou

👉其他

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

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

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