第七届蓝桥杯Java C组决赛试题

最新推荐文章于 2024-02-19 21:35:59 发布

Slayer_Zhao

最新推荐文章于 2024-02-19 21:35:59 发布

阅读量1k

点赞数

分类专栏：蓝桥杯文章标签：蓝桥杯

本文链接：https://blog.csdn.net/qq_38905818/article/details/80099406

版权

蓝桥杯专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.平方末尾

能够表示为某个整数的平方的数字称为“平方数”
比如，25,64
虽然无法立即说出某个数是平方数，但经常可以断定某个数不是平方数。
因为平方数的末位只可能是：[0, 1, 4, 5, 6, 9] 这6个数字中的某个。
所以，4325435332必然不是平方数。

如果给你一个2位或2位以上的数字，你能根据末位的两位来断定它不是平方数吗？

请计算一下，一个2位以上的平方数的最后两位有多少种可能性？

注意：需要提交的是一个整数，表示2位以上的平方数最后两位的不同情况数。
不要填写任何多余内容（比如，说明解释文字等）

答案：22

思路：枚举暴力

import java.util.*;
public class Main
{
    static int a[]=new int[100];
    public static void main(String[] args)
    {
        int count=0;
        for(int i=4;i<10000;i++)
        {
            int res=i*i%100;
            a[res]++;
        }

        for(int i=0;i<100;i++)
        {
            if(a[i]>0)
            {
                count++;
            }
        }
        System.out.println(count);
    }

}

2.七星填数

如图【图1.png】所示。

在七角星的14个节点上填入1~14 的数字，不重复，不遗漏。
要求每条直线上的四个数字之和必须相等。

图中已经给出了3个数字。
请计算其它位置要填充的数字，答案唯一。

填好后，请提交绿色节点的4个数字（从左到右，用空格分开）

比如：12 5 4 8
当然，这不是正确的答案。

注意：只提交4个用空格分开的数字，不要填写任何多余的内容。

答案：10 3 9 8

思路：数组全排暴力

import java.util.*;
public class Main {

    public static boolean check(int a[])
    {
        int []r=new int[7];
        r[0]=a[0]+a[1]+a[2]+a[3];
        r[1]=a[3]+a[5]+a[7]+a[10];
        r[2]=14+a[6]+a[8]+a[10];
        r[3]=14+a[4]+a[1]+6;
        r[4]=6+a[2]+a[5]+11;
        r[5]=11+a[7]+a[8]+a[9];
        r[6]=a[0]+a[4]+a[6]+a[9];


        for(int i=0;i<6;i++)
        {
            for(int j=i+1;j<7;j++)
            {
                if(r[i]!=r[j])
                {
                    return false;
                }
            }
        }

        return true;

    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5,7,8,9,10,12,13};
        allSort(array, 0, array.length-1);

    }
    static void allSort(int[] array,int begin,int end){

        if(begin==end){
            if(check(array))
            {
                System.out.print(array[0]+" "+array[1]+" "+array[2]+" "+array[3]+" ");
            }
            return;
        }

        for(int i=begin;i<=end;i++){
            swap(array,begin,i );
            allSort(array, begin+1, end);
            swap(array,begin,i );
        }
    }

    static void swap(int[] array,int a,int b){
        int tem=array[a];
        array[a]=array[b];
        array[b]=tem;
    }


}

3.打印数字

小明写了一个有趣的程序，给定一串数字。
它可以输出这串数字拼出放大的自己的样子。

比如“2016”会输出为：
22222 00000 1 6666
2 2 0 0 1 1 6
2 0 0 1 666666
2 0 0 1 6 6
2 0 0 1 6 6
2 2 0 0 1 6 6
2222222 00000 1111 66666

请仔细分析代码，填写划线部分缺少的内容。

public class Main
{
	static void f(int n)
	{
		String[][] di = 
	{{" 00000 ",
	"0     0",
	"0     0",
	"0     0",
	"0     0",
	"0     0",
	" 00000 "},
	{"     1 ",
	"   1 1 ",
	"     1 ",
	"     1 ",
	"     1 ",
	"     1 ",
	"   1111"},
	{" 22222 ",
	"2     2",
	"      2",
	"     2 ",
	"   2   ",
	" 2    2",
	"2222222"},
	{" 33333 ",
	"3     3",
	"      3",
	"  3333 ",
	"      3",
	"3     3",
	" 33333 "},
	{"   44  ",
	"  4 4  ",
	" 4  4  ",
	"4   4  ",
	"4   4  ",
	"4444444",
	"    4  "},
	{" 55555 ",
	" 5     ",
	"555555 ",
	"      5",
	"      5",
	"5     5",
	" 55555 "},
	{" 6666  ",
	"6      ",
	"666666 ",
	"6     6",
	"6     6",
	"6     6",
	" 66666 "},
	{"7777777",
	"7    7 ",
	"    7  ",
	"   7   ",
	"  7    ",
	" 7     ",
	" 7     "},
	{" 88888 ",
	"8     8",
	"8     8",
	" 88888 ",
	"8     8",
	"8     8",
	" 88888 "},
	{" 99999 ",
	"9     9",
	"9     9",
	" 999999",
	"      9",
	"9     9",
	" 99999 "}};
		               
		char[] cc = (""+n).toCharArray(); 
		          
		for(int i=0; i<di[0].length; i++){
			for(int j=0; j<cc.length; j++){
				System.out.print( ____________________ + " ");  //填空位置
			}
			System.out.println();
		}	
	}
	
	public static void main(String[] args)
	{
		f(2016);
	}
}

注意：只提交划线部分缺少的代码，不要添加任何题面已有代码或符号。
也不要提交任何说明解释文字等。

答案：di[cc[j]-'0'][i]

4.赢球票

某机构举办球票大奖赛。获奖选手有机会赢得若干张球票。

主持人拿出 N 张卡片（上面写着 1~N 的数字），打乱顺序，排成一个圆圈。
你可以从任意一张卡片开始顺时针数数: 1,2,3.....
如果数到的数字刚好和卡片上的数字相同，则把该卡片收入囊中，从下一个卡片重新数数。
直到再无法收获任何卡片，游戏结束。囊中卡片数字的和就是赢得球票的张数。

比如：
卡片排列是：1 2 3
我们从1号卡开始数，就把1号卡拿走。再从2号卡开始，但数的数字无法与卡片对上，
很快数字越来越大，不可能再拿走卡片了。因此这次我们只赢得了1张球票。

还不算太坏！如果我们开始就傻傻地从2或3号卡片数起，那就一张卡片都拿不到了。

如果运气好，卡片排列是 2 1 3
那我们可以顺利拿到所有的卡片！

本题的目标就是：已知顺时针卡片序列。
随便你从哪里开始数，求最多能赢多少张球票（就是收入囊中的卡片数字之和）

输入数据：
第一行一个整数N(N<100)，表示卡片数目
第二行 N 个整数，表示顺时针排列的卡片

输出数据：
一行，一个整数，表示最好情况下能赢得多少张球票

比如：
用户输入：
3
1 2 3

程序应该输出：
1

比如：
用户输入：
3
2 1 3

程序应该输出：
6

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

思路：模拟过程即可

import java.util.*;
public class Main {


    public static void main(String[] args) {

        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int a[]=new int[n+1];
        boolean vis[]=new boolean[n+1];
        int max=0;

        for(int i=1;i<=n;i++)
        {
            a[i]=in.nextInt();
        }

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

            for(int k=1;k<=n;k++)
            {
                vis[k]=false;
            }

            int num=1;
            int count=0;
            for(int j=0;;j++)
            {
                int index=(i+j)%n;
                if(vis[index]) continue;
                if(num==a[index])
                {
                    count+=num;
                    vis[index]=true;
                    num=0;
                }
                if(num>n)
                {
                    break;
                }
                num++;
            }
            if(count>max)
            {
                max=count;
            }
        }

        System.out.print(max);

    }
    
}

5.路径之谜

小明冒充X星球的骑士，进入了一个奇怪的城堡。
城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 n x n 个方格。【如图1.png】所示。

按习俗，骑士要从西北角走到东南角。
可以横向或纵向移动，但不能斜着走，也不能跳跃。
每走到一个新方格，就要向正北方和正西方各射一箭。
（城堡的西墙和北墙内各有 n 个靶子）

同一个方格只允许经过一次。但不必做完所有的方格。

如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？

有时是可以的，比如图1.png中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入：
第一行一个整数N(0<N<20)，表示地面有 N x N 个方格
第二行N个整数，空格分开，表示北边的箭靶上的数字（自西向东）
第三行N个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出：
一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3....
比如，图1.png中的方块编号为：

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

示例：
用户输入：
4
2 4 3 4
4 3 3 3

程序应该输出：

0 4 5 1 2 3 7 11 10 9 13 14 15

思路：DFS，亮点是需要用step记录路径

import java.util.*;
public class Main
{
    static int x[]={1,-1,0,0};
    static int y[]={0,0,1,-1};
    static int a[];//x方向靶子
    static int b[];//y方向靶子
    static boolean vis[][];//是否访问
    static int d[];//路径
    static int n;

    public static void dfs(int a1[],int b1[],int i,int j,int step)
    {
        if(check1(a1,b1))//判断x,y方向是否有出现超出数量的靶子
        {
            return;
        }

        if(check2(a1,b1) && i==n && j==n)//判断是否满足题目条件
        {
            d[step]=n*n-1;
            for(int k=1;k<=step;k++)
            {
                System.out.print(d[k]+" ");
            }
            System.exit(0);
        }

        d[step] = (i-1)*n+j-1;//记录路径

        for(int k=0;k<4;k++)//四个方向dfs
        {
            if(!vis[i+x[k]][j+y[k]])
            {
                vis[i+x[k]][j+y[k]]=true;
                a[j+y[k]]--;
                b[i+x[k]]--;
                dfs(a1,b1,i+x[k],j+y[k],step+1);
                vis[i+x[k]][j+y[k]]=false;
                a[j+y[k]]++;
                b[i+x[k]]++;
            }
        }
    }
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        a=new int[n+1];
        b=new int[n+1];
        vis=new boolean[n+2][n+2];
        d=new int[n*n+1];

        vis[1][1]=true;

        for(int i=0;i<=n;i++)
        {
            vis[0][i]=true;
            vis[i][0]=true;
            vis[n+1][i]=true;
            vis[i][n+1]=true;
        }

        for(int i=1;i<=n;i++)
        {
            a[i]=in.nextInt();
        }
        for(int i=1;i<=n;i++)
        {
            b[i]=in.nextInt();
        }
        a[1]--;
        b[1]--;

        dfs(a,b,1,1,1);

    }

    public static boolean check1(int[] a1,int[] b1){
        for(int i=1;i<=n;i++){
            if(a1[i]<0||b1[i]<0){
                return true;
            }
        }
        return false;
    }
    public static boolean check2(int[] a1,int[]b1){
        for(int i=1;i<=n;i++){
            if(a1[i]!=0||b1[i]!=0){
                return false;
            }
        }
        return true;
    }
}

6.碱基

生物学家正在对n个物种进行研究。
其中第i个物种的DNA序列为s[i]，其中的第j个碱基为s[i][j],碱基一定是A、T、G、C之一。
生物学家想找到这些生物中一部分生物的一些共性，他们现在关注那些至少在m个生物中出现的长度为k的连续碱基序列。准确的说，科学家关心的序列用2m元组(i1,p1,i2,p2....im,pm)表示，
满足:
1<=i1<i2<....<im<=n;
且对于所有q(0<=q<k), s[i1][p1+q]=s[i2][p2+q]=....=s[im][pm+q]。

现在给定所有生物的DNA序列，请告诉科学家有多少的2m元组是需要关注的。如果两个2m元组有任何一个位置不同，则认为是不同的元组。

【输入格式】
输入的第一行包含三个整数n、m、k，两个整数之间用一个空格分隔，意义如题目所述。
接下来n行，每行一个字符串表示一种生物的DNA序列。
DNA序列从1至n编号，每个序列中的碱基从1开始依次编号，不同的生物的DNA序列长度可能不同。

【输出格式】
输出一个整数，表示关注的元组个数。
答案可能很大，你需要输出答案除以1000000007的余数。

【样例输入】
3 2 2
ATC
TCG
ACG

【样例输出】
2

再例如：
【样例输入】
4 3 3
AAA
AAAA
AAA
AAA

【样例输出】
7

【数据规模与约定】
对于20%的数据，k<=5,所有字符串总长L满足L <=100
对于30%的数据，L<=10000
对于60%的数据，L<=30000
对于100%的数据，n<=5,m<=5,1<=k<=L<=100000
保证所有DNA序列不为空且只会包含’A’ ’G’ ’C’ ’T’四种字母

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

Slayer_Zhao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
第七届蓝桥杯Java C组决赛试题

1.平方末尾能够表示为某个整数的平方的数字称为“平方数”比如，25,64虽然无法立即说出某个数是平方数，但经常可以断定某个数不是平方数。因为平方数的末位只可能是：[0, 1, 4, 5, 6, 9] 这6个数字中的某个。所以，4325435332必然不是平方数。如果给你一个2位或2位以上的数字，你能根据末位的两位来断定它不是平方数吗？请计算一下，一个2位以上的平方数的最后两位有多少种可能性？注意：...
复制链接

扫一扫