蓝桥杯JAVAB

A_lazy_chestnut

已于 2024-05-21 12:06:05 修改

阅读量135

点赞数 3

文章标签： java 算法数据结构蓝桥杯

于 2024-04-08 22:34:49 首次发布

本文链接：https://blog.csdn.net/A_lazy_chestnut/article/details/137523738

版权

一，立方变自身-JavaB(6届）

public class L3 {
    public static void main(String[] args) {
        int cnt = 0;//记录满足要求的个数
        //立方再往上，各位相加不会等于原数
        for (int i = 1; i < 100; i++) {
            //得到三次方
            int ans = (int) Math.pow(i, 3);
            //得到立方的每位数相加
            int number = get(ans);
            //判断是否满足条件
            //满足个数++
            if (number == i) cnt++;
        }
        System.out.println(cnt);
    }

    public static int get(int num) {
        int number = 0;//保存立方每位数相加的结果
        while (num > 0) { //大于0就继续
            number += num % 10;//得到最后一位
            num /= 10;
        }
        return number;
    }
}

答案：6

二，数的分解-JavaB(10届）

public class L3 {
    public static void main(String[] args){
      int count=0;
      for(int i=1;i<=2019;i++){
          for(int j=1;j<=2019;j++){
              for(int k=1;k<=2019;k++){
                  if(i+j+k==2019&&judge(i)&&judge(j)&&judge(k)&&i!=j&&j!=k&&i!=k){
                      count++;
                  }
              }
          }
      }
System.out.println(count);

    }
    public static boolean judge(int n){
        while(n>0){
            if(n%10==2||n%10==4){
                return false;
            }
            n/=10;
        }
        return true;
    }
}

三，数列求值-JavaB(10届）

数列题目首先想到用数组表示

public class L3 {
    public static void main(String[] args){
        int a[]=new int[20190324];
        a[0]=a[1]=a[2]=1;
        for(int i=3;i<20190324;i++){
            a[i]=(a[i-1]+a[i-2]+a[i-3])%10000;
        }
        //数组是从零开始的，第20190324位数组下标就是20190323
        System.out.println(a[20190323]);

    }
}

四，单词分析-JavaB(11届）

使用数组下标记录位置

import java.util.Scanner;
import java.util.Arrays;
//输出出现次数最多的字母，以及它出现的次数
public class A1 {
    public static void main(String []args){
Scanner sc=new Scanner(System.in);
//字母输入
        char[] ch=sc.nextLine().toCharArray();
        //建立从a到z的数组
        int[] num=new int[30];
        for(int i=0;i<ch.length;i++){
            //当每有一个a到z的字母时，下标就加一,记录字母出现次数
            num[ch[i]-'a']++;
        }
        int max=-1;
        int maxi=-1;
        for(int i=0;i<num.length;i++){
            if(max<num[i]){
                //max记录最多字母出现的次数
                max=num[i];
                //maxi记录出现次数最多字母位置
                maxi=i;
            }
        }
        char result=(char)('a'+maxi);
        System.out.println(result);
        System.out.println(max);
    }
}

五，成绩分析-JavaB(11届）

求某个班的最高分，最低分，平均分

import java.util.Scanner;
import java.util.Arrays;
//计算最大值，最小值，平均分数
public class A1 {
    public static void main(String []args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
double sum=0;
int []a=new int[n];
for(int i=0;i<n;i++){
    a[i]=sc.nextInt();
    sum=sum+a[i];
}
//默认升序排列
Arrays.sort(a);
System.out.println(a[n-1]);
System.out.println(a[0]);
//String.format表示某些部分是可变的，详细看文章
System.out.println(String.format("%.2f",sum/n));


    }
}

String.format()的详细用法-CSDN博客

六，蛇形填数-JavaB(11届）

思路：找他们之间的规律，按照a[i][j]中找的i与j相等，寻找之间差值的规律。

a[1][1]=1,a[2][2]=5,a[3][3]=13,a[4][4]=25……

5-1=4,13-5=8,25-13=12……

import java.util.Scanner;
public class A1 {
    public static void main(String []args){
int sum=1;
int add=0;
for(int i=1;i<=20;i++){
    sum=sum+add;
    add=add+4;
    if(i==20){
        System.out.println(sum);
        break;
    }
}
    }
}

在加前一位数的同时sum也在相加，放在同一个for循环里面

七，寻找2020-JavaB(11届）

import java.util.Scanner;
public class A1 {
    static char[][]r=new char[300][300];//首先定义一个300行300列的数组
    public static void main(String []args){
Scanner scanner=new Scanner(System.in);
for(int i=0;i<r.length;i++){
    r[i]=scanner.nextLine().toCharArray();//存取数组中的数据
}
int count=0;//定义一个结果集
        //找2020位于同一行的
        for(int i=0;i<300;i++){
            for(int j=0;j<300-3;j++){//300-3是因为要确定其中一个，这里面的一个确定其中的三个
                if(r[i][j]=='2'&&r[i][j+1]=='0'&&r[i][j+2]=='2'&&r[i][j+3]=='0'){
                    count++;
                }


            }
        }
        //找2020位于同一列的
        for(int i=0;i+3<300;i++){
            for(int j=0;j<300;j++){
                if(r[i][j]=='2'&&r[i+1][j]=='0'&&r[i+2][j]=='2'&&r[i+3][j]=='0'){
                    count++;
                }
            }
        }
        //同一斜线
        for(int i=0;i<300-3;i++){
            for(int j=0;j<300-3;j++){
                if(r[i][j]=='2'&&r[i+1][j+1]=='0'&&r[i+2][j+2]=='2'&&r[i+3][j+3]=='0'){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}

运行结果：

八，门牌制作-JavaB(11届）

import java.util.Scanner;
public class A1 {
    public static void main(String []args){
        int count=0;
        //拆分数字，计算里面含有某个数字的个数
        for(int i=1;i<=2020;i++){
            int x=i;//防止死循环
            while(x>0){
                if(x%10==2){
                    count++;
                }
                x=x/10;
            }
        }
        System.out.println(count);
    }
}

运行结果：624

九，时间显示-JavaB(12届）

public class A0 {
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        Long n=sc.nextLong();
        n=n%(24*60*60*1000);
        n/=1000;
        int h=(int)(n/3600);
        int m=(int)((n%3600)/60);
        int s=(int)((n%3600)%60);
        //注意，这里必须用printf才能输出
        System.out.printf("%02d:%02d:%02d\n",h,m,s);

      }

    }

十，ASC-javaB(12届）

public class L1{
    public static void main(String[] args){
   int i='L'-'A'+65;
   System.out.println(i);
       }
    }

十一，字符统计-JavaB(13届)

import java.util.Scanner;

public class L1 {
public static void main(String []args){
Scanner scan=new Scanner(System.in);
String S=scan.next();
int len=S.length();
int[] array=new int[26];
int i,max=0;
for(i=0;i<len;i++){
    array[S.charAt(i)-'A']++;//统计字符串中字符出现的总次数
    max=Math.max(max,array[S.charAt(i)]-'A');//统计字符串中字符出现的最大值
}
for(i=0;i<26;i++){
    if(max==array[i])
        System.out.println("%c"+(char)(i+'A'));//输出最大值
}
}

    }

十二，山-javaB(13届）

思路：首先设计一个算法，判断是否为山，满足山的两个条件，一是从第一个数到第1/2位是否为单调递增。其次从2022到2022222022进行循环

public class L1 {
public static void main(String []args){
int count=0;
for(int m=2022;m<=2022222022;++m){
    if(isshan(1)){
        count++;
    }
}
System.out.println(count);
}
//1，先编写一个方法判断一个数是不是shan
    //1.1先输入一个字符串形式的将其转化为数组
    //1.2依次遍历，从数的第一个数字到第二分之一个数字判断是否为单调递增，是否左右对称
public static boolean isshan(long a){
    //valueOf是将对象s改成String类型的对象
    String s=String.valueOf(a);
    //CharArray是将字符串中的字符转化为字符数组
    char []chars=s.toCharArray();
    for(int i=0;i<s.length()/2;i++){
        //是否满足单调递增和对称的条件，注意是否对称该如何表示
        if(chars[i]<chars[i+1]||chars[i]!=chars[chars.length-i-1]);
        return false;
    }
    return true;
}
    }

十三，星期计算-JavaB(13届）

import java.math.BigInteger;
public class L1 {
    public static void main(String[] args) {
        //先计算20的22次方
        BigInteger bi=new BigInteger("20");
        //20的22次方的运行结果
        BigInteger res=new BigInteger("1");
        for(int i=0;i<22;i++){
            //BigInteger是一个类，加减乘除和取模等运算都是调用
            res=res.multiply(bi);
            System.out.println(i+1+"次方的结果"+res.toString());
        }
        System.out.println("------------");
        System.out.println(res.toString());
        System.out.println("------------");
        BigInteger mo=new BigInteger("7");
        //一周七天，将res%7；
        res=res.remainder(mo);
        //计算出1，然后在周六的基础上加一
        System.out.println(res.toString());
        }
    }

十四，阶乘求和JavaB(14届)

方法一：

import java.math.BigInteger;
public class L1 {

    public static void main(String[] args) {
        BigInteger n=new BigInteger("1");
        BigInteger sum=new BigInteger("0");
        for(int i=1;i<50;i++) {
            n=n.multiply(new BigInteger(""+i));
            sum=sum.add(n);
            System.out.println("i="+i+"时，sum后九位是："+sum.mod(new BigInteger(""+1000000000)));
        }
    }
}

方法2：利用for循环

import java.util.Scanner;

public class myPractice {

	public static int sumFac(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int ret = 1;
            for (int j = 1; j <= i; j++) {
                ret *= j; // ret = ret * j;
            }
            sum += ret; // sum = sum + ret;
        }
        return sum;
    }

	public static void main(String[] args) { // m4
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int ret = sumFac(n);  //方法二
        System.out.println(n + " 的阶乘和为：" + ret);
    }
}

十五，买二赠一JavaB(14)

思路：将他们的价格进行从小到大排列放入一个数组中，从后向前买可以免费，买两个可免费一个，进行遍历数组，引入一个队列，如果原数组有比这个小的值，直接往前走。

package 蓝桥杯备赛;
 
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.concurrent.ConcurrentLinkedQueue;
 
public class 买二赠一 {
 
	public static void main(String[] args) {
		//写入数据
		Scanner scan = new Scanner(System.in);
		int number;
		number = scan.nextInt();
		int price[] = new int[number];
		for(int i=0;i<number;i++) {
			price[i] = scan.nextInt();
		}
		long res = 0;
		scan.close();
		Arrays.sort(price);
		
		int t = number-1;
		Queue<Integer> queue = new LinkedList<>();
		boolean flag = false;
		
		while(t>=0) {
			if(!queue.isEmpty()&&price[t]<=queue.peek()) {//如果队列非空且价格小于队列的第一个元素。queue.peek只会获取队列头部元素，不会删除。
				queue.poll();//出队列
			}
			else {
				if(flag) {
					queue.add(price[t]/2);
					flag = false;
				}
				else {
					flag = true;
				}
				res += price[t];
			}
			t--;
		}
		System.out.print(res);
	
	}
}

十六，矩形总面积JavaB(14届）

思路：总面积减去重叠面积，不重叠的话，重叠面积就是0，不用考虑特殊情况了

找到其中的规律

import java.util.Scanner;
public class L2 {
    public  static void main(String []args){
Scanner sc=new Scanner(System.in);
        int x1=sc.nextInt();
        int y1=sc.nextInt();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        int x3=sc.nextInt();
        int y3=sc.nextInt();
        int x4=sc.nextInt();
        int y4=sc.nextInt();
        //总面积减去重叠面积，先计算总面积
        long sum=(long)(x2-x1)*(y2-y1)+(long)(x4-x3)*(y4-y3);
        //重叠面积
        long width=Math.max(x1,x3)-Math.min(x2,x4);
        long high=Math.min(y2,y4)-Math.max(y1,y3);
        //判断是否有重叠面积
        if(width>0&&high>0){
            sum=sum-width*high;
        }
        System.out.println(sum);

    }
}

十七，幸运数字JavaB(14届)

public class Main{
    public static void main(String[] args) {
        int j=0;
        for (int i=1;i<10000000;i++){
            if (BaseConversion(i)){
                j++;
                if (j==2023){
                    System.out.println(i);//215040
                    break;
                }
            }
        }
    }
    public static boolean BaseConversion(int n){
        //十进制
        int sum=0;
        int x=n;
        while (x!=0){
            sum+=(x%10);
            x/=10;
        }
        if (n%sum!=0)
            return false;
        //二进制
        sum=0;
        x=n;
        while (x!=0){
            sum+=(x%2);
            x/=2;
        }
        if (n%sum!=0)
            return false;
        //八进制
        sum=0;
        x=n;
        while (x!=0){
            sum+=(x%8);
            x/=8;
        }
        if (n%sum!=0)
            return false;
        //十六进制
        int[] arr={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
        sum=0;
        x=n;
        while (x!=0){
            sum+=(arr[x%16]);
            x/=16;
        }
        if (n%sum!=0)
            return false;
        return true;
    }
}

十八，一步之遥

从昏迷中醒来，小明发现自己被关在X星球的废矿车里。
矿车停在平直的废弃的轨道上。
他的面前是两个按钮，分别写着“F”和“B”。

小明突然记起来，这两个按钮可以控制矿车在轨道上前进和后退。
按F，会前进97米。按B会后退127米。
透过昏暗的灯光，小明看到自己前方1米远正好有个监控探头。
他必须设法使得矿车正好停在摄像头的下方，才有机会争取同伴的援助。
或许，通过多次操作F和B可以办到。

矿车上的动力已经不太足，黄色的警示灯在默默闪烁…
每次进行 F 或 B 操作都会消耗一定的能量。
小明飞快地计算，至少要多少次操作，才能把矿车准确地停在前方1米远的地方。

请填写为了达成目标，最少需要操作的次数。

public class L0{

        public static void main(String[] args) {
            for (int i = 1; i < 100; i++) {
                for (int j = 1; j < 100; j++) {
                    if (i * 97 - j * 127 == 1) {
                        System.out.println(i+j);
                    }
                }
            }}}

Integer.MAX_VALUE表示int数据类型的最大取值数：2 147 483 647
Integer.MIN_VALUE表示int数据类型的最小取值数：-2 147 483 648

String类型有一个方法：contains（）,该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。

import java.util.ArrayList;

public class L0{

    public static ArrayList<Integer> list=new ArrayList<Integer>();
    public static int f(int a, int b){
    if(b>200||list.contains(a)){
        return Integer.MAX_VALUE;
    }
    list.add(a);
    if(a==11)return b;
    return Math.min(f(a+97,b+1),f(a-127,b+1));
}
        public static void main(String[] args) {
            
                        System.out.println(f(0,0));
                    }
                }
            v

十九，求最大公约数和最小公倍数-进制整除法

运用欧几里得算法

//欧几里得算法，求最大公约数，gcd(A,B)
public class L0{
static int gcd(int a,int b){
    if(b==0) return a;
    return gcd(b,a%b);
}

    public static void main(String[] args){
System.out.println(gcd(60,42));
}}

//欧几里得算法，求最大公约数，gcd(A,B)
//最小公倍数，算数基本定理，质因数分解的唯一性
public class L0{
static int gcd(int a,int b){
    if(b==0) return a;
    return gcd(b,a%b);
}
static int lcm(int a,int b){
    return a*b/gcd(a,b);
}

    public static void main(String[] args){
System.out.println(gcd(60,42));
System.out.println(lcm(60,42));
}}

//直接计算

import java.util.Scanner;
public class L1{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        int n=sc.nextInt();
        System.out.println("请分别输入两个整数"+m+" "+n);
        int min=m<n?m:n;
        for(int i=min;i>0;i--){//从大到小除，第一个救是最大公约数
            if(m%i==0&&n%i==0){
                min=i;//最大公约数；
                break;
            }
            int max=(m*n)/min;
            System.out.println("最大公约数，最小公倍数分别为："+max+"   "+min);
        }
    }
}

二十，天平称重-进制与整除

用天平称重时，我们希望用尽可能少的砝码组合称出尽可能多的重量。

如果只有5个砝码，重量分别是1，3，9，27，81

则它们可以组合称出1到121之间任意整数重量（砝码允许放在左右两个盘中）。

本题目要求编程实现：对用户给定的重量，给出砝码组合方案。

例如：

用户输入：

5

程序输出：

9-3-1

用户输入：

19

程序输出：

27-9+1

要求程序输出的组合总是大数在前小数在后。

可以假设用户的输入的数字符合范围1~121

思路：首先列举出前几位数字，找规律

replace的用法，替换旧字符串，形成新字符串

public class L0{
static String reve(String s){
    //正负变号
    s=s.replace("#","+");
    s=s.replace("-","#");
    s=s.replace("#","+");
    return "-"+s;
}
    static String f(int x){
        int a=1;
        while(a<x)a=a*3;
        if(a==x)return ""+a;
        if(x<=a/2)return a/3+"+"+f(x-a/3);
        return a+reve(f(a-x));
    }

    public static void main(String[] args){
        for(int i=1;i<100;i++){
System.out.println(i+"+"+"="+f(i));
    }
}}

二十一，杨辉三角

杨辉三角的数值部分实现

//杨辉三角
//1，创建一个二维数组
//2，寻找二维数组之间的关系并输出
public class A0 {
    public static void main(String []args){
      int[][] arr=new int[10][10];
      for(int i=0;i<arr.length;i++){
          for(int j=0;j<=i;j++){
              if(j==0||j==i){
               arr[i][j]=1;}
                  else{
                      arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                      }
                  System.out.println(arr[i][j]);
              }
          }

      }

    }

二十二，递归-振兴中华

小明参加了学校的趣味运动会，其中的一个项目是：跳格子。地上画着一些格子，每个格子里写一个字
从我做起振
我做起振兴
做起振兴中
起振兴中华
比赛时，先站在左上角的写着“从”字的格子里，可以横向或纵向跳到相邻的格子里，但不能跳到对角的格子或其它位
置。一直要跳到“华”字结束。要求跳过的路线刚好构成“从我做起振兴中华”这句话。
请你帮助小明算一算他一共有多少种可能的跳跃路线呢？
答案是一个整数，请通过浏览器直接提交该数字。
注意：不要提交解答过程，或其它辅助说明类的内容。
————————————————
原文链接：https://blog.csdn.net/weixin_55054681/article/details/124139989

思路：将其想象为一个坐标系，只能向下或者向右移动，横坐标加一或者纵坐标加一，进行循环

public class L0 {
    public static int f(int a,int b){
        if(a==4||b==3)return 1;
        else return(f(a+1,b)+f(b+1,a));
    }

    public static void main(String[] args){
int a=f(0,0);
System.out.println(a);
    }

二十三，暴力枚举-罗马逆向数字

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:

输入: “III”
输出: 3
示例 2:

输入: “IV”
输出: 4
示例 3:

输入: “IX”
输出: 9
示例 4:

输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:

输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

提示：

1 <= s.length <= 15
s 仅含字符 (‘I’, ‘V’, ‘X’, ‘L’, ‘C’, ‘D’, ‘M’)
题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
关于罗马数字的详尽书写规则，可以参考罗马数字 - Mathematics 。

思路：将某一个数进行拆分成各个位，进行组合分析。拆开列举组合

public class L0 {
    static String NumRoman(int x){
        //首先确定各个位数
        int a=x/1000;
        int b=x%1000/100;
        int c=x%100/10;
        int d=x%10;
        String s="";
        //枚举各个数值
        if(a==1)s+="M";
        if(a==2)s+="MM";
        if(a==3)s+="MMM";
        if(a==4)s+="MMMM";
        if(b==1)s+="C";
        if(b==2)s+="CC";
        if(b==3)s+="CCC";
        if(b==4)s+="CD";
        if(b==5)s+="D";
        if(b==6)s+="DC";
        if(b==7)s+="DCC";
        if(b==8)s+="DCCC";
        if(b==9)s+="CM";
        if(c==1)s+="X";
        if(c==2)s+="XX";
        if(c==3)s+="XXX";
        if(c==4)s+="XL";
        if(c==5)s+="L";
        if(c==6)s+="LX";
        if(c==7)s+="LXX";
        if(c==8)s+="LXXX";
        if(c==9)s+="XC";
        if(d==1)s+="|";
        if(d==2)s+="||";
        if(d==3)s+="|||";
        if(d==4)s+="|V";
        if(d==5)s+="V";
        if(d==6)s+="V|";
        if(d==7)s+="V||";
        if(d==8)s+="V|||";
        if(d==9)s+="|X";
        return s;

    }
    //判断罗马数字是否正确
    static boolean RomanNumOK(String s){
        for(int i=0;i<4000;i++){
            if(s.equals(NumRoman(i)))return true;

        }
        return false;
    }
    public static void main(String []args){
        System.out.println(RomanNumOK("ccxx"));
        System.out.println(NumRoman(1234));
    }
}

二十四，二进制中1的个数（位运算）

import java.util.Scanner;

//换算二进制，1的个数
public class A0 {
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int N=sc.nextInt();
        System.out.println(Integer.toString(N,2));
        int count=0;
        //比对每一位
        for(int i=0;i<32;i++){
            if((N&(1<<i))==(1<<i)){//将每个1往左移，判断1的位数
                count++;
            }
           /* if(((N>>>i)&1)==1){
                count++;
            }*/
        }
System.out.println(count);

    }
}

二十五，用一条语句判断一个整数是不是2的整数次方（位运算）

import java.util.Scanner;

//用一条语句判断一个整数是不是2的整数次方
public class A1 {
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int b=sc.nextInt();
        if(((b-1)&b)==0){
        System.out.println("是2的整数次方");
} else{
            System.out.println("不是2的整数次方");
        }
    }
}

二十六，最少砝码

import java.util.Scanner;
public class L1{
    public static void main(String[] args){
 Scanner sc=new Scanner(System.in);
 int n=sc.nextInt();
 int n1=1;
 int n2=1;
 int total=1;
 while(total<n){
     n1++;
     n2=n2*3;
     total+=n2;
     }
 System.out.println(n1);
 }
       }

二十七，递归-找钱问题

公园票价为5角。假设每位游客只持有两种币值的货币：5角、1元。

再假设持有5角的有m人，持有1元的有n人。

由于特殊情况，开始的时候，售票员没有零钱可找。

我们想知道这m+n名游客以什么样的顺序购票则可以顺利完成购票过程。

显然，m < n的时候，无论如何都不能完成；

m>=n的时候，有些情况也不行。比如，第一个购票的乘客就持有1元。

请计算出这m+n名游客所有可能顺利完成购票的不同情况的组合数目。

注意：只关心5角和1元交替出现的次序的不同排列，持有同样币值的两名游客交换位置并不算做一种新的情况来计数。

思路：递归，考虑可能出现的不同可能，从后往前逐步分析0.5与1的个数

public class L0 {
    public static int c(int m,int n){
        if(m==0)return 0;
        if(n==0)return 1;
        if(m<n)return 0;
        if(m==1&&n==1)return 1;
        return c(m-1,n)+c(n-1,m);
    }

    public static void main(String[] args){
System.out.println(c(2,3));
    }
}

二十八，暴力枚举-罗马数字的枚举解法

古罗马帝国开创了辉煌的人类文明，但他们的数字表示法的确有些繁琐，尤其在表示大数的时候，现在看起来简直不能忍受，所以在现代很少使用了。
之所以这样，不是因为发明表示法的人的智力的问题，而是因为一个宗教的原因，当时的宗教禁止在数字中出现0的概念！
罗马数字的表示主要依赖以下几个基本符号：

I --> 1
V --> 5
X --> 10
L --> 50
C --> 100
D --> 500
M --> 1000

这里，我们只介绍一下1000以内的数字的表示法。
单个符号重复多少次，就表示多少倍。最多重复3次。
比如：CCC表示300 XX表示20，但150并不用LLL表示，这个规则仅适用于I X C M。

如果相邻级别的大单位在右，小单位在左，表示大单位中扣除小单位。
比如：IX表示9 IV表示4 XL表示40
49 = XLIX

更多的示例参见下表，你找到规律了吗？
I = 1
II = 2
III = 3
IV = 4
V = 5
VI = 6
VII = 7
VIII = 8
IX = 9
X = 10
XI = 11
XII = 12
XIII = 13
XIV = 14
XV = 15
XVI = 16
XVII = 17
XVIII = 18
XIX = 19
XX = 20
XXI = 21
XXII = 22
XXIX = 29
XXX = 30
XXXIV = 34
XXXV = 35
XXXIX = 39
XL = 40
L = 50
LI = 51
LV = 55
LX = 60
LXV = 65
LXXX = 80
XC = 90
XCIII = 93
XCV = 95
XCVIII = 98
XCIX = 99
C = 100
CC = 200
CCC = 300
CD = 400
D = 500
DC = 600
DCC = 700
DCCC = 800
CM = 900
CMXCIX = 999

本题目的要求是：请编写程序，由用户输入若干个罗马数字串，程序输出对应的十进制表示。

输入格式是：第一行是整数n,表示接下来有n个罗马数字(n<100)。
以后每行一个罗马数字。罗马数字大小不超过999。
要求程序输出n行，就是罗马数字对应的十进制数据。

例如，用户输入：
3
LXXX
XCIII
DCCII

则程序应该输出：
80
93
702

思路：以单个字符的形式，合成数字相加

public class L0 {
    public static int romeName(String s){
        int sum=0;
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);//字符是单引号，转换为字符
            if(c=='|')sum+=1;//c
            if(c=='V')sum+=5;
            if(c=='X')sum+=10;
            if(c=='L')sum+=50;
            if(c=='C')sum+=100;
            if(c=='D')sum+=500;
            if(c=='M')sum+=1000;
        }
        return sum;
    }
    public static void main(String[] args){
System.out.println(romeName("CCXX"));
    }
}

二十九，暴力枚举-利用位数猜年龄

美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，他回答说：“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”请你推算一下，他当时到底有多年轻。

思路：利用for循环，枚举，排除法

public class L0 {
    public static void main(String[] args){
    for(int i=1;i<100;i++){
    int a=i*i*i;
    int b=a*i;
    if(((a+"").length())!=4)continue;//注意是（a+“”）
    if(((b+"").length())!=6)continue;
    System.out.println(i+"="+a+" "+b);
}
    }
}

三十，幸运数字

【问题描述】

哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整数。例如 126 是十进制下的一个哈沙德数，因为 (126) 10 mod (1+2+6) = 0 ； 126 也是八进制下的哈沙德数，因为 (126) 10 = (176) 8 ， (126) 10 mod (1 + 7 + 6) = 0 ；同时 126 也是 16 进制下的哈沙德数，因为 (126) 10 = (7 e ) 16 ， (126) 10 mod (7 + e ) = 0 。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为哈沙德数，那么这个数字就是幸运数字，第 1 至第 10 个幸运数字的十进制表示为：1 , 2 , 4 , 6 , 8 , 40 , 48 , 72 , 120 , 126 . . . 。现在他想知道第 2023 个幸运数字是多少？你只需要告诉小蓝这个整数的十进制表示即可。

public class Main{

    public static void main(String[] args) {

        int j=0;

        for (int i=1;i<10000000;i++){

            if (BaseConversion(i)){

                j++;

                if (j==2023){

                    System.out.println(i);//215040

                    break;

                }

            }

        }

    }

    public static boolean BaseConversion(int n){

        //十进制

        int sum=0;

        int x=n;

        while (x!=0){

            sum+=(x%10);

            x/=10;

        }

        if (n%sum!=0)

            return false;

        //二进制

        sum=0;

        x=n;

        while (x!=0){

            sum+=(x%2);

            x/=2;

        }

        if (n%sum!=0)

            return false;

        //八进制

        sum=0;

        x=n;

        while (x!=0){

            sum+=(x%8);

            x/=8;

        }

        if (n%sum!=0)

            return false;

        //十六进制

        int[] arr={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

        sum=0;

        x=n;

        while (x!=0){

            sum+=(arr[x%16]);

            x/=16;

        }

        if (n%sum!=0)

            return false;

        return true;

    }

}