2. 蓝桥杯—基础练习Java-B组

最新推荐文章于 2024-01-20 12:08:32 发布
最新推荐文章于 2024-01-20 12:08:32 发布
阅读量378 收藏 7
点赞数
分类专栏： # 蓝桥杯-Java 文章标签： 蓝桥杯Java基础练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45267102/article/details/108980403
版权

文章目录

蓝桥杯-基础练习Java-B组

1. 闰年判断

试题名称: 闰年判断

给定一个年份，判断这一年是不是闰年。当以下情况之一满足时，这一年是闰年：

  1. 年份是4的倍数而不是100的倍数；

  2. 年份是400的倍数。

  3. 其他的年份都不是闰年。

import java.util.Scanner;
/**
 * @Date 2020/10/8 10:23
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 获取年数
        int y = scanner.nextInt();

        // 如果是4的倍数并且不是100的倍数
        if (y%4 == 0 && y%100 != 0){
            System.out.println("yes");
        }else if (y%400 == 0){
            System.out.println("yes");
        }else {
            System.out.println("no");
        }
        
        scanner.close();
    }
}
得分100
CPU使用93ms
内存使用22.10MB

2. 01字串

试题名称： 01字串

对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

  • 00000
  • 00001
  • 00010
  • 00011
  • 00100

请按从小到大的顺序输出这32种01串。

/**
 * @Date 2020/10/8 10:32
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
		// 使用StringBuilder（线程不安全的）来拼接01字串
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < 32; i++) {
            // 转换成二进制字符串
            String temp = Integer.toBinaryString(i);
            // 获取转换后二进制字符串的长度
            int length = temp.length();

            // 如果转换后的二进制长度不足五，利用StringBuilder进行补零
            if (length < 5){
                for (int j = 0; j < 5 - length; j++) {
                    sb.append("0");
                }
                sb.append(temp);
            }
            // 如果使用到StringBuilder,就打印StringBuilder
            if (sb.length() != 0){
                System.out.println(sb.toString());
                sb = new StringBuilder();
            }else {
                System.out.println(temp);
            }  
        }
        
    }
}
得分100
CPU使用62ms
内存使用20.38MB

3. 字母图形

试题名称： 字母图形

利用字母可以组成一些美丽的图形，下面给出了一个例子：

  • ABCDEFG
  • BABCDEF
  • CBABCDE
  • DCBABCD
  • EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

import java.util.Scanner;

/**
 * @Date 2020/10/8 10:47
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 行数n
        int n = scanner.nextInt();
        // 列数m
        int m = scanner.nextInt();

        // 使用char[][] 接收数据
        // char[][] chars = new char[n][m];
        char temp;

        // 打印图案
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // chars[i][j] = (char) (65+ Math.abs(i-j));
                // System.out.print(chars[i][j]);
                // 大写A--65  小写a--97
                temp = (char) (65+ Math.abs(i-j));
                System.out.print(temp);
            }
            System.out.println();
        }

        // System.out.println("n = " + chars.length);
        // System.out.println("m = " + chars[0].length);
    }
}
得分100
CPU使用93ms
内存使用22.21MB

4. 数列特征

试题名称： 数列特征

给出n个数，找出这n个数的最大值，最小值，和。

import java.util.Scanner;
/**
 * @Date 2020/10/8 16:29
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
			
        int[] arr = new int[n];
		
        // 使用数组储存这n个数
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }


        // 定义最大值和最小值
        int max = arr[0];
        int min = arr[0];
        int sum = 0;

        // 找到最大值，最小值，并求和
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }

            if (min > arr[i]){
                min = arr[i];
            }
            sum = sum + arr[i];
        }

        // 输出结果
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
    }
}
得分100
CPU使用171ms
内存使用33.94MB

5. 查找整数

试题名称： 查找整数

给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

import java.util.Scanner;

/**
 * @Date 2020/10/8 17:31
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        // 个数n
        int n = scanner.nextInt();
        
        int[] arr = new int[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }
        
		// 读取要查找的数
        int a = scanner.nextInt();
		
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == a){
                // 输出是第几次出现的
                System.out.println(i+1);
                return;
            }
        }

        System.out.println(-1);
    }
}
得分100
CPU使用93ms
内存使用23.04MB

6. 杨辉三角形

试题名称： 杨辉三角形

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行：

1
1 1
1 2 1
1 3 3 1

给出n，输出它的前n行。

import java.util.Scanner;

/**
 * @Date 2020/10/8 18:57
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 杨辉三角形的行数
        int n = scanner.nextInt();
        int[][] arr = new int[n][n];
        // 最左上角的值为1
        arr[0][0] = 1;

        for (int i = 1; i < n; i++) {
            // 每进入一次循环，对杨辉三角形的一行的两条边置为 1
            arr[i][0] = 1;
            arr[i][i] = 1;

            // 当 i > 1 的时候才进入该循环
            for (int j = 1; j < i; j++) {
                arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
            }
        }

        // 输出杨辉三角形
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

    }
}
得分100
CPU使用93ms
内存使用23.13MB

7. 特殊的数字

试题名称： 特殊的数字

153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。

编程求所有满足这种条件的三位十进制数。

/**
 * @Date 2020/10/9 8:34
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        int bai = 0;
		int shi = 0;
		int ge = 0;
		// 获取三位数的百位，十位和个位
        for (int i = 100; i < 1000; i++) {
            bai = (i/100);
            shi = (i%100)/10;
            ge = (i%10);
            
            /**
             * static double pow(double a, double b)
             * 将第一个参数的值返回到第二个参数的幂。
             * 
             * int temp = (int) (Math.pow(bai,3)+Math.pow(shi,3)+ Math.pow(ge,3));
             */
            if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge){
                System.out.println(i);
            }
            
        }
    }
}
得分100
CPU使用46ms
内存使用20.39MB

8. 回文数

试题名称： 回文数

1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。

8.1 方法一

/**
 * @Date 2020/10/9 8:58
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        int q = 0;
        int b = 0;
        int s = 0;
        int g = 0;
        for (int i = 1000; i < 10000; i++) {
            q = (i/1000);
            b = (i%1000)/100;
            s = (i%100)/10;
            g = (i%10);
            if(q == g && b == s){
                System.out.println(i);
            }
        }
    }
}
得分100
CPU使用15ms
内存使用20.48MB
8.2 方法二
public class Main{
	public static void main(String[] args){
		for (int i = 1; i <= 9; i++) {
			for (int j = 0; j <= 9; j++) {
				System.out.println(i*1000 + j*100 + j*10 + i);
			}
		}
	}
	
}
得分100
CPU使用46ms
内存使用20.34MB

9. 特殊回文数

试题名称： 特殊回文数

123321是一个非常特殊的数，它从左边读和从右边读是一样的。

输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

import java.util.Scanner;

/**
 * @Date 2020/10/9 9:12
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 10000; i < 1000000; i++) {
            // 如果是五位数
            if (i < 100000) {
                int a, b, c, d, e;
                a = i / 10000;
                b = i / 1000 % 10;
                c = i / 100 % 10;
                d = i / 10 % 10;
                e = i % 10;
                if (a == e && b == d && a + b + c + d + e == n) {
                    System.out.println(i);
                }
                // 如果是六位数
            } else {
                int a, b, c, d, e, f;
                a = i / 100000;
                b = i / 10000 % 10;
                c = i / 1000 % 10;
                d = i / 100 % 10;
                e = i / 10 % 10;
                f = i % 10;
                if (a == f && b == e && c == d && a + b + c + d + e + f == n) {
                    System.out.println(i);
                }
            }
        }
    }
}
得分100
CPU使用109ms
内存使用22.31MB

10. 十进制转十六进制

试题名称： 十进制转十六进制

  1. 十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。
  2. 十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
  3. 给出一个非负整数，将它表示成十六进制的形式。
import java.util.Scanner;

/**
 * @Date 2020/10/9 9:32
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        
        // 十进制转十六进制
        String result = Integer.toHexString(n);
        
         /**
         * String toUpperCase()
         * 将所有在此字符 String使用默认语言环境的规则大写。
         *
         * String toLowerCase()
         * 将所有在此字符 String使用默认语言环境的规则，以小写。
         */
        System.out.println(result.toUpperCase());

		  // 十六进制转十进制
          // int startN = Integer.parseInt(result,16);
		  // System.out.println(startN);

    }
}
得分100
CPU使用78ms
内存使用22.11MB

11. 十六进制转十进制☆

试题名称： 十六进制转十进制

从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。

十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

11.1 方法一☆
import java.util.Scanner;

/**
 * @Date 2020/10/9 9:44
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.next();

		char[] c = line.toCharArray();
        int n = c.length;
        int m = 0;
        long sum = 0;
        for (int i = 0; i < n; i++) {
            if (c[i] == 'A'){
                m = 10;
            }else if (c[i] == 'B'){
                m = 11;
            }else if (c[i] == 'C'){
                m = 12;
            }else if (c[i] == 'D'){
                m = 13;
            }else if (c[i] == 'E'){
                m = 14;
            }else if (c[i] == 'F'){
                m = 15;
            }else{
                //若不是字母，则将字符转成整数形式给m
                m = Integer.parseInt(c[i] + "");
            }
            //取16的(n-i-1)次幂乘以 m
            // fff n == 3   从左到右依次是 2  1  0
            sum += m * (Math.pow(16, n - i - 1));
        }
        System.out.println(sum);
 
    }
}
得分100
CPU使用109ms
内存使用22.01MB
11.2 方法二
import java.util.Scanner;

/**
 * @Date 2020/10/9 9:44
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.next();
        
        int num = Integer.parseInt(line, 16);
        System.out.println(num);
    }
}
得分75
CPU使用78ms
内存使用22.07MB

12. 十六进制转八进制☆

试题名称： 十六进制转八进制

给定n个十六进制正整数，输出它们对应的八进制数。

提示：先将十六进制数转换成某进制数，再由某进制数转换成八进制。

import java.util.Scanner;

/**
 * @Date 2020/10/9 10:18
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {


        /**
         * static String toBinaryString(int i)
         * 在基数2中返回整数参数的字符串表示形式为无符号整数。
         *
         * static String toHexString(int i)
         * 返回整数参数的字符串表示形式，作为16位中的无符号整数。
         *
         * static String toOctalString(int i)
         * 在基数8中返回整数参数的字符串表示形式为无符号整数。
         */
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        // 储存十六进制数
        String[] strs = new String[n];
        // 读取十六进制数为String
        for (int i = 0; i < n; i++) {
            strs[i] = scanner.next();
        }

        for (String str : strs) {
            // 将字符串转成二进制字符串
            String strBinary = toBinary(str);
					
            int len_strBin = strBinary.length();
            if(len_strBin%3==1) strBinary = "00" + strBinary;
            if(len_strBin%3==2) strBinary = "0" + strBinary;
            // String binay = Long.toBinaryString(a);

            // 将 二进制 binay  转化为 八进制的字符串
            String result = toOctal(strBinary);
            System.out.println(result);
        }
        scanner.close();
    }

    /**
     * 二进制转八进制
     *
     * @param strBinary 二进制字符串
     * @return 八进制字符串
     */
    private static String toOctal(String strBinary) {
        int len = strBinary.length();
        int k;
        StringBuffer stb = new StringBuffer();
        if ("000".equals(strBinary.substring(0, 3))) {
            k = 3;
        } else {
            k = 0;
        }
        for (int i = k; i < len - 2; i += 3) {
            String string = strBinary.substring(i, i + 3);
            if (string.equals("000")) {
                stb.append("0");
            } else if (string.equals("001")) {
                stb.append("1");
            } else if (string.equals("010")) {
                stb.append("2");
            } else if (string.equals("011")) {
                stb.append("3");
            } else if (string.equals("100")) {
                stb.append("4");
            } else if (string.equals("101")) {
                stb.append("5");
            } else if (string.equals("110")) {
                stb.append("6");
            } else if (string.equals("111")) {
                stb.append("7");
            }
        }
        return stb.toString();
    }

    /**
     * 十六进制转二进制
     *
     * @param strHex 十六进制字符串
     * @return 二进制字符串
     */
    private static String toBinary(String strHex) {
        int len_str = strHex.length();
        StringBuffer stb = new StringBuffer();
        for (int i = 0; i < len_str; i++) {
            switch (strHex.charAt(i)) {
                case '0':
                    stb.append("0000");
                    break;
                case '1':
                    stb.append("0001");
                    break;
                case '2':
                    stb.append("0010");
                    break;
                case '3':
                    stb.append("0011");
                    break;
                case '4':
                    stb.append("0100");
                    break;
                case '5':
                    stb.append("0101");
                    break;
                case '6':
                    stb.append("0110");
                    break;
                case '7':
                    stb.append("0111");
                    break;
                case '8':
                    stb.append("1000");
                    break;
                case '9':
                    stb.append("1001");
                    break;
                case 'A':
                    stb.append("1010");
                    break;
                case 'B':
                    stb.append("1011");
                    break;
                case 'C':
                    stb.append("1100");
                    break;
                case 'D':
                    stb.append("1101");
                    break;
                case 'E':
                    stb.append("1110");
                    break;
                case 'F':
                    stb.append("1111");
                    break;
                default:
                    break;
            }
        }

        return stb.toString();
    }
}
得分100
CPU使用171ms
内存使用49.51MB

13. 数列排序

试题名称： 数列排序

给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

import java.util.Scanner;

/**
 * @Date 2020/10/9 11:18
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] array = new int[n];

        for (int i = 0; i < n; i++) {
            array[i] = scanner.nextInt();
        }

        int temp = 0;
        
        // 冒泡排序
        for (int j = 0; j < array.length; j++) {
            // array.length - 1 - j
            for (int i = 0; i < array.length - 1 - j; i++) {
                if (array[i] > array[i + 1]) {
                    temp = array[i + 1];
                    array[i + 1] = array[i];
                    array[i] = temp;
                }
            }
        }

        // 输出排序后的数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}
得分100
CPU使用93ms
内存使用22.34MB

14. >>>和>>

/**
 * @Date 2020/10/8 16:29
 * @Version 10.21
 * @Author DuanChaojie
 */
public class Main {
    public static void main(String[] args) {
        /**
         * 由于计算机中存储的都是数的补码，正数的原码、反码、补码都是相同的；
         * 而负数的原码、反码、补码是不一样的，补码=原码取反+1（符号位不变）
         * >>>为逻辑移位符，向右移n位，高位补0
         * >> 算数移位符，也是向右移n位，不同的是：正数高位补0，负数高位补1
         * << 移位符，向左移n位，低位补0
         */
        int i = 16;
        System.out.println(i>>1);//8
        System.out.println(i>>2);//4

        System.out.println(i>>>1);//8
        System.out.println(i>>>2);//4

        System.out.println(i<<1 );//32
        System.out.println(i<<2 );//64

    }
}

☆

喵先生呢
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯基础练习BASIC-6-13
随笔记录，有些许菜，莫怪莫怪
01-06 367
蓝桥杯基础练习BASIC-6-13 BASIC-6 杨辉三角形 问题描述 ​ 杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。 ​ 它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。 ​ 下面给出了杨辉三角形的前4行： ​ 1 ​ 1 1 ​ 1 2 1 ​ 1 3 3 1 ​ 给出n，输出它的前n行。 输入格式 输入包含一个数n。//数据规模与约定:1 <= n <= 34 输出格式 输出杨辉三角形的前n行。
2014-蓝桥杯预赛-Java本科-B组真题
05-18
"2014-蓝桥杯预赛-Java本科-B组真题"是针对Java编程语言的一次竞赛，旨在测试参赛者在Java编程、数据结构、算法应用等方面的技能。蓝桥杯比赛通常涵盖多轮，预赛是第一阶段，旨在筛选出在软件开发和问题解决方面有...
蓝桥杯练习java答案-基础练习
weixin_60460398的博客
07-02 1842
目录 基础练习 BASIC-01 A+B问题 BASIC-02 数列求和 BASIC-03 圆的面积 BASIC-04 Fibonacci数列 BASIC-1 闰年判断 BASIC-2 01字符 BASIC-3 字母图形 BASIC-4 数列特征 BASIC-5 查找整数 BASIC-6 杨辉三角形 BASIC-7 特殊的数字 BASIC-8 回文数 BASIC-9 特殊回文数 BASIC-10 十进制转十六进制 BASIC-11 十六进制转十进制 BASIC-12 十
蓝桥杯练习系统java-基础练习-BASIC-01-A+B问题
Diana_Lyt的博客
01-30 64
蓝桥杯练习系统java-基础练习-BASIC-01-A+B问题
蓝桥杯练习------基础练习
qq_51263768的博客
03-13 523
一、基础练习 数列排序 问题描述 　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200 输入格式 　　第一行为一个整数n。 　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 输出格式 　　输出一行，按从小到大的顺序输出排序后的数列。 样例输入 5 8 3 6 4 9 样例输出 3 4 6 8 9 陌生知识点：sort函数，数组用法，sort(a,a+n) #include<bits/stdc++.h> using n...
蓝桥杯练习系统java-基础练习-BASIC8-回文数
Diana_Lyt的博客
02-01 77
蓝桥杯练习系统java-基础练习-BASIC8-回文数
蓝桥杯 基础练习 BASIC-2 01字串 JAVA
谢谢 啊sir的博客
04-04 107
BASIC-2 01字串 问题描述 对于长度为 5 位的一个 01 串，每一位都可能是 0 或 1 ，一共有 32 种可能。它们的前几个是： 00000 00001 00010 00011 00100 请按从小到大的顺序输出这32种01串。 输入格式 本试题没有输入。 输出格式 输出32行，按从小到大的顺序每行一个长度为5的01串。 样例输出 00000 00001 00010 00011 <以下部分省略> 这题也就是相当于二进制的从 1 到 31 //不适用类库 public static
蓝桥杯准备之路-Java基础复习
qq_62609093的博客
01-20 733
java基础复习
蓝桥杯 基础练习 BASIC-01 A+B问题 JAVA
谢谢 啊sir的博客
04-04 178
BASIC-01 A+B问题 问题描述 输入A、B，输出A+B。 输入格式 输入的第一行包括两个整数，由空格分隔，分别表示A、B。 样例输入 12 45 样例输出 57 数据规模与约定 -10000 <= A , B <= 10000。 A+B我相信这是所有编码人入门的第一道题，别杠，杠就你对。 public static void main(String[] args) { Scanner sc = new Scanner(System.in); int a = sc.next
蓝桥杯练习系统java-基础练习-BASIC11-十六进制转十进制
Diana_Lyt的博客
02-01 87
蓝桥杯练习系统java-基础练习-BASIC11-十六进制转十进制
第十届蓝桥杯 省赛 Java B组 试题压缩包
04-05
总结，准备蓝桥杯省赛Java B组的考生应全面掌握Java基础语法，深入理解并能灵活应用集合框架、异常处理、IO流、多线程等核心概念。同时，不断锻炼自己的算法思维，熟练运用设计模式，关注Java的新特性，这样才能在...
省赛国赛蓝桥杯C语言与java（B组）题库答案
06-06
总的来说，这个压缩包是准备蓝桥杯B组竞赛的宝贵资料，包含的C语言和Java题库答案、算法练习以及VIP题目，将对参赛者的学习和训练提供极大的帮助。通过深入研究这些内容，参赛者不仅可以提升编程技术，还能增强逻辑...
第十五届蓝桥杯java b组
04-14
第十五届蓝桥杯Java B组比赛是一项针对具有一定Java编程基础的学生进行的技术竞赛。该比赛旨在通过一系列精心设计的编程挑战，全面评估参赛者在算法理解、实现能力以及Java编程技能等方面的表现。 比赛形式为个人赛...
蓝桥杯Java B组历年真题的源码及解析（2013-2017）
04-30
Java B组是该赛事的一个部分，主要面向非计算机专业或者对Java编程有一定基础的学生。这个压缩包包含了从2013年至2017年这五年间Java B组的历年真题源代码和解析，对于准备参加蓝桥杯的选手以及想要提高Java编程能力...
chromeforxp.zipchromeforxp.zipchromeforxp.zip
08-04
chromeforxp.zipchromeforxp.zipchromeforxp.zip
shapely-2.0.5-cp311-cp311-win32.whl
最新发布
08-04
shapely-2.0.5-cp311-cp311-win32.whl
[毕业设计]vb+access抽奖系统(系统+论文+开题报告+外文翻译+封面+中英摘要+任务书+中期检查表).zip
08-04
[毕业设计]vb+access抽奖系统(系统+论文+开题报告+外文翻译+封面+中英摘要+任务书+中期检查表)
shapely-2.0.5-cp39-cp39-macosx_10_9_x86_64.whl
08-04
shapely-2.0.5-cp39-cp39-macosx_10_9_x86_64.whl
蓝桥杯2014 JAVA本科B组题目详解：武功秘籍、面条切割与字母序列
在2014年的第五届蓝桥杯JAVA本科B组试题中，考察了三个不同的编程和数学问题，涉及算法设计、逻辑推理以及基本的编程技巧。 1. **武功秘籍问题**: 这是一个关于纸张剪裁的问题，目标是小明只想要练习某本书的第81页...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值