第九届蓝桥杯JavaA组(2018年)省赛真题解析

已于 2022-04-05 20:28:46 修改
阅读量6.8k 收藏 1
点赞数 1
分类专栏： 算法与数据结构 文章标签： 蓝桥杯 java 职场和发展
于 2022-01-21 12:02:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/122617913
版权

第九届蓝桥杯JavaA组(2018年)省赛真题解析

1.分数

  • 1/1+1/2+1/4+1/8+1/16+…
  • 每项是前一项的一半，如果一共有20项，求这个和是多少
  • 结果用分数表示，类似：
  • 3/2，当然这这是加了前2项而已，分子分母要求互质，
  • 提交的是已经约分过的分数。

思想：求出分子分母，同除最大公约数即可。

/**
 * 1.分数
 * 1/1+1/2+1/4+1/8+1/16+...
 * 每项是前一项的一半，如果一共有20项，求这个和是多少
 * 结果用分数表示，类似：
 * 3/2，当然这这是加了前2项而已，分子分母要求互质，
 * 提交的是已经约分过的分数。
 */
public class Main {
    static int n ;
    public static void main(String[] args) {
        int index = 1, sum = 0 ;
        for(int i=1; index<=20; i*= 2){
            n = i ;
            sum += i ;
            index ++ ;
        }
        System.out.println(sum/gcd(sum,n) + "/" + n/gcd(sum,n));
    }

    private static int gcd(int sum, int n) {
        if(n==0){
            return sum ;
        }
        return gcd(n, sum%n) ;
    }
}

2.星期一
思想：做个平闰年判断，累积天数，然后除以7就是星期一的天数。

import static java.time.Year.isLeap;

public class Main1 {
    public static void main(String[] args) {
        long days = 0 ;
        for(int year=1901; year<=2000; year++){
            if(isLeap(year)){
                days += 366 ;
            }else{
                days += 365 ;
            }
        }
        System.out.println(days/7);
    }
    /**
    private static boolean leap(int year){
        if((year%4 == 0 && year%100!=0) || year%400==0){
            return true ;
        }
        return false ;
    }
     */
}

3.复数幂
思想：这个需要用到Java特有的BigInteger，然后迭代找出虚部和实部即可。

import java.math.BigInteger;

/**
 * 3.复数幂
 * 设i为虚数单位，对任意正整数n，(2+3i)^n的实部和虚部都是整数，
 * 求(2+3i)^123456等于多少，这个数字很大，要求精确表示，
 */

public class Main {
    static BigInteger aa, bb ;
    public static void main(String[] args) {
        BigInteger a = new BigInteger("2") ;
        BigInteger b = new BigInteger("3") ;
         aa = null;
         bb = null ;
        for(int i=1; i<=123455; i++){
            aa = a.multiply(new BigInteger("2")).subtract(b.multiply(new BigInteger("3"))) ;
            bb = b.multiply(new BigInteger("2")).add(a.multiply(new BigInteger("3"))) ;
            a = aa ;
            b = bb ;
        }
        System.out.println(a + "" + (b.compareTo(BigInteger.ONE)<=0 ? "" : "+") + b + "i");
    }
}

4.方格计数
思想：求出一个象限满足限制条件的，乘以4即可。


public class Main {
    public static void main(String[] args) {
        long ans = 0 ;
        long N = 50000;
        long y = N ;
        for(long x=1; x<=N; x++){
            while(y>0 && x*x+y*y>N*N){
                y -- ;
            }
            ans += y ;
        }
        System.out.println(4*ans);
    }
}

5.代码填空：略

6.航班日期
思想：规律题，两次航行的时间差求和取平均就是航行时间。


/**
 * 航班日期
 3
 17:48:19 21:57:24
 11:05:18 15:14:23
 17:21:07 00:31:46 (+1)
 23:02:41 16:13:20 (+1)
 10:19:19 20:41:24
 22:19:04 16:41:09 (+1)

 */

import java.text.ParseException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        import java.util.Scanner;

public class Main1 {
    static int T ;
    static Scanner input = new Scanner(System.in) ;
    public static void main(String[] args) throws ParseException {
        T = input.nextInt() ;
        input.nextLine() ;
        for(int i=0; i<T; i++){
            long t1 = getTime() ;
            long t2 = getTime() ;
            long t = (t1+t2) / 2 ;
            System.out.printf("%02d:%02d:%02d\n",t/3600,t/60%60, t%60);
        }
    }

    private static long getTime() throws ParseException {
        String time = input.nextLine() ;
        String [] split = time.split(" ") ;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH:mm:ss") ;
        Date t1 = simpleDateFormat.parse(split[0]) ;
        Date t2 = simpleDateFormat.parse(split[1]) ;
        int d = 0 ;
        if(split.length==3){
            d = Integer.parseInt(split[2].substring(2,3)) ;
        }
        return d*24*3600 + t2.getTime()/1000 - t1.getTime()/1000 ;
    }
}

7.三体攻击
思想：这题比较，我用的是暴力法，可以通过部分测试用例，比较好的方法是二分加三维前缀和，但是赛场上还是用暴力迅速得分靠谱。

import java.util.Scanner;

/**
 * 7.三体攻击
 *
 */
public class Main {
    static int A,B,C,m ;
    static int [][] attack ;
    static int [][][] a ;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        A = input.nextInt() ;
        B = input.nextInt() ;
        C = input.nextInt() ;
        m = input.nextInt() ;
        a = new int [A+1][B+1][C+1] ; //用来存储每个战舰的生命值
        attack = new int [m][7] ;//记录每一轮攻击的7个数据
        for(int i=1; i<=A; i++){ //记录战舰的生命值
            for(int j=1; j<=B; j++){
                for(int k=1; k<=C; k++){
                    a[i][j][k] = input.nextInt();
                }
            }
        }
        for(int i=0; i<m; i++){ //记录攻击信息
            for(int j=0; j<7; j++){
                attack[i][j] = input.nextInt() ;
            }
        }
        for(int round=0; round<m; round++){ //攻击轮数
            for(int i=attack[round][0]; i<=attack[round][1]; i++){
                for(int j=attack[round][2]; j<=attack[round][3]; j++){
                    for(int k=attack[round][4]; k<=attack[round][5]; k++){
                        if(a[i][j][k] > 0){ //受到攻击生命值减少
                            a[i][j][k] -= attack[round][6] ;
                        }else{ //生命值小于0,爆炸
                            System.out.println(round+1);
                            return ;
                        }
                    }
                }
            }
        }
    }
}

8.全球变暖
思想：搜索+标记
第一轮搜索算出有多少岛屿 ；
然后迭代遍历将不会被淹没的标记出来
第二轮搜出出不会被淹没的岛屿数量
两轮搜索的结果相减就是被淹没的岛屿数量

import java.util.Scanner;

/**
 * 8.全球变暖
 */

/**
 7
 .......
 .##....
 .##....
 ....##.
 ..####.
 ...###.
 .......
 */
public class Main {
    static char [][] a ;
    static int N ;
    static int cnt = 0, cnt1 ;
    static int [] offsetX = {-1,1,0,0} ;
    static int [] offsetY = {0,0,-1,1} ;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        N = input.nextInt() ;
        a = new char [N][N] ;
        String s = "" ;
        int index = 0 ;
        for(int i =0; i<N; i++){
                s += input.next() ;
        }
        for(int i=0; i<N; i++){
            for(int j=0; j<N; j++){
                a[i][j] += s.charAt(index++) ;
            }
        }

        for(int i=0; i<N; i++){
            for(int j=0; j<N; j++){
                if(a[i][j] == '#') {
                    dfs1(a, i, j);
                    cnt ++ ;//计算岛屿数量
                }
            }
        }
        for(int i=1; i<N-1; i++) { //还没被淹没的标记为#
            for (int j = 1; j < N-1; j++) {
                if(a[i][j] == '1' && a[i-1][j] == '1' && a[i+1][j]=='1' && a[i][j-1]=='1' && a[i][j+1]=='1'){
                    a[i][j] = '#' ;
                }
            }
        }
        for(int i=0; i<N; i++){
            for(int j=0; j<N; j++){
                if(a[i][j] == '#') {
                    dfs1(a, i, j);
                    cnt1 ++ ;//计算未被淹没的岛屿数量
                }
            }
        }
        System.out.println(cnt-cnt1); //被淹没的岛屿数量
    }

    private static void dfs1(char[][] a, int x, int y) {
        a[x][y] = '1' ;
        for(int i=0; i<4; i++){
            int nx = x + offsetX[i] ;
            int ny = y + offsetY[i] ;
            if(nx<0 || ny<0 || nx>N || ny>N){
                continue;
            }
            if(a[nx][ny] == '#')
            dfs1(a, nx, ny) ;
        }
    }
}

9.倍数问题
方法1：暴力枚举
三层循环，从大到小依次枚举，测试用例数据不是很大，可以通过大多数测试用例。

import java.util.Arrays;
import java.util.Scanner;

/**
 * 9.倍数问题
 *
 */
public class Main {
    static int n, K ;
    static int [] a ;
    static int sum ;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in)  ;
        n = input.nextInt() ;
        K = input.nextInt() ;
        a = new int [n] ;
        for(int i=0; i<n; i++){
            a[i] = input.nextInt() ;
        }
        Arrays.sort(a) ;
        for(int i=n-1; i>0; i--){ //可以通过60%的测试用例
            for(int j=i-1; j>0; j--){
                for(int k=j-1; k>0; k--){
                    sum = a[i] + a[j] + a[k] ;
                    if(sum % K== 0){
                        System.out.println(sum);
                    }
                }
            }
        }

    }
}

方法2：排序+搜索
由大到小排序，搜索枚举，找到第一个就结束


import java.util.Arrays;
import java.util.Scanner;

/**
 * 从小到大排序，然后搜索枚举
 */
public class Main1 {
    static int n, K ;
    static int [] a ;
    static int [] c ;
    static int [] b ;
    static boolean flag = false ;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        n = input.nextInt() ;
        K = input.nextInt() ;
        a = new int [n+1] ;
        c = new int [n+1] ;
        b = new int [4] ;
        c[0] = Integer.MAX_VALUE ;
        for(int i=1; i<=n; i++){
            a[i] = input.nextInt() ;
        }
        Arrays.sort(a) ;
        for(int i=1; i<=n; i++){
            c[i] = a[n-i+1] ;
        }
        dfs(c, n, 1) ;
    }

    private static void dfs(int[] c, int n, int s) {
        if(flag){
            return ;
        }
        if(s==4){
            int sum = b[1] + b[2] + b[3] ;
            if(sum%K==0){
                System.out.println(sum);
                flag = true ;
            }
            return ;
        }
        for(int i=1; i<=n; i++){
            if(c[i]<c[s-1]){
                b[s] = c[i] ;
                dfs(c, n, s+1) ;
            }
        }
    }
}

10.付账问题
思想：贪心策略，拥有的钱由小到大排序，每一次遍历拥有的钱小于均摊值，则全部出，否则，所有人出均摊值，局部最优，全局也最优。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static double  S, ave, avg = 0, s=0;
    static int n ;
    static double [] a ;
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in) ;
        n = input.nextInt() ;
        S = input.nextDouble() ;
        a = new double[n] ;
        for(int i=0; i<n; i++){
            a[i] = input.nextDouble() ;
        }
        avg = S / n ;
        ave = avg ;
        Arrays.sort(a) ;
        for(int i=0; i<n; i++){
            if(ave > a[i]){
                S -= a[i] ;
                s += (avg-a[i]) * (avg-a[i]) ;
                ave= S / (n-i-1) ;
            }else{
                double avg1 = S / (n-i) ;
                s += (avg-avg1)*(avg-avg1)*(n-i) ;
                break ;
            }
        }
        System.out.printf("%.4f", Math.sqrt(s/n));
    }
}
nuist__NJUPT
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2018年第九届蓝桥杯省赛 Java A 组真题
Code-CHAN的博客
04-07 184
2018年第九届蓝桥杯省赛 Java A 组真题 第一题 import java.util.Calendar; public class Q1 { public static void main(String[] args) { Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, 2000); // 月份从 0 开始 cal.set(Calendar.MONTH, 0); cal.set(Calendar.
2018年第九届蓝桥杯C/C++省赛A组题解
liuwq012的专栏
04-04 6580
2018年第九届蓝桥杯C/C++省赛A组题解第一题：题意：就是求一个，首项为1，等比为1/2的等比数列的前二十项之和答案：就是2^20-1/2^19第二题：题意：求整个二十世纪总共有多少个星期一求解过程：当时灵机一动，打开电脑日历，查看了20世纪第一天是星期一（哈哈），然后算出整个二十世纪有25个闰年，所以总天数就是（365*100+25）/7 = 5217天。第三题题意：求解给定的数相乘得到的数...
2018年蓝桥杯第九届javaA组省赛题解
Zun
02-10 1359
蓝桥杯第九届省赛题解 1.标题：分数 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + … 每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2 当然，这只是加了前2项而已。分子分母要求互质。 注意： 需要提交的是已经约分过的分数，中间任何位置不能含有空格。 请不要填写任何多余的文字或符号。 思路 手动计算： 等比数列，再约分 编码： 求和 约...
第十一届蓝桥杯大赛决赛试题Java A组(试题解析)
Learning_xzj的博客
05-08 5991
## 试题 **A:** 合数个数 **👀问题描述** 一个数如果除了 1 和自己还有其他约数，则称为一个合数。 例如：1, 2, 3 不是合数，4, 6 是合数。请问从 1 到 2020 一共有多少个合数。 ✏️**思路解析** 在1-2020这些数中，构成有3部分：质数、合数、既非质数亦非合数，既非质数亦非合数只有数字"1"。 ✨**参考代码**
蓝桥杯2022JAVAA组详解
gbhhshh的博客
04-11 6528
蓝桥杯A组JAVA题解
第九届蓝桥杯JavaA组省赛真题
热门推荐
南 墙
07-20 1万+
解题代码部分来自网友，如果有不对的地方，欢迎各位大佬评论 题目1、分数 题目描述 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + … 每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2 当然，这只是加了前2项而已。分子分母要求互质。 注意： 需要提交的是已经约分过的分数，中间任何位置不能含有空格。 请不要填写任何多余的文字或符号。 Sn=...
第十三届蓝桥杯JavaA组省赛第二场
05-14
1. **Java编程基础**：蓝桥杯JavaA组省赛涉及的是Java编程，参赛者需要掌握Java语言的基本语法、数据类型、控制结构、类与对象、异常处理、输入输出流等核心概念。 2. **算法与数据结构**：比赛中的程序设计题要求...
2018第九届蓝桥杯省赛Java语言A组
04-02
【标题】2018第九届蓝桥杯省赛Java语言A组是针对Java编程语言的一场算法竞赛，旨在测试参赛者在Java语言基础、数据结构、算法设计与实现等多方面的能力。作为一场省级赛事，它对于参赛者的技术水平有一定的要求，...
2017第八届蓝桥杯大赛个人赛省赛（软件类C/C++）真题（A/B/C）
03-10
【标题】2017第八届蓝桥杯大赛个人赛省赛（软件类C/C++）真题（A/B/C） 【描述】这次大赛聚焦于软件类的C/C++编程，旨在考察参赛者的编程能力、算法理解以及问题解决技巧。比赛涵盖了从基础编程到复杂算法的多个...
蓝桥杯历届真题解析（Java 大学 A,B,C 组）
03-26
《蓝桥杯历届真题解析（Java 大学 A,B,C 组）》是一部集成了历年蓝桥杯编程竞赛中Java大学组A、B、C三类问题的解析资料，旨在帮助参赛者深入理解比赛题目，提升编程技能，以及为准备参加蓝桥杯的大学生提供宝贵的...
2013蓝桥杯javaA组真题官方代码
03-29
"2013蓝桥杯Java A组真题官方代码"是针对一项知名编程竞赛——蓝桥杯的Java部分题目提供的官方参考实现。蓝桥杯是一项面向全国高校学生的IT技术比赛，旨在提升参赛者的编程技能和算法理解能力，特别是在软件和信息...
2018年第九届蓝桥杯C/C++A组省赛 题面&部分题解
krypton12138的博客
04-03 1万+
首先，原题： 链接: https://pan.baidu.com/s/1UzRN6Mf2Dwp0263F-MMESg 密码: 2ryh 第一题 标题：分数 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + .... 每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2 当然，这只是加了前2项而已。分子分母要求互质。 注意： 需要...
1235. 付账问题 Java题解 （贪心）【第九届蓝桥杯省赛C++A组,JAVA A组】
深街酒徒的博客
04-04 442
要想使得标准差最小，即方差最小，应使得所有人的付账波动不能太大，理想状况是每人应该出正好平均值的钱，这样方差就是0。但是，当有人不够平均值时，就需要将他所有的钱都结付，尽可能的接近平均值，那这个人不够的部分就需要其他人来补上了，为了使每人出的钱都接近平均值，所以补的这部分需要“有能力担负的起的人”共同均摊。
【蓝桥杯】Java开发A组省赛真题+详细解析
丧心病狂Loli控的博客
04-19 1427
1. 世纪末的星期 曾有邪教称1999年12月31日是世界末日。当然该谣言已经不攻自破。   还有人称今后的某个世纪末的12月31日，如果是星期一则会…   有趣的是，任何一个世纪末的年份的12月31日都不可能是星期一!!   于是，“谣言制造商”又修改为星期日…   1999年的12月31日是星期五，请问：未来哪一个离我们最近的一个世纪末年（即xx99年）的12月31日正好是星期天（即星期日）？   请回答该年份（只写这个4位整数，不要写12月31等多余
蓝桥杯AcWing学习笔记 7-1贪心的学习（上）（附相关蓝桥真题：付账问题、乘积最大）(Java)
How many ten years in the life time?
03-26 3154
贪心（上） 贪心 顾名思义 我们在考虑的时候很贪婪：① 找一个最优解 ② 短视（只考虑眼前的） y总：我个人认为贪心是所有算法题里面最难的一章，比dp还要难一些，因为贪心的题没有固定的套路，可能两道贪心题没有任何的关联，它的跳跃性非常强，代码很短，但结论的证明很难，很难想出来。 那考试的时候遇到贪心题怎么办呢？一般有两种做法： ① 看一下这个贪心题是否和我们之前做过的题是相似的，然后用当时的那道题套一下看看能不能做出来。 ② 只能靠猜，猜完的话可以尝试证明出来，但是很难。 例题 AcWing 105
2020年第十一届蓝桥杯JavaA组省赛
衣点QIAO的博客
03-29 2201
文章目录试题 A: 门牌制作试题 B: 既约分数试题 C: 蛇形填数试题 D: 七段码试题 E: 排序试题 F: 成绩分析试题 G: 单词分析试题 H: 数字三角形试题 I: 子串分值和试题 J: 装饰珠 以下均为个人想法和解题思路，如有错误或不足，欢迎指正。 试题 A: 门牌制作 本题总分：5 分 【问题描述】 小蓝要为一条街的住户制作门牌号。 这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。 小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字 符粘贴到
1/1 + 1/2 + 1/4 + 1/8 + 1/16 + .... 每项是前一项的一半，如果一共有20项,求这个和是多少，结果用分数表示出来。分子分母要求互质。
vivi_cin的博客
01-21 1054
转载：蓝桥杯真题 18省Ca1-分数 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + .... 每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2_伏城无嗔的博客-CSDN博客
2018蓝桥杯赛题
NYIST_TC_LYQ的博客
04-01 3555
标题：分数 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + ....  每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2 当然，这只是加了前2项而已。分子分母要求互质。 注意： 需要提交的是已经约分过的分数，中间任何位置不能含有空格。 请不要填写任何多余的文字或符号。 标题：星期一
2022年蓝桥杯javaa组
最新发布
09-07
2022年蓝桥杯Java A组是中国著名的计算机竞赛之一，该比赛旨在发掘和培养优秀的Java程序设计人才。参赛者需要具备一定的Java编程基础和算法思维能力，通过解决一系列实际问题来展示自己的技术水平。 蓝桥杯Java A组比赛内容将涉及Java语言基础知识、面向对象编程、数据结构与算法、数据库等方面。参赛选手需要通过模拟真实的工作场景，设计和实现各种功能模块，展现出自己解决问题的能力和代码的优雅性。 蓝桥杯Java A组比赛对于参赛者来说是一次难得的锻炼机会。通过参加比赛，可以学习到实际项目中常用的技术和解决问题的思路，提高自己的编程能力。同时，这也是一个展示自己才华和与其他选手竞争的舞台，可以通过与其他优秀选手的交流互动，拓宽自己的视野，并且与同龄人一起追求计算机编程的进步。 参加蓝桥杯Java A组比赛，不仅可以提升自己的技术能力，还能为自己的未来发展增加一份宝贵的竞赛经验。很多优秀的程序员和企业都非常看重蓝桥杯的参赛者，因为这代表着他们在编程领域具备一定的实力和潜力。 总而言之，参加2022年蓝桥杯Java A组是一个对自己实力的检验和提高的机会，同时也是一个与其他优秀选手竞争的平台，可以通过比赛锻炼自己的技术能力和解决问题的能力。参赛者在比赛中要保持冷静和耐心，学会与其他选手交流和合作，相信通过努力，一定能够在比赛中取得好的成绩。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nuist__NJUPT

给个鼓励吧，谢谢你

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值