蓝桥杯JAVA-试题-基础练习

已于 2024-10-27 21:13:27 修改
阅读量612 收藏 23
点赞数 15
分类专栏： 备赛蓝桥杯 文章标签： 蓝桥杯 java 职场和发展 开发语言
于 2024-03-26 12:16:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76949164/article/details/137038952
版权

一、十六进制转八进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

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

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

　　【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

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

解题思路

 输入十六进制转八进制，java支持十六进制转二进制或十进制，和二进制或十进制转八进制

因此要中转一下

本题目如果使用Integer和String会超数据域，因此引入BigInteger类

BigInteger这个类，是超巨整数类，整数域能达到2的2的32次方，很适合在十六进制转换时使用，具体操作请看代码

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        //int[] a=new int[n];
        for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,16);//输入16进制数
            System.out.println(big.toString(8));//输出转八进制数
        }
    }
}

若不考虑数据域，使用Integer和String把十六进制转十进制再转八进制，请看以下代码 

String sixteen=in.next();
String eight=Integer.toOctalString((Integer.parseInt(sixteen,16)));
System.out.println(eight);

 二、试题 基础练习 十六进制转十进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

样例输入

FFFF

样例输出

65535

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //int n=in.nextInt();
        //int[] a=new int[n];
        //for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,16);
            System.out.println(big.toString(10));
        //}
    }
}

 若不考虑数据域，使用Integer和String把十六进制转十进制，请看以下代码 

String sixteen=in.next();
int ten=Integer.parseInt(sixteen,16);
System.out.println(ten);

三、十进制转十六进制

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647

输出格式

　　输出这个整数的16进制表示

样例输入

30

样例输出

1E

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Locale;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //int n=in.nextInt();
        //int[] a=new int[n];
        //for (int i = 0; i < n; i++) {
            String a=in.next();
            BigInteger big=new BigInteger(a,10);
            System.out.println(big.toString(16).toUpperCase(Locale.ROOT));
        //}
    }
}

若不考虑数据域，使用Integer和String把十进制转十六进制，请看以下代码  

int ten=in.nextInt();
String sixteen=Integer.toHexString(ten);

四、特殊回文数

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

输入格式

　　输入一行，包含一个正整数n。

输出格式

　　按从小到大的顺序输出满足条件的整数，每个整数占一行。

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

解题思路

本题有两个条件：

1.回文数

2.各个位数的和为它本身

因此就制造两个函数，分别实现两个判断功能

最后在循环里跑起来就可以了 

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int sum=0;
        for(int i=10000;i<1000000;i++)
        {
            if(isIt(i))
            {
                if(getSum(i)==n)
                    System.out.println(i);
            }
        }
    }
    public static boolean isIt(int n)
    {
        String s=Integer.toString(n);
        for(int i=0,j=s.length()-1;i<j;i++,j--)
        {
            if(s.charAt(i)!=s.charAt(j))
                return false;
        }
        return true;
    }
    public static int getSum(int n)
    {
        int sum=0;
        while(n>0)
        {
            sum+=(n%10);
            n/=10;
        }
        return sum;
    }

}

五、回文数

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输出格式

　　按从小到大的顺序输出满足条件的四位十进制数。

思路

这题是刚才的削弱版，同理 

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        for(int i=1000;i<10000;i++)
        {
            if(isIt(i))
                System.out.println(i);
        }
    }
    public static boolean isIt(int n)
    {
        String s=Integer.toString(n);
        for(int i=0,j=s.length()-1;i<j;i++,j--)
        {
            if(s.charAt(i)!=s.charAt(j))
                return false;
        }
        return true;
    }
}

六、杨辉三角

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

　　

它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

　　

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

　　

   1

　　

  1 1

　　

 1 2 1

　　

1 3 3 1

　　

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

输入格式

输入包含一个数n。

输出格式

输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。

样例输入

4

样例输出

1
1 1
1 2 1
1 3 3 1

数据规模与约定

1 <= n <= 34。

解题思路

杨辉三角的规则：

第一行为1，

第二行为11，

从第三行开始往后每一行，边界都为1，每一行从第2个数到第n-1个数为上一行的相邻数依次相加得到，如图

 

实现的过程中，记住我给出的原理小的时候

记录上一行，留给下一行计算使用

二维列表法 

使用List实现的优势：
1. 更灵活：List的长度可以动态增长，不需要提前指定数组的大小。
2. 更易于操作：List提供了丰富的方法，如add、clear等，方便对数据进行操作。
3. 可读性更好：使用List可以更直观地表示数据结构，代码可读性更高。

使用List实现的劣势：
1. 性能较差：List的底层是基于数组实现的，相比直接使用数组会有一定的性能损失。
2. 内存占用较大：List在动态增长时可能会造成内存碎片，占用更多内存空间。

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        List<List<Integer>> list=Triangle(n);
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<list.get(i).size();j++)
            {
                if(j==0)
                    System.out.print(list.get(i).get(j));
                else
                    System.out.print(" "+list.get(i).get(j));

            }
            System.out.println();
        }
    }
    public static List<List<Integer>> Triangle(int n)
    {
        List<List<Integer>> list=new ArrayList<>();
        if(n==0)
            return null;
        List<Integer> row=new ArrayList<>();//上一行
        List<Integer> now=new ArrayList<>();//现在这行
        row.add(1);//初始化上一行为第一行：1
        for(int i=0;i<n;i++) {
            list.add(new ArrayList<>(row));
            now.clear();//清空本行
            now.add(1);//本行左边界1
            for(int j=0;j<row.size()-1;j++)
            {
                now.add(row.get(j)+row.get(j+1));
            }
            now.add(1);//本行右边界1
            row.clear();//清空上一行
            row.addAll(now);//把本行数据赋给上一行，也就是说，当前行变成上一行了
        }
        return list;
    }
}

二维数组法

使用数组实现的优势：
1. 性能更好：数组在内存中是连续存储的，访问元素速度更快。
2. 内存占用更小：数组的大小是固定的，不会因动态增长而产生额外开销。

使用数组实现的劣势：
1. 不够灵活：数组长度固定，需要提前指定大小，不适合动态增长的情况。
2. 操作复杂：需要手动处理数组的边界情况，代码相对复杂一些。

import java.util.*;

public class Main{
	public static void main(String args[]){
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		int arr[][]=new int[n][n];
		for(int i=0;i<n;i++) {
			for(int j=0;j<i+1;j++) {
				arr[i][j]=1;
				if(i>=1&&j>=1) {
					arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
				}
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}

综合来看，如果数据规模较小且代码可读性更重要，可以选择使用List实现；如果需要处理大规模数据且性能要求较高，可以选择使用数组实现。在实际应用中，根据具体需求和场景选择合适的实现方式会更加合适。 

七、查找整数

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式

如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

解题思路

本题其实就是在数组里找一个数，找到了返回位置，找不到返回-1

常规做法就是for循环

但如何不用for循环呢？

那就用java的列表，使用查找ArrayList.indexOf() 

import java.util.ArrayList;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        ArrayList<Integer> list=new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(in.nextInt());
        }
        int m=in.nextInt();
        int i=list.indexOf(m)>-1 ? list.indexOf(m)+1 : -1;
        System.out.println(i);
    }
}

八、数列特征

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

输入格式

第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式

输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。

样例输入

5
1 3 -2 4 5

Data

样例输出

5
-2
11

Data

数据规模和约定

1 <= n <= 10000。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n];
        int sum=0;
        for (int i = 0; i < n; i++) {
            a[i]=in.nextInt();
            sum+=a[i];
        }
        Arrays.sort(a);
        System.out.println(a[n-1]);
        System.out.println(a[0]);
        System.out.println(sum);
    }
}

九、字母图形

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

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

输入格式

输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式

输出n行，每个m个字符，为你的图形。

样例输入

5 7

样例输出

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

数据规模与约定

1 <= n, m <= 26。

解题思路

这题做的我是真想骂人

题目的意思其实就是，输入两个数N行 M列

这个数M代表第一行的字母数，比如M=7,第一行就是ABCDEFG

N代表行数

题目要从第二行开始，在A的左边遍历字母到Z，每一行多遍历一个字母，最多到Z

比如这样：

24 7

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
FEDCBAB
GFEDCBA
HGFEDCB
IHGFEDC
JIHGFED
KJIHGFE
LKJIHGF
MLKJIHG
NMLKJIH
ONMLKJI
PONMLKJ
QPONMLK
RQPONML
SRQPONM
TSRQPON
UTSRQPO
VUTSRQP
WVUTSRQ
XWVUTSR

 您猜我以为是啥？

我以为是在第一行的基础上，循环遍历第一行的字母，像一个圈一样，右边走了到左边

呈现这样的效果：

24 7
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
FEDCBAB
GFEDCBA
FGFEDCB
EFGFEDC
DEFGFED
CDEFGFE
BCDEFGF
ABCDEFG
GABCDEF
AGABCDE
BAGABCD
CBAGABC
DCBAGAB
EDCBAGA
FEDCBAG
GFEDCBA
FGFEDCB
EFGFEDC
DEFGFED

按我自己读题的思路，代码是这样的：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt(),m= in.nextInt();
        int sum=0;
        LinkedList<Character> list=new LinkedList<>();
        LinkedList<Character> list1=new LinkedList<>();
        char[] a=new char[m];
        for (int i = 0; i < m; i++) {
            a[i]=(char)(i+'A');
        }
        for (int i = 0; i < m; i++) {
            list.add((char)(i+'A'));
        }
        for(int i=0;i<n;i++)
        {
            if(i==0)
            {
                Print(list);
                continue;
            }
            list1.clear();
            list1.addAll(rt(i,list,a));
            list.clear();
            list.addAll(list1);
            Print(list);

        }
    }
    public static LinkedList<Character> rt(int n,LinkedList<Character> list,char[] a)
    {
        int count=0;
        if(a[n%a.length]=='A'||a[n%a.length]==a[a.length-1])
        {
            if((n+1)/a.length%2==0)
                list.addFirst(a[(n)%a.length]);
            else
                list.addFirst(a[a.length-1-((n+1)%a.length)]);
            count++;
        }
        else
        {
            if(n/a.length%2==0)
                list.addFirst(a[(n+count)%a.length]);
            else
                list.addFirst(a[a.length-1-((n+count+1)%a.length)]);
        }
        list.removeLast();
        return list;
    }
    public static void Print(LinkedList<Character> list)
    {
        for (Character c : list) {
            System.out.print(c);
        }
        System.out.println();
    }
}

 按题目的意思代码是这样的

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        char[][] a = new char[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                a[i][j]=(char) ('A'+Math.abs(i-j));//给A加上i-j的绝对值
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(a[i][j]);
            }
            System.out.println();
        }
    }
}

家人们谁懂啊！！！！！ 

十、01字串

资源限制

内存限制：256.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

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

00000

00001

00010

00011

00100

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

输入格式

本试题没有输入。

输出格式

输出32行，按从小到大的顺序每行一个长度为5的01串。

样例输出

00000
00001
00010
00011
<以下部分省略>

解题思路

这道题就是从0到31输出二进制数 

先搞一个for循环，把每一个int数转换成二进制的字符串，再把字符串转化成int

保留五位输出即可

public class Main {
    public static void main(String[] args) {
        for(int i=0;i<32;i++)
        {
            String s=Integer.toBinaryString(i);
            int a=Integer.valueOf(s);
            System.out.printf("%05d\n",a);
        }
    }
}

十一、阶乘计算（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　输入一个正整数n，输出n!的值。
　　其中n!=1*2*3*…*n。

算法描述

　　n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
　　将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
　　首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。

输入格式

　　输入包含一个正整数n，n<=1000。

输出格式

　　输出n!的准确值。

样例输入

10

样例输出

3628800

解题思路

一看这个数据域，n<=1000就知道，这题不简单，涉及到超大整数

1000的阶乘，这得多大啊

我们就想到了java的BigInteger类

补充BigInteger类的方法 

变量和类型方法描述
BigIntegerabs()

返回一个BigInteger，其值是此BigInteger的绝对值。

BigIntegeradd​(BigInteger val)

返回一个值为 (this + val)的BigInteger。

BigIntegerand​(BigInteger val)

返回值为 (this & val)的BigInteger。

BigIntegerandNot​(BigInteger val)

返回值为 (this & ~val)的BigInteger。

intbitCount()

返回此BigInteger的二进制补码表示中与其符号位不同的位数。

intbitLength()

返回此BigInteger的最小二进制补码表示中的位数， 不包括符号位。

bytebyteValueExact()

将 BigInteger转换为 byte ，检查是否丢失了信息。

BigIntegerclearBit​(int n)

返回一个BigInteger，其值等于此BigInteger且指定位已清除。

intcompareTo​(BigInteger val)

将此BigInteger与指定的BigInteger进行比较。

BigIntegerdivide​(BigInteger val)

返回值为 (this / val)的BigInteger。

BigInteger[]divideAndRemainder​(BigInteger val)

返回两个BigIntegers的数组，其中包含 (this / val)后跟 (this % val) 。

doubledoubleValue()

将此BigInteger转换为 double 。

booleanequals​(Object x)

将此BigInteger与指定的Object进行相等性比较。

BigIntegerflipBit​(int n)

返回一个BigInteger，其值等于此BigInteger，并且指定的位被翻转。

floatfloatValue()

将此BigInteger转换为 float 。

BigIntegergcd​(BigInteger val)

返回一个BigInteger，其值是 abs(this)和 abs(val) 。

intgetLowestSetBit()

返回此BigInteger中最右边（最低位）一位的索引（最右边一位右边的零位数）。

inthashCode()

返回此BigInteger的哈希码。

intintValue()

将此BigInteger转换为 int 。

intintValueExact()

将此 BigInteger转换为 int ，检查是否丢失了信息。

booleanisProbablePrime​(int certainty)

返回 true如果此BigInteger可能为素数， false ，如果它一定为合。

longlongValue()

将此BigInteger转换为 long 。

longlongValueExact()

将此 BigInteger转换为 long ，检查是否丢失了信息。

BigIntegermax​(BigInteger val)

返回此BigInteger和 val 。

BigIntegermin​(BigInteger val)

返回此BigInteger和 val 。

BigIntegermod​(BigInteger m)

返回一个值为 (this mod m的BigInteger。

BigIntegermodInverse​(BigInteger m)

返回BigInteger，其值为 (this -1 mod m) 。

BigIntegermodPow​(BigInteger exponent, BigInteger m)

返回一个值为 (thisexponent mod m)的BigInteger。

BigIntegermultiply​(BigInteger val)

返回值为 (this * val)的BigInteger。

BigIntegernegate()

返回值为 (-this)的BigInteger。

BigIntegernextProbablePrime()

返回大于此 BigInteger的第一个整数，该整数可能是素数。

BigIntegernot()

返回一个值为 (~this)的BigInteger。

BigIntegeror​(BigInteger val)

返回一个值为 (this | val)的BigInteger。

BigIntegerpow​(int exponent)

返回值为 (thisexponent)的BigInteger。

static BigIntegerprobablePrime​(int bitLength, Random rnd)

使用指定的bitLength返回可能为素数的正BigInteger。

BigIntegerremainder​(BigInteger val)

返回一个值为 (this % val)的BigInteger。

BigIntegersetBit​(int n)

返回一个BigInteger，其值等于此BigInteger并设置了指定的位。

BigIntegershiftLeft​(int n)

返回值为 (this << n)的BigInteger。

BigIntegershiftRight​(int n)

返回值为 (this >> n)的BigInteger。

shortshortValueExact()

将此 BigInteger转换为 short ，检查是否丢失了信息。

intsignum()

返回此BigInteger的signum函数。

BigIntegersqrt()

返回此BigInteger的整数平方根。

BigInteger[]sqrtAndRemainder()

返回两个BigIntegers的数组，其中包含 s的整数平方根 this及其余部分 this - s*s 。

BigIntegersubtract​(BigInteger val)

返回值为 (this - val)的BigInteger。

booleantestBit​(int n)

当且仅当指定位置位时，返回 true 。

byte[]toByteArray()

返回一个包含此BigInteger的二进制补码表示的字节数组。

StringtoString()

返回此BigInteger的十进制String表示形式。

StringtoString​(int radix)

返回给定基数中此BigInteger的String表示形式。

static BigIntegervalueOf​(long val)

返回一个BigInteger，其值等于指定的 long 。

BigIntegerxor​(BigInteger val)

返回值为 (this ^ val)的BigInteger。

import java.math.BigInteger;
import java.util.Scanner;


public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        String a=Integer.toString(n);
        BigInteger big=new BigInteger(a);
        int b=0;
        for (int i = n-1; i >0; i--) {
            big=big.multiply(new BigInteger(Integer.toString(i)));
        }
        System.out.println(big);
    }
    
}

十二、高精度加法（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。

算法描述

　　由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
　　定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
　　计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
　　最后将C输出即可。

输入格式

　　输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。

输出格式

　　输出一行，表示a + b的值。

样例输入

20100122201001221234567890
2010012220100122

样例输出

20100122203011233454668012

import javax.sound.midi.Soundbank;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String a=in.next();
        String b=in.next();
        BigInteger big1=new BigInteger(a);
        BigInteger big2=new BigInteger(b);
        System.out.println(big1.add(big2));
    }
}

十三、矩阵乘法（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
　　例如：
　　A =
　　1 2
　　3 4
　　A的2次幂
　　7 10
　　15 22

输入格式

　　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
　　接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值

输出格式

　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开

样例输入

2 2
1 2
3 4

样例输出

7 10
15 22

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int m=in.nextInt();
        int[][] a=new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                a[i][i1]=in.nextInt();
            }
        }
        if(m==0)
        {
            for (int i = 0; i < n; i++) {
                for (int i1 = 0; i1 < n; i1++) {
                    if(i1==i)
                        System.out.print(1+" ");
                    else
                        System.out.print(0+" ");
                }
                System.out.println();
            }
            return;
        }
        int[][] res=a;
        for (int i = 1; i < m; i++) {
            res=getMatrix(a,res);
        }
        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                System.out.print(res[i][i1]+" ");
            }
            System.out.println();
        }
    }
    static int[][] getMatrix(int[][] a,int[][] res)
    {
        int n=a.length;
        int[][] b=new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int i1 = 0; i1 < n; i1++) {
                for (int i2 = 0; i2 < n; i2++) {
                    b[i][i1]+=a[i][i2]*res[i2][i1];
                }
            }
        }
        return b;
    }
}

十四、字符串对比（vip）

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一：
　　1：两个字符串长度不等。比如 Beijing 和 Hebei
　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing
　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing
　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing
　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

输入格式

　　包括两行，每行都是一个字符串

输出格式

　　仅有一个数字，表明这两个字符串的关系编号

样例输入

BEIjing

beiJing

样例输出

3

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

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String str=in.next();
        String str1=in.next();
        System.out.println(Judge(str,str1));
    }
    static int Judge(String str,String str1)
    {
        if(str.length()!=str1.length())
            return 1;
        if(str.equals(str1))
            return 2;
        if(str.toLowerCase().equals(str1.toLowerCase()))
            return 3;
        return 4;

    }
}

十五、时间转换

资源限制

内存限制：512.0MB   C/C++时间限制：1.0s   Java时间限制：3.0s   Python时间限制：5.0s

问题描述

　　给定一个以秒为单位的时间t，要求用“<H>:<M>:<S>”的格式来表示这个时间。<H>表示时间，<M>表示分钟，而<S>表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。

输入格式

　　输入只有一行，是一个整数t（0<=t<=86399）。

输出格式

　　输出只有一行，是以“<H>:<M>:<S>”的格式所表示的时间，不包括引号。

样例输入

0

样例输出

0:0:0

样例输入

5436

样例输出

1:30:36


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int t=in.nextInt();
        int h=t/3600;
        int m=t/60%60;
        int s=t%60;
        System.out.println(h+":"+m+":"+s);
    }
}

第五届蓝桥杯——基础练习：数列排序
爱音乐，爱编程。
12-24 7005
问题描述 　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1 输入格式 　　第一行为一个整数n。 　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 输出格式 　　输出一行，按从小到大的顺序输出排序后的数列。 样例输入 5 8 3 6 4 9 样例输出 3 4 6 8 9 问题程序 import java
java蓝桥杯 试题-基础练习-数列排序
qq_coding的博客
01-02 259
试题-基础练习-数列排序 题目 问题描述 　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200 输入格式 　　第一行为一个整数n。 　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。 输出格式 　　输出一行，按从小到大的顺序输出排序后的数列。 样例输入 5 8 3 6 4 9 样例输出 3 4 6 8 9 代码 冒泡排序：外层n-1；内层n-i-1 记得关闭Scanner package other.lanqiao.practiceBase; im
蓝桥杯 数字判定 Java实现
weixin_46110492的博客
07-11 148
算法训练 判定数字 时间限制：1.0s 内存限制：512.0MB 　　编写函数，判断某个给定字符是否为数字。 样例输入 9 样例输出 yes 代码： ———————————————————————— import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner sc=new Scanner(System.in); String str=sc.next(); char[]a=str.
蓝桥杯（Java）注意事项
热门推荐
哈哈er的博客
02-25 2万+
蓝桥杯Java注意事项 常用技巧 输入输出 字符串操作 Java数组基本操作 数据格式化 eclipse快捷键 编程技巧 蓝桥杯Java注意事项 类名称必须采用public class Main方式命名 整数之间的运算为整数。 int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1），一个字节占8位，也就是32位。 所...
蓝桥杯—对局匹配（JAVA实现）
学海无涯乐作舟
03-24 1004
文章目录一、题目二、解题思路三、代码实现 一、题目 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 　　小明喜欢在一个围棋网站上找别人在线对弈。这个网站上所有注册用户都有一个积分，代表他的围棋水平。 小明发现网站的自动对局系统在匹配对手时，只会将积分差恰好是K的两名用户匹配在一起。如果两人分差小于或大于K，系统都不会将他们匹配。 现在小明知道这个网站总共有N名用户，以及他们的...
Java实现蓝桥杯历届试题买不到的数目
06-04 5536
历届试题 买不到的数目 时间限制：1.0s 内存限制：256.0MB 提交此题 锦囊1 锦囊2 问题描述 小明开...
蓝桥杯java-试题 基础练习 回文数
运气不好努力来凑的博客
07-26 160
package 特殊回文数; import java.util.Scanner; public class Main { public static void f(int n) { 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;..
蓝桥杯java-试题 基础练习 闰年判断
运气不好努力来凑的博客
07-26 143
package 闰年判断; import java.util.Scanner; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub //1.输入年份 Scanner sc=new Scanner(System.in); int year=sc.nextInt(); int flag=0; //2.判断+3.输出 if.
蓝桥杯练习系统java-基础练习-BASIC2-01字串
Diana_Lyt的博客
01-30 219
蓝桥杯练习系统java-基础练习-BASIC2-01字串
蓝桥杯介绍-参加比赛心得-往年试题-相关练习-蓝桥杯-计算机-比赛-算法竞赛
01-20
比赛涵盖多个领域，包括C/C++程序设计、Java程序设计、Python程序设计、嵌入式系统开发、网页设计与制作以及信息安全技术等，通过机试形式考核参赛者的编程能力和解决问题的能力。 参加蓝桥杯，提前准备至关重要。...
蓝桥杯c++-蓝桥杯竞赛练习之算法提高题一元一次方程.zip
04-13
在本资源包“蓝桥杯c++-蓝桥杯竞赛练习之算法提高题一元一次方程.zip”中，主要涉及的是C++编程语言在解决蓝桥杯竞赛中的算法问题，特别是针对一元一次方程的求解。一元一次方程是数学中的基本概念，而在编程竞赛中...
java蓝桥杯 试题-基础练习-十六进制转八进制
qq_coding的博客
01-03 226
试题-基础练习-十六进制转八进制 题目 试题 基础练习 十六进制转八进制 资源限制 时间限制：1.0s 内存限制：512.0MB 问题描述 　　给定n个十六进制正整数，输出它们对应的八进制数。 输入格式 　　输入的第一行为一个正整数n （1<=n<=10）。 　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。 输出格式 　　输出n行，每行为输入对应的八进制正整数。 【注意】 　　输入的十六进制数不会有前导0，比如012
**蓝桥杯--试题 基础练习 字母图形**
weixin_44035979的博客
08-27 361
蓝桥杯–试题 基础练习 字母图形 资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 利用字母可以组成一些美丽的图形，下面给出了一个例子： ABCDEFG BABCDEF CBABCDE DCBABCD EDCBABC 这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。 输入格式 输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。 输出格式 输出n行，每个m个字符，为你的图形。 样例输入 5 7 样例输出 ABCDEFG BABCDEF CBABCDE
(蓝桥杯C/C++)——搜索
2402_82385099的博客
11-09 628
就是将搜索过程中会重复计算且结果相同的部分保存下来，作为一个状态，下次访问到这个状态时直接将这个子搜索的结果返回，而不需要再重新算一遍。通常会使用数组或map来进行记忆化，下标一般和dfs的参数表对应。注意使用记忆化需要保证重复计算的结果是相同的，否则可能产生数据失真。其实就是将搜索过程当中一些不必要的部分直接剔除掉，因为搜索过程构成了一棵树，剔除不必要的部分，就像是在树上将树枝剪掉，故名剪枝。
蓝桥杯 Python组-神奇闹钟（datetime库）
AuRoRamth的博客
11-05 1247
传送门： 0神奇闹钟 - 蓝桥云课​​​​​​小蓝发现了一个神奇的闹钟，从纪元时间（1970 年 11 日 00：00：00）开始，每经过 x 分钟，这个闹钟便会触发一次闹铃 (纪元时间也会响铃)。这引起了小蓝的兴趣，他想要好好研究下这个闹钟。对于给出的任意一个格式为 уууу-MM-ddHH:mm:ss 的时间，小蓝想要知道在这个时间点之前 (包含这个时间点) 的最近的一次闹铃时间是哪个时间?注意，你不必考虑时区问题。输入格式输入的第一行包含一个整数 T，表示每次输入包含 T 组数据。接下来依次描述
蓝桥杯第二十场小白入门赛
m0_73924943的博客
10-26 1010
用数学思维来分析：设k*k区间中分别有a行，b列被选中，即长度为n的字符串中有a个1，长度为m的字符串中有b个1。最后看了看别人的和我相似的思路，才发现原来自己思路有漏洞，我把可能情况分两部分，一是两个目标地点在同一侧，二是不在同一侧。查看了测试用例后，我才明白，可能茶壶容量远小于一杯茶的容量，也就是说，你要倒满一杯茶，需要接好几次水壶，而我的代码中循环一次res最多也加一。后果就是，对于这类测试用例，我的循环结束了，我的sum还远远小于0，还没加成正值。我的思路代码：（但我不知道哪有错误）
蓝桥杯 懒洋洋字符串--字符串读入
2401_82736456的博客
11-08 334
题目 代码 #include <iostream> using namespace std; int main() { int n; cin>>n; char s[210][4]; int ans=0; for(int i=0;i<n;i++){ scanf("%s",s[i]); } for(int i=0;i<n;i++){ char a=s[i][0]; char b=s[i][
(蓝桥杯C/C++)——动态规划(DP)
最新发布
2402_82385099的博客
11-09 394
DP(动态规划)全称DynamicProgramming，是运筹学的一个分支，是一种将复杂问题分解成很多重叠的子问题，并通过子问题的解得到整个问题的解的算法。在动态规划中有一些概念:状态:就是形如dp[il[il=val的取值，其中i，i为下标，也是用于描述、确定状态所需的变量,val为状态值。状态与状态之间的转移关系，一般可以表示为一个数学表达式，转移方向决迭代或递归方向。也就是题目所求的状态，最后的答案。
第十五届蓝桥杯C/C++B组题解——数字接龙
weixin_73378557的博客
11-07 1108
小蓝最近迷上了一款名为《数字接龙》的迷宫游戏，游戏在一个大小为N × N 的格子棋盘上展开，其中每一个格子处都有着一个 0 . . . K − 1 之间的整数。游戏规则如下：从左上角 (0, 0) 处出发，目标是到达右下角 (N − 1, N − 1) 处的格子，每一步可以选择沿着水平/垂直/对角线方向移动到下一个格子。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值