蓝桥杯2013-Java B组省赛真题

已于 2023-02-27 17:39:56 修改
阅读量364 收藏 6
点赞数 1
文章标签： java 蓝桥杯 开发语言 Powered by 金山文档
于 2023-02-26 21:25:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dashujuxinxing/article/details/129217695
版权

前言

本文章只包含题目+答案，没有详细的分析过程（仅为了个人的归纳复盘使用）

题目以及讲解是看B站的视频：2013年-Java-B-题1_哔哩哔哩_bilibili

2013-Java省赛第一题——世纪末的星期

import java.util.Calendar;

//世纪末的星期
//熟悉日期api，在1970年之后都可以用
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calendar calendar = Calendar.getInstance();
        for(int year=1999;year<10000;year+=100)
        {
            calendar.set(Calendar.YEAR, year);
            calendar.set(Calendar.MONTH, 11);//默认是从0开始，所以11就是12个月
            calendar.set(Calendar.DAY_OF_MONTH, 31);//从1开始,设置12月
            if(calendar.get(Calendar.DAY_OF_WEEK)==1)//是星期日
            {
                System.out.println(year);
                break;
            }
        }
    }

}

答案：2299

关于这题的tips：

1.熟悉日期api：Java基础--常用API--日期相关API - 累成一条狗 - 博客园 (cnblogs.com)

2.set方法：两个参数（设置的项、设置的值）

3.注意日期的开始值（比如：Calendar.MONTH是从0开始的，所以设置11就是12月，日历从1开始的，星期日是1）

2013-Java省赛第二题——马虎的算式

//马虎的算式_枚举
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int count = 0;
        for(int a=1;a<10;a++)
        {
            for(int b=1;b<10;b++)
            {
                if(a!=b)
                {
                    for(int c=1;c<10;c++)
                    {
                        if(c!=a&&c!=b)
                        {
                            for(int d=1;d<10;d++)
                            {
                                if(d!=a&&d!=b&&d!=c)
                                {
                                    for(int e=1;e<10;e++)
                                    {
                                        if(e!=a&&e!=b&&e!=c&&e!=d)
                                        {
                                            if((a*10+b)*(c*100+d*10+e)==(a*100+d*10+b)*(c*10+e))
                                            {
                                                count++;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        System.out.println(count);
    }

}

答案：142

关于这题的tips：

该题是枚举，认真写好每一个for循环和if条件就不会出错，注意检查。

2013-Java省赛第三题——振兴中华

//振兴中华_递归_深搜
//二叉树-只能往下或往右-动态规划
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //做递归三要素:重复、变化、边界
        int count = f(0,0);
        System.out.println(count);
    }
    
    private static int f(int i,int j) {//i:行；j:列
        if(i==3 || j==4) return 1;//如果到了边界，就使其加1，不继续往下递归
        return f(i+1,j) + f(i,j+1);//将两种走法的路线数相加
        //向右、向下
    }

}

答案：35

关于这题的tips：

这题考的是递归-深度搜索、动态规划，蓝桥杯中此类的题目不少，需要分析出整个算法的逻辑，分为几步进行，然后写在方法中。

2013-Java省赛第四题——黄金连分数

import java.math.BigDecimal;
import java.math.BigInteger;

//黄金连分数(斐波拉契用迭代)
//1.化为求斐波拉契数列相邻两项的比值，到多少值？越多越精确，n/n+1项，n再往上增加，这个壁纸的小数点后101位是稳定的，也就是不变的
//2.double无法表示一百位的小数，BigInteger和BigDecimal(大数api)
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BigInteger a = BigInteger.ONE;
        BigInteger b = BigInteger.ONE;
        for(int i=3;i<1000;i++)
        {
            BigInteger t = b;
            b = a.add(b);
            a = t;
        }
        BigDecimal divide = new BigDecimal(a,110).divide(new BigDecimal(b,110),BigDecimal.ROUND_HALF_DOWN);
        System.out.println(divide.toPlainString().substring(0,103));//101位，截取0.
        //提交的时候要进行101位的四舍五入
    }

}

答案：

0.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375

斐波那契数列迭代（配合大数api）
        BigInteger a = BigInteger.ONE;
        BigInteger b = BigInteger.ONE;
        for(int i=3;i<1000;i++)
        {
            BigInteger t = b;
            b = a.add(b);
            a = t;
        }

关于这题的tips：

  1. 要先分析，发现每一层得出的结果，可以发现每一层的结果就是斐波拉契数列前一项与后一项的比值（斐波拉契数列：1,1,2,3,5,8......每一项等于前两项的和）

  1. 循环要到多少次？需要多次尝试才能得到一个稳定的值

  1. 因为double的精度无法算到小数点后一百位，所以使用BigInteger和BigDecimal(大数api)（divice是分数的函数）

  1. 最后需要将结果转化成字符串，用substring（）方法截取小数点后101位数（注意！因为第100位需要进行四舍五入，所以要多截一位），而0.也占了两位数，所以是substring(0,103)

  1. 答案记得四舍五入

2013-Java省赛第五题——有理数类（程序阅读题）

需要填的是加法方法中的return值

package cn.edu.fjjxu;
//有理数类
public class Main05 {
    
    public static void main(String[] args) {
        Rational a = new Rational(1, 3);
        Rational b = new Rational(1, 6);
        Rational c = a.add(b);
        System.out.println(a+"+"+b+"="+c);
    }
    static class Rational{
        private long ra;
        private long rb;
        
        //求最大公约数
        private long gcb(long a,long b)
        {
            if(b==0) return a;
            return gcb(b, a%b);
        }
        
        //分子和分母约分
        public Rational(long a,long b)
        {
            ra = a;//分子
            rb = b;//分母
            long k = gcb(ra, rb);
            if(k>1)//需要约分
            {
                ra /= k;
                rb /= k;
            }
        }
        
        //加法:问题
        public Rational add(Rational x)
        {
            return new Rational(ra*x.rb+x.ra*rb,rb*x.rb);//问题
        }
        
        //乘法
        public Rational mul(Rational x)
        {
            return new Rational(ra*x.ra, rb*x.rb);
        }
        
        public String toString()
        {//ra作为分子，rb作为分母
            if(rb==1) return "" + ra;
            return ra + "/" + rb;
        }
    }
}

答案：new Rational(ra*x.rb+x.ra*rb,rb*x.rb)

关于这题的tips：

  1. 观察题目所给的信息可以发现每一个方法都对应了数学中的不同方法（最大公约数、约分等等）

  1. 既然要求的是加法，可以参考乘法的return值，找到分数加法运算的规律

2013-Java省赛第六题——三部排序（程序阅读题）

//三部排序_快排的变形
public class Main {
    public static void main(String[] args) {
        int[]arr = {25,18,-2,0,16,-5,33,21,0,19,-16,25,-3,0};
        sort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    static void sort(int[] x){
        int p = 0;//移动的指针
        int left = 0;//下标
        int right = x.length - 1;//最大下标
        
        while (p<=right) {
            if(x[p]<0){
                //元素小于0，将元素和left位置交换
                int t = x[left];
                x[left] = x[p];
                x[p] = t;
                left++;
                p++;
            }else if(x[p]>0){
                //元素大于0，将元素和right位置交换
                int t = x[right];
                x[right] = x[p];
                x[p] = t;
                right--;
            }else{
                //元素等于0
                p++;//代码填空位置
            }
        }
    }
}

答案：p++

关于本题的tips：

  1. （极限思维）快速求解，考虑一种极限的情况，数组全部都是0，那么就不发生交换，只要移动哨兵（也就是p指针）

  1. 本题是快速排序的变形，其实比快排更加简单，只需要归类，将正数、负数和零归成三类分别分析三个指针各自的动向即可

2013-Java省赛第七题——错误票据

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

//错误票据_枚举
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<Integer>();
        int N = sc.nextInt();
        sc.nextLine();//吃掉整数后面的换行符
        for(int i=0;i<N;i++){
            
            String line = sc.nextLine();
            String[] split = line.split(" ");
            for(int j=0;j<split.length;j++){
                list.add(Integer.parseInt(split[j]));//解析成整数
            }
        }
//        System.out.println(list.size());ID的个数
        //对数组进行排序用array(Arrays.sort)对集合进行排序用collections
        Collections.sort(list);
        int a = 0;//a:断号
        int b = 0;//b:重号
        for(int i=1;i<list.size();i++){//边界从1开始！！
            if(list.get(i)-list.get(i-1)==2){
                a = list.get(i)-1;
            }
            //此处有坑！==:是比较对象，equals才是比较内容！！
            if(list.get(i).equals(list.get(i-1))){
                b = list.get(i);
            }
        }
        System.out.println(a+" "+b);
    }

}

关于本题的tips：

  1. 这题的第一个坑是关于输入方面的，输入N行，但是每行的列数不确定，需要多写一句sc.nextLine();（吃掉整数后面的换行符），并将ID号存进字符串集合中，用空格分隔开

  1. 排序方面：对数组进行排序用array(Arrays.sort)对集合进行排序用collections

  1. 这题的第二个坑：==:是比较对象，equals才是比较内容！所以条件应该写成list.get(i).equals(list.get(i-1))而不是list.get(i)==list.get(i-1)，如果非要这样写，就改成list.get(i)-list.get(i-1)==0也是对的

2013-Java省赛第八题——幸运数

import java.util.Scanner;

//幸运数
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        int []a = new int[n];//存储数据的数组，范围给大一点才能找到保证重复的数值在后面
        for(int i=0;i<n;i++){
            a[i] = 2*i + 1;//奇数列
        }
        //已经把2的倍数（位置）给删除了
        
        int l = 1;//幸运数的下标,a[l]是幸运数
        while(true){
            int p = l+1;//数字向前挪动的坑位
            for(int i=l+1;i<n;i++){
                if((i+1)%a[l]==0){}
                else{
                    a[p] = a[i];//切换幸运数
                    p++;
                }
            }
    //      测试第一轮的输出
//            for(int i=0;i<n;i++){
//                System.out.print(a[i]+" ");
//            }
//            System.out.println();
            l++;
            if(a[l]>=n) break;
        }
        int count = 0;
        for(int i=0;i<n;i++){
            if(a[i]>=n) break;
            if(a[i]>m) count++;
        }
        System.out.println(count);
    }

}

关于本题的tips：

  1. 这题是需要去分析其中的逻辑关系的，首先是第一次删去数得到的序列其实就是奇数列，所以说初始序列可以直接生成奇数列

  1. 在解题的过程中可以先试一轮的值来验算得到的数列是否正确

  1. 这里可以将删去项变成是往前挪，这样的话不用一直重新定义下标

  1. 坑点：两个if语句的顺序不要写反了，不然题例中的21就要被count计进去了

  1. 这题需要认真分析！（主要是要搞懂指针的挪动规律）

2013-Java省赛第九题——带分数

import java.util.Scanner;

//带分数_枚举_全排列(递归)
public class Main { 
    static int result;
    static int N;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        N = sc.nextInt();
        int[] arr = {1,2,3,4,5,6,7,8,9};
        f(arr,0);
        System.out.println(result);
    }
    //确认某一个排列的第k位
    public static void f(int[] arr,int k){
        if(k==9){//全部确认
            check(arr);
            return;
        }else{
            //选定第k位
            for(int i=k;i<9;i++){
                //将第i位和第k位交换
                int t = arr[i];
                arr[i] = arr[k];
                arr[k] = t;
                
                //移交下一位去确认k+1位
                f(arr,k+1);
                
                //回溯（换回来）——深搜(退回来的时候，应该将之前的状态都清空，所以应该换回来)
                t = arr[i];
                arr[i] = arr[k];
                arr[k] = t;
            }
        }
    }
    
    //还要放加号和除法(枚举加号和除号的位置)
    public static void check(int[] arr) {
        //加号前的字符数最多是7
        for (int i = 1; i <= 7; i++) {
            int num1 = toInt(arr,0,i);//加号前面的一段整数
            if(num1>=N){//如果其实+前面的数额已经超过了N，那么就没必要计算了
                continue;
            }
            //除号前面的字符数
            for (int j = 1; j <= (8-i); j++) {
                int num2 = toInt(arr, i, j);
                int num3 = toInt(arr, i+j, 9-i-j);
                if((num2%num3==0)&&(num1+num2/num3==N)){
                    result++;
                }
            }
        }
    }
    //将数组变成整数
    private static int toInt(int[] arr, int pos, int len) {
        int t = 1;
        int count = 0;
        for (int i = pos+len-1; i >= pos; i--) {
            count += arr[i]*t;
            t*=10;
        }
        return count;
    }

}

用递归来写全排列是必然要掌握的！

全排列的写法
    static int[] arr = {1,2,3,4,5,6,7,8,9};
    static int count;
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        f(arr,0);
    }
    //确认某一个排列的第k位
    private static void f(int[] arr,int k){
        if(k==9){//全部确认
            if(check(arr)){
                count++;
            }
            print(arr);
        }
        //选定第k位
        for(int i=k;i<arr.length;i++){
            //将第i位和第k位交换
            int t = arr[i];
            arr[i] = arr[k];
            arr[k] = t;
            
            //移交下一位去确认k+1位
            f(arr,k+1);
            
            //回溯（换回来）——深搜(退回来的时候，应该将之前的状态都清空，所以应该换回来)
            t = arr[i];
            arr[i] = arr[k];
            arr[k] = t;
        }
        
    }
    private static void print(int[] arr2) {
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
        System.out.println();
    }
将数组变成整数的模板
   //将数组变成整数
    private static int toInt(int[] arr, int pos, int len) {
        int t = 1;
        int count = 0;
        for (int i = pos+len-1; i >= pos; i--) {
            count += arr[i]*t;
            t*=10;
        }
        return count;
    }

关于这题的tips：

  1. 首先需要掌握的肯定是全排列的写法，先写出9个数字的全排列

  1. 然后就是考虑两个运算符号的位置

  1. 最后将数组转化成整数，条件符合的情况利用计数变量count++

  1. 这个题很难去验算了，就是保证题例都能通过，而且逻辑和性能方面的问题

2013-Java省赛第十题——连号区间数

import java.util.Scanner;
//连号区间数
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n+1];
        for (int i = 1; i <= n; i++) {
            arr[i] = sc.nextInt();
        }
        int count = 0;
        for (int i = 1; i <= n; i++) {
            int max = arr[i];
            int min = arr[i];
            for (int j = i; j <= n; j++) {//]右边界的位置
                if(arr[j]>max) max = arr[j];
                if(arr[j]<min) min = arr[j];
                if(i==j) {
//                    System.out.printf("[%d,%d]\n",i,j);
                    count++;
                }else{//i<j怎么判断[i,j]是连号区间呢？
                    if(max-min==j-i) {
//                        System.out.printf("[%d,%d]\n",i,j);
                        count++;
                    }
                }
            }
        }
        System.out.println(count);
    }

}

关于本题的tips：

分析连号的规律，设置最大值和最小值就能写出来

总结

程序填空题（填结果）

01世纪末的星期：枚举每个世纪末，判断是否星期天 （Calendar api）

02马虎的算式：枚举每个位上的数字，组合判断

03振兴中华：找重复中的变化，找边界

04黄金连分数：1. 识别问题等价于斐波那契的n项和n+1项的比值；2. n要多少才够；3.怎么处理很大的数和精度要求很高的浮点数

程序填空题（填代码）

05有理数类：面向对象+分数加法(通分与约分)

06三部排序：快速排序(三指针区间法)变形;极限思维(考虑全部是0)

编程题

07错误票据：输入比较特殊，排序，迭代(获取断号和重号)，输出

08幸运数：模拟筛选过程，枚举计数

09带分数：1-9用递归做全排列，对每一个排列，都枚举+和/的位置，然后进行检查

10连号区间数：枚举所有区间，检查这个区间里面的数排序后是否连号

2013年的题目大部分都是考枚举、递归方面的算法

小王要努力24108
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
第十届蓝桥杯Java大学本科B组省赛试题
03-25
【标题】：“第十届蓝桥杯Java大学本科B组省赛试题” 【描述】：“第十届蓝桥杯Java大学本科B组省赛试题”是一场针对大学生Java编程能力的竞赛，旨在检验参赛者的编程基础、算法理解以及问题解决能力。蓝桥杯比赛...
2023年第十四届蓝桥杯JavaB组省赛真题及解析
Narnat的博客
05-14 2万+
本次比赛我只能说真是技不如人，本以为精通暴力算法就能狠狠拿下蓝桥杯的我，真的是被狠狠军训了😭。虽然最后也是拿了二等安慰奖，但是内心根本没有多开心，因为自己这几个月学的算法，几乎没有在本次比赛发挥作用，而且一直处于被题目吊打的局面。但这不能说明刷题没用，只能说我的水平还有待提高。重心态，重思维。想想也是如果单纯以算法衡量能否在蓝桥杯取得好成绩是不妥当的。毕竟大一，大二乃至大三都可以参加，单纯以刷题就能取得好成绩的话，对大一刚接触编程的新生来说太不利了，所以侧重思维就相对来说更公平。
2022年第十三届蓝桥杯比赛Java B组 【全部真题答案解析-第一部分】
热门推荐
kndjg的博客
11-10 3万+
最近回顾了Java B组的试题，深有感触：脑子长时间不用会锈住，很可怕。 兄弟们，都给我从被窝里爬起来，赶紧开始卷！！！
2024年十五届蓝桥杯省赛大学B组真题（Java残缺版）
最新发布
2302_76207485的博客
04-30 4737
2024年十五届蓝桥杯省赛大学B组真题（Java完整版）题解
蓝桥杯2023年第十四届省赛真题-买瓜--Java题解
weixin_73936404的博客
09-17 2476
这道题是一个很简单的递归可能性的罗列，但是每次递归有三个情况，则时间复杂度为O(3^N)，时间复杂度过高，所以需要在递归过程中除掉那些完全不可能的解，使复杂度降低。输入的第一行包含两个整数 n, m，用一个空格分隔，分别表示瓜的个数和小蓝想买到的瓜的总重量。对于所有评测用例，1 ≤n≤30，1≤ Ai ≤ 109 ，1 ≤ m ≤ 10^9。第二行包含 n 个整数 Ai，相邻整数之间使用一个空格分隔，分别表示每个瓜的重量。小蓝刀功了得，他可以把任何瓜劈成完全等重的两份，不过每个瓜只能劈一刀。
蓝桥杯 2018年省赛真题 (Java 大学C组)
NOW I GOT ONE WAY
10-11 6723
@ 蓝桥杯 2018 年省赛真题 (Java 大学 C 组 ) 先挂上 #1 哪天返回 问题描述 小明被不明势力劫持。后被扔到x星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。 他决定在x星战打工。好心的老板答应包食宿，第1天给他1元钱。 并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。 请计算一下，小明在第几天就能凑够108元，返回地球。 答案提交 要求提交的是一个整数，表示第几天。请不要提交任何多余的内容。 NULL calcCode： 在这里插
第十四届蓝桥杯省赛真题解析 Java （B组），代码经过测试平台验证，均正确
weixin_73936404的博客
06-16 7713
第十四届蓝桥杯省赛 Java （B组）Java实现，思路详解和算法实现
第十四届蓝桥杯 Java C组省赛真题
04-08
本资源为第十四届蓝桥杯 Java C 组省赛真题，涵盖了 Java 编程基础知识点，包括结果填空和程序设计两种题型。本总结将对题目中的知识点进行详细说明。 一、结果填空题 结果填空题要求选手根据题目描述直接填写结果...
蓝桥杯第七届JavaC组省赛和决赛真题.zip
04-13
蓝桥杯第七届JavaC组省赛和决赛真题.zip；这份蓝桥杯第七届JavaC组省赛和决赛真题的压缩文件是一份珍贵的学习资源。通过仔细研究这些历年真题，你将能够更全面地了解比赛考题的类型和难度，为自己的备赛工作提供有力...
2022蓝桥杯Web大学组省赛真题
07-03
2022蓝桥杯Web组省赛真题是一份面向Web开发者的竞赛试题，旨在评估参赛者在Web开发领域的技能和能力。这份资源提供了省赛的真实题目，可供学习和练习使用。 该资源包含了一系列的编程问题，涵盖了Web开发的各个方面...
蓝桥杯第九届JavaC组省赛和决赛真题.zip
04-12
本压缩包"蓝桥杯第九届JavaC组省赛和决赛真题.zip"是针对第九届比赛的Java C组别，包含了省赛和决赛的试题，是参赛者进行赛前训练的重要资源。以下是这两个阶段的真题中可能涵盖的知识点： 1. **Java基础**：包括但...
2013年蓝桥杯JavaB组真题
03-16
2013年蓝桥杯JavaB组真题
【蓝桥真题】——2023年蓝桥Java组省赛真题+解析+代码（通俗易懂版）
weixin_43741934的博客
11-13 3039
关于这次蓝桥杯，比赛的时候没有看D题，G和H花了好长时间，呜呜…，等比赛结束的时候边走边看题才知道是送分题，考后相当于是补题了，好遗憾，痛失10分，也许人生就是这样，十之八九是遗憾，但这又有何妨呢，前方康庄大道，还有很多美好的事情等着我呢！！！下面就把这次我看过的并且感觉能做的题目写一下吧，如有错误，欢迎评论区指正！！
蓝桥杯java历年真题及答案整理(共100道题目及答案)
G_GUi的博客
07-30 1万+
1.字符排序 2.串的简单处理 3.猜算式 4.Excel地址转换 5.手机尾号评分 6.括号问题 7.扑克牌排列 8.第一个数字（数字的值返回） 9.放麦子 10.求21位数的水仙花数 11.猜生日 12.填算式 13.纵横放火柴游戏 14.古代赌局 15.源码变换 16.数量周期 17.提取子串 18.取球博弈 19.密码发生器 20.方阵顺时针旋转 21.古堡算式 22.微生物增殖 23.信用卡号校验 24.输入日期 25.顺时针螺旋填入 26.Playfair密码 27.漏掉的账目明细 28.制作表
2023第十四届蓝桥杯Java大学生B组真题？（真题+附链接）
m0_74939018的博客
04-19 2143
【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。【问题描述】 令 S = 1!，求 S 的末尾 9 位数字。2023年第十四届蓝桥杯软件类省赛的真题全部都在这，赶紧去，给自己打个分，能不能拿省一，就看你的了。试题 A: 阶乘求和。
第十四届蓝桥杯大赛软件赛省赛（Java 大学A组）
NOW I GOT ONE WAY
05-08 6193
第十四届蓝桥杯大赛软件赛省赛 Java 大学 A 组
蓝桥杯个人赛软件类历届真题及其解析
NOW I GOT ONE WAY
12-22 1万+
蓝桥杯个人赛软件类历届真题及其解析
【22年蓝桥杯】十三届蓝桥杯真题JavaB组解析+代码（带你复习知识点）（一）
Jing_Hua
03-25 3221
直接取余的话可以使用java自带的Math.pow(数，次方),或者使用BigInteger（BigInteger和int的区别就是前者范围没有限制，所以可以直接使用）。实现代码：方法一：使用BigInteger解方法二：直接使用Math.pow()
2023第十四届蓝桥杯Java B组（A-F）真题，暴力骗分
weixin_64890546的博客
04-11 2263
本人菜鸡一枚，如有错误，评论区指正，本文主要为算法新手在比赛中骗分提供一些思路，这皆是我的一家之言，大伙看个乐就行了。这题不能用暴力解决，毕竟10的11次方了。这题只要求观察出1！到39！之和后面的末尾9位数没有变过即可解决，如果有接触过这种类型题，可快速完成答案：215040简单进制转换。long换成int也是可以的，不会爆本人这题没有审题已寄，我以为是计算全部然后输出（样例的4，0是分页的），这题ans过大的话可能要用BigInteger处理。这题只需考虑{}和{全部}的关系,应该是能骗些分的。
蓝桥杯第14届Java C组省赛真题及考试注意事项
第十四届蓝桥杯Java C组省赛真题涵盖了丰富的题型，包括结果填空和程序设计两种类型。参赛选手需在考试开始后下载试题并使用考场提供的解压密码解压。考试时间为4小时，期间允许浏览已提交的答案并进行拷贝，但时间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值