一：基础练习：

（本文只附代码，解析后续修改后添上)

　　1.a+b问题：

　　　　代码如下：

　　　　

  1.  1 import java.util.*;
  2.  2 public class Main {
  3.  3     public static void main(String args[]) {
  4.  4     int a,b;
  5.  5
  6.  6         Scanner input = new Scanner(System.in);
  7.  7         a = input.nextInt();
  8.  8         b = input.nextInt();
  9.  9
  10. 10         System.out.println(a+b);
  11. 11     }
  12. 12 }

　　2.序列排序问题：

　　　　代码如下：

　　　　

  1.  1 import java.util.Arrays;
  2.  2 import java.util.Scanner;
  3.  3
  4.  4 public class Main {
  5.  5     public static void main(String[] args) {
  6.  6         Scanner scanner = new Scanner(System.in);
  7.  7         int n = scanner.nextInt();
  8.  8         int[] arr = new int[n];
  9.  9         //往数组添加元素，接收数据
  10. 10         for (int i = 0; i < n; i++) {
  11. 11             arr[i] = scanner.nextInt();
  12. 12         }
  13. 13
  14. 14         //对数组排序
  15. 15         Arrays.sort(arr);
  16. 16
  17. 17         //打印数组
  18. 18         for (int i = 0; i < n; i++) {
  19. 19             System.out.print(arr[i] + " ");
  20. 20         }
  21. 21     }
  22. 22 }

　　3.十六进制转八进制：

　　　　代码如下：

　　　　　　

  1. import java.util.Scanner;
  2.  public class Main {
  3.         public static void main(String[] args) {
  4.             Question1();
  5.  
  6.         }
  7.         public static void Question1() {
  8.             Scanner in = new Scanner(System.in);
  9.             int n = Integer.parseInt(in.nextLine());
  10.             int i, j;
  11.             String[] sz = new String[n];
  12.             //读入十六进制数
  13.             for (i = 0; i < n; i++) {
  14.                 sz[i] = in.next();
  15.             }
  16.             for(i = 0; i < sz.length; i++) {
  17.                 String s = sz[i];
  18.                 StringBuilder sb = new StringBuilder();
  19.                 //将一位十六进制数转换为四位二进制数
  20.                 for(j = 0; j < s.length(); j++) {
  21.                     switch(s.charAt(j)) {
  22.                         case '0':
  23.                             sb.append("0000");
  24.                             break;
  25.                         case '1':
  26.                             sb.append("0001");
  27.                             break;
  28.                         case '2':
  29.                             sb.append("0010");
  30.                             break;
  31.                         case '3':
  32.                             sb.append("0011");
  33.                             break;
  34.                         case '4':
  35.                             sb.append("0100");
  36.                             break;
  37.                         case '5':
  38.                             sb.append("0101");
  39.                             break;
  40.                         case '6':
  41.                             sb.append("0110");
  42.                             break;
  43.                         case '7':
  44.                             sb.append("0111");
  45.                             break;
  46.                         case '8':
  47.                             sb.append("1000");
  48.                             break;
  49.                         case '9':
  50.                             sb.append("1001");
  51.                             break;
  52.                         case 'A':
  53.                             sb.append("1010");
  54.                             break;
  55.                         case 'B':
  56.                             sb.append("1011");
  57.                             break;
  58.                         case 'C':
  59.                             sb.append("1100");
  60.                             break;
  61.                         case 'D':
  62.                             sb.append("1101");
  63.                             break;
  64.                         case 'E':
  65.                             sb.append("1110");
  66.                             break;
  67.                         case 'F':
  68.                             sb.append("1111");
  69.                             break;
  70.                     }
  71.                 }
  72.                 //再将二进制数转换成八进制数
  73.                 transform(sb);
  74.             }
  75.  
  76.         }
  77.         public static void transform(StringBuilder sb) {
  78.             int num = sb.length() % 3;
  79.             //判断长度是否为3的倍数
  80.             switch(num) {
  81.                 case 0:
  82.                     //若转换的八进制数中第一位为0则删去
  83.                     if(sb.substring(0, 3).equals("000"))
  84.                         sb.delete(0, 3);
  85.                     break;
  86.                 case 1:
  87.                     if(sb.substring(0, 1).equals("0"))
  88.                         sb.delete(0, 1);
  89.                     else sb = sb.insert(0, "00");
  90.                     break;
  91.                 case 2:
  92.                     if(sb.substring(0, 2).equals("00"))
  93.                         sb.delete(0, 2);
  94.                     else sb = sb.insert(0, "0");
  95.                     break;
  96.             }
  97.             StringBuilder res = new StringBuilder();
  98.             int len = sb.length();
  99.             String[] new_s1 = new String[len/3];
  100.             //取三位转换成八进制数
  101.             for(int i = 0; i < len/3; i++) {
  102.                 int tmp = Integer.parseInt(sb.substring(i * 3, i * 3 + 3), 2);
  103.                 res.append(tmp);
  104.             }
  105.             System.out.println(res);
  106.         }
  107.     }

4.十六进制转十进制：

　　代码如下：

　　　　

  1. import java.util.Scanner;
  2. public class Main {
  3. 	public static void main(String[] args) {
  4. 		Scanner scanner = new Scanner(System.in);
  5. 		String string = scanner.nextLine();
  6. 		System.out.print(Long.parseLong(string, 16));
  7. 	}
  8. }

5.十进制转十六进制：

　　代码如下：

　　　　

  1. import java.util.Scanner;
  2. public class Main {
  3.         public static void main(String[] args) {
  4.             Scanner input = new Scanner(System.in);
  5.             one(input.nextInt());
  6.  
  7.         }
  8.  
  9.         public static void one(int a){
  10.             int b;
  11.             if(a<=15) {
  12.                 tohax(a);
  13. //            System.out.print(a);
  14.  
  15.             }
  16.             else{
  17.                 b=a%16;
  18.                 one(a>>4);
  19.                 tohax(b);
  20. //            System.out.print(b);
  21.             }
  22.         }
  23.         public static void tohax(int c){
  24.             switch (c){
  25.                 default:
  26.                     System.out.print(c);
  27.                     break;
  28.  
  29.                 case 10:
  30.                     System.out.print("A");
  31.                     break;
  32.                 case 11:
  33.                     System.out.print("B");
  34.                     break;
  35.                 case 12:
  36.                     System.out.print("C");
  37.                     break;
  38.                 case 13:
  39.                     System.out.print("D");
  40.                     break;
  41.                 case 14:
  42.                     System.out.print("E");
  43.                     break;
  44.                 case 15:
  45.                     System.out.print("F");
  46.                     break;
  47.  
  48.             }
  49.         }
  50.     }

6.特殊的回文数：

　　代码如下：

　　　　

  1. import java.util.Scanner;
  2.  
  3. public class Main {
  4.         final static byte one = 1;//常量1.
  5.         final static byte two = 2;//常量2.
  6.         final static byte ten = 10;//常量10；
  7.  
  8.         //输入：正整数n。
  9.  
  10.     //输出：y行，每行为一个回文数。
  11.         /*
  12.         * 格式：回文数每个数的和都为n
  13.         *       从左读和从右读是一样的，所以是关于y轴对称。
  14.         *       数据大小：10001-999999。n的大小为2-54.
  15.         *       5位的是2-45，6位的是2-54.
  16.         * 要求：10进制，五位到六位的所有正整数。
  17.         *       从小到大输出结果。
  18.         * */
  19.  
  20.     //程序如下：
  21.         //1.输入正整数n。
  22.         //2.判断是否是偶数，不是，则说明一定是5位。
  23.         //3.判断是否小于45，不是，则说明一定是6位。
  24.         //4.求5位。输出结果
  25.         //5.   求6位。输出结果
  26.     public static void main(String[] args) {
  27.  
  28.             Scanner input = new Scanner(System.in);
  29.             byte in = input.nextByte(); //获取到输入到2-54的一个正整数。
  30.  
  31.             if (in % two != 0) {
  32.                     askfive(in);//不是偶数，就只求5位
  33.             } else if (in > 45) {
  34.                     asksix(in);//大于45，就只求6位。
  35.             } else {//都不是，就要求5位和6位。
  36.                     askfive(in);
  37.                     asksix(in);
  38.             }
  39.     }
  40.  
  41.         public static void askfive(byte in) {
  42.                 //求5位数。
  43.                 //先确定第一位最小值存不存在。
  44.                 for (int i = one; i <ten ; i++) {//第一位
  45.                         for (int j = 0; j <ten ; j++) {//第二位
  46.                                 final int i0 = in - two * i - two * j;
  47.                                 if (i0 < ten&&i0>=0) {//求第一位等于第五位，第二位等于第四位，第三位是否满足小于10的要求的数存在。
  48.                                         System.out.println(i+""+j+""+i0+""+j+""+i);
  49.  
  50.                                 }
  51.                         }
  52.                 }
  53.         }
  54.  
  55.         public static void asksix(byte in) {
  56.                 //求6位数。
  57.                 //先确定第一位最小值存不存在。
  58.                 for (int i = one; i <ten ; i++) {//第一位数
  59.                         for (int j = 0; j <ten ; j++) {//第二位数
  60.                                final int i1 = (in - two * i - two * j) / two;
  61.                                 if (i1 < ten&&i1>=0) {//第三位数成立
  62.                                         System.out.println(i+""+j+""+ i1 +""+ i1 +""+j+""+i);
  63.                                 }
  64.  
  65.                         }
  66.  
  67.                 }
  68.         }
  69.  
  70. }

7.回文数：

　　代码如下：

　　　　

  1. public class Main {
  2.  
  3.     /*
  4.     * 输入：无
  5.     * 输出：回文数
  6.     *   格式要求：长度是四位的十进制数。关于y轴对此，第一位等于第四位，第二位等于第三位。
  7.     *              范围是1001-9999.
  8.     *   要求：从小到大。
  9.     * */
  10.  
  11.     //编程思路：
  12.     //1.从第一位为1，第二位为0，开始循环。
  13.     //2、输出所有这样的数。
  14.  
  15.     public static void main(String[] args) {
  16.         for (int i = 1; i <10 ; i++) {//第一位
  17.             for (int j = 0; j < 10; j++) {//第二位
  18.                 System.out.println(i+""+j+""+j+""+i);
  19.             }
  20.         }
  21.     }
  22. }

8.特殊的数字：

　　代码如下：

　　　　

  1. public class Main {
  2.     final static byte ten = 10;//常量10；
  3.     final static byte three = 3;//常量3；
  4.  
  5.     /*
  6.     * 输入：无
  7.     * */
  8.  
  9.     /*
  10.     * 输出：n行，三位的十进制
  11.     * 格式要求：从小到大。
  12.     * */
  13.  
  14.     //程序思路：
  15.         //1、范围是从100-999.而根据立方根来推断，如果从立方根下手，最小要从105（1+125>100)开始循环，最大到962(8+216+729<999)
  16.     // 2.对三个数循环，求和，判断是否等于自己的10进制。
  17.     // 3.输出所有相等的数。
  18.  
  19.     public static void main(String[] args) {
  20.         for (int i = 105; i <963 ; i++) {
  21.             int a = i % ten;//个位。
  22.             int b = (i / ten)%ten;//十位位。
  23.             int c = i/100 ;//百位。
  24.             if (i == (Math.pow(a, three) + Math.pow(b, three) + Math.pow(c, three))) {
  25.                 System.out.println(i);
  26.             }
  27.  
  28.                 }
  29.  
  30.             }
  31.  
  32.         }

9.杨辉三角：

　　代码如下：

　　　　

  1. import java.util.Scanner;
  2.  
  3. public class Main {
  4.  
  5.     /*
  6.     * 输入：整数n
  7.     * 格式要求：n的范围是1-34.
  8.     * */
  9.  
  10.     /*
  11.     * 输出：n行，每一行是杨辉三角的数。
  12.     * 格式要求，每一行的每个数要按顺序输出，并且要使用一个空格分隔。
  13.     * */
  14.  
  15.     //程序思路：
  16.         //1、输入一个byte大小的数，n
  17.         //2、根据Cn，循环和递归的方式来求每一行每一个数
  18.  
  19.     public static void main(String[] args) {
  20.  
  21.         Scanner input = new Scanner(System.in);
  22.         byte n = input.nextByte();//获取整形n。
  23.  
  24.         askYh(n);
  25.  
  26.     }
  27.     public static void askYh(byte n) {//求杨辉的某行。
  28.         int b = n-1;//C的下方。
  29.         if (b == 0) {//说明是第一行
  30.             System.out.println("1");
  31.         }
  32.         for (int i = 0; i < n; i++) {//n行。
  33.             for (int j = 0; j <=i; j++) {//对C的上方从0到i循环，不能大于i。
  34.                 int out = askJc(i, j) / askJc02(i, j);
  35.                 System.out.print(out + " ");
  36.             }
  37.             System.out.println();//换行。
  38.         }
  39.     }
  40.  
  41.     public static int askJc(int i,int j) {//求b!/i!
  42.         //递归调用
  43.         if (i == j + 1) {
  44.             return i;
  45.         }
  46.         if (i == j) {//当c的上方和下方相同的时候，返回1.
  47.             return 1;
  48.         }
  49.         return i*askJc(i-1,j);
  50.     }
  51.  
  52.     public static int askJc02(int i,int j) {//求（b-i）！
  53.         if ((i == j + 1)||(i == j)) //当i-j = 1 的和i=j的时候
  54.             return 1;
  55.  
  56.          return (i - j) * askJc02(i - 1, j);
  57.         }
  58.  
  59.     }
  1.  1 import java.util.Scanner;
  2.  2
  3.  3 public class test04 {
  4.  4
  5.  5
  6.  6     /*
  7.  7     * 输入：整数n
  8.  8     * 格式要求：n的范围是1-34.
  9.  9     * */
  10. 10
  11. 11     /*
  12. 12     * 输出：n行，每一行是杨辉三角的数。
  13. 13     * 格式要求，每一行的每个数要按顺序输出，并且要使用一个空格分隔。
  14. 14     * */
  15. 15
  16. 16
  17. 17     //程序思路：
  18. 18         //1、输入一个byte大小的数，n
  19. 19         //2、根据Cn，循环和递归的方式来求每一行每一个数
  20. 20
  21. 21
  22. 22     public static void main(String[] args) {
  23. 23
  24. 24         Scanner input = new Scanner(System.in);
  25. 25         byte n = input.nextByte();//获取整形n。
  26. 26
  27. 27         askYh(n);
  28. 28
  29. 29     }
  30. 30     public static void askYh(byte n) {//求杨辉的某行。
  31. 31         int b = n-1;//C的下方。
  32. 32         if (b == 0) {//说明是第一行
  33. 33             System.out.println("1");
  34. 34         }
  35. 35         for (int i = 0; i < n; i++) {//n行。
  36. 36             for (int j = 0; j <=i; j++) {//对C的上方从0到n-1循环
  37. 37                 int out = askJc(i, j) / askJc02(i, j);
  38. 38                 System.out.print(out + " ");
  39. 39             }
  40. 40             System.out.println();//换行。
  41. 41         }
  42. 42     }
  43. 43
  44. 44     public static int askJc(int i,int j) {//求b!/i!
  45. 45         //递归调用
  46. 46         if (i == j + 1) {
  47. 47             return i;
  48. 48         }
  49. 49         if (i == j) {//当c的上方和下方相同的时候，返回1.
  50. 50             return 1;
  51. 51         }
  52. 52         return i*askJc(i-1,j);
  53. 53     }
  54. 54
  55. 55     public static int askJc02(int i,int j) {//求（b-i）！
  56. 56         if ((i == j + 1)||(i == j)) //当b-i = 1 或者i=j的时候。
  57. 57             return 1;
  58. 58
  59. 59          return (i - j) * askJc02(i - 1, j);
  60. 60         }
  61. 61
  62. 62     }

　　//未完，待更。。。

蓝桥杯2022年java试题的更多相关文章

  1. 取球游戏_nyoj_518(博弈-蓝桥杯原题).java

    取球游戏 时间限制: 1000 ms  |  内存限制: 65535 KB 难度: 2   描述 今盒子里有n个小球,A.B两人轮流从盒中取球,每个人都可以看到另一个人取了多少个,也可以看到盒中还剩下 ...

  2. 蓝桥杯算法训练 java算法 表达式求值

    问题描述 输入一个只包含加减乖除和括号的合法表达式,求表达式的值.其中除表示整除. 输入格式 输入一行,包含一个表达式. 输出格式 输出这个表达式的值. 样例输入 1-2+3*(4-5) 样例输出 - ...

  3. 记 2019蓝桥杯校内预选赛(JAVA组) 赛后总结

    引言 好像博客好久没更新了 哈哈哈哈哈 趁现在有空更新一波 不知道还有没有人看 确实该记录一下每天做了什么了 不然感觉有些浑浑噩噩了 比赛介绍 全称: 蓝桥杯全国软件和信息技术专业人才大赛 蓝桥杯 实 ...

  4. 蓝桥杯-四平方和-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

  5. 蓝桥杯- 移动距离-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

  6. 蓝桥杯-密码发生器-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

  7. 蓝桥杯-括号问题-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

  8. 蓝桥杯-扑克牌移动-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

  9. 蓝桥杯-放麦子-java

    /* (程序头部注释开始) * 程序的版权和版本声明部分 * Copyright (c) 2016, 广州科技贸易职业学院信息工程系学生 * All rights reserved. * 文件名称: ...

随机推荐

  1. Android官方文档翻译 四 1.2Running Your App

    Running Your App If you followed the previous lesson to create an Android project, it includes a def ...

  2. (转)Make 命令

    Make 命令 代码变成可执行文件,叫做编译(compile):先编译这个,还是先编译那个(即编译的安排),叫做构建(build). Make是最常用的构建工具,诞生于1977年,主要用于C语言的项目 ...

  3. 前端——JSON学习总结

    学习网址: https://www.bilibili.com/video/BV1Pt411u7R3 什么是JSON?(以下有关概念内容为视频中学习文档相关内容,代码为本人学习时使用的有关代码) JSO ...

  4. 根据SVG Arc求出其开始角、摆动角和椭圆圆心

    SVG Arc 目前Svg的Arc的参数字符串如下: a rx ry x-axis-rotation large-arc-flag sweep-flag x y 除了a表示标识为Arc之外,其余参数说 ...

  5. ES_AutoCheck.sh

    #!/bin/bash #@es_check #@date 2019/11/26 #@auth tigergao status=`curl -s GET "http://172.16.71. ...

  6. 学习Java第13天

    今天选择数据库选了半天,Oracle,MySQL,SQL sever太难了,安装了又被图形界面,Linux虚拟机所困扰 明天尽量完成数据库安装 只能说是找视频资料和安装教程了.

  7. Shiro 简单介绍和快速入门。

    一.shiro是啥? /* * Shiro ? 安全框架是一个 1.功能强大且易于使用的Java安全框架,可执行身份验证,授权,加密和会话管理,并可用于保护任何应用程序 - 从命令行应用程序,移动应用 ...

  8. java下载网络大文件之内存不够的解决办法（包含分片上传分片下载）

    一.背景 2020年11月份的时候,我做过一个项目,涉及到网络文件,比如第三方接口提供一个文件的下载地址,使用java去下载,当时我全部加在到JVM内存里面,话说,单单是80M的下载单线程没问题,但是 ...

  9. SP419/422 TRANSP（2） - Transposing is Fun

    首先可以发现转置本质上就是一个置换,问题就转化为求一个排列排成有序的最少次数. 这是一个经典问题,答案为点数减循环置换的个数,考虑如何求循环置换. 发现有两个特殊性质:置换为转置,矩阵的边长为 \(2 ...

  10. java - HashMap原理及实现 (转)

    众所周知,HashMap是一个用于存储Key-Value键值对的集合,每一个键值对也叫做Entry.这些个键值对(Entry)分散存储在一个数组当中,这个数组就是HashMap的主干. HashMap ...