【蓝桥】做题笔记及心得总结（基础篇）

最新推荐文章于 2022-07-06 16:39:05 发布

心中有光，不惧路长

最新推荐文章于 2022-07-06 16:39:05 发布

阅读量709

点赞数

分类专栏：笔记数据结构与算法 java入门文章标签：蓝桥杯 java 数据结构

本文链接：https://blog.csdn.net/julia_xueli/article/details/122577503

版权

笔记同时被 3 个专栏收录

37 篇文章 0 订阅

订阅专栏

数据结构与算法

20 篇文章 0 订阅

订阅专栏

java入门

16 篇文章 0 订阅

订阅专栏

基础题

类型1：考察数据类型方面的应用

题目1：

时间限制：1.0s 内存限制：512.0MB

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

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

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

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

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

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

解决关键代码：

BigInteger num=new BigInteger(arr[i],16);

改进原因：题目要求：
$每个十六进制数长度不超过 100000 。$
这是个很大的数，光用int容易造成溢出。

完整代码：

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

public class Main {
    public static void main(String[] args) {

        Scanner s=new Scanner(System.in);
        int N=s.nextInt();
        String [] arr=new String [N];
        String [] goalarr=new String [N];

        for (int i = 0; i < N; i++) {
            arr[i]=s.next();
            BigInteger num=new BigInteger(arr[i],16);
            goalarr[i]=num.toString(8);
        }
        for (int i = 0; i <N ; i++) {
            System.out.println(goalarr[i]);
        }
        }
    }

类题1：

问题描述

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

样例输入

FFFF

样例输出

65535

解决关键代码

long goal=Long.parseLong(string,16);

将字符串以16进制的方式解析为long类型整数

类题2：十进制转十六进制

解决关键代码：

long orinum=Long.parseLong(string,10);//得到十进制数
String goal=Long.toHexString(orinum).toUpperCase();//转为16进制字符串，字母转换为大写格式

还是要注意数据类型范围的问题

类题3：序列求和题，但是输入n的数据规模约定为1 <= n <= 1,000,000,000

注意：这题n和输出结果的数据类型必须设为可表示数据范围比int大的（如Long）！否则d当n较大时评测无法通过。

题解

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Long n = s.nextLong();
        System.out.println((long)(((1+n)*n)/2));
    }
}

类题4：阶乘计算（非递归解法）

要注意的点是给定的n可能会很大，要注意数据类型的选取（我选BigInteger)

题解：

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

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        Long n = s.nextLong();
 //阶乘，数据可能很大
        //BigInteger 
        BigInteger goal=new BigInteger("1");
        while(n>0){
            goal=goal.multiply(new BigInteger(n.toString()));
            n--;
        }
        System.out.println(goal);
    }
}

类题5：输入整数n,求圆的面积，要求输出结果保留小数点后七位

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        double tmp=Math.PI*n*n;
        String result=String.format("%.7f",tmp);
        System.out.println(result);
    }
}

类型1总结：

对数据结构类型、范围要有足够的重视。
java是面向对象的语言，有现成的函数及功能以供使用。要学会转换思维，不需要什么实现细节都亲力亲为，对一些简单的题目尤其如此，能调包就调包，能用现成函数就不要自己写一遍。毕竟评测系统看的是结果，比赛追求效率。

类型2：回文数类的问题

题目：判断回文数，并要求该回文数的各位数之和为输入的数字n

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

    Scanner s=new Scanner(System.in);
    int num=s.nextInt();
        for (int i = 10000; i <999999 ; i++) {
            int sum=0;int tmp=i;
            while(tmp>0){
                sum+=tmp%10;//个十百千万顺序
                tmp=tmp/10;
            }
            if(sum==num){//满足位数之和的要求，再来判断是否为回文数
                String s1=Integer.toString(i);
                String s2=new StringBuffer(s1).reverse().toString();
                if(s2.equals(s1))
                System.out.println(i);
            }
        }

        }


}

类题1 ：求出所有四位十进制回文数

public class Main {
    public static void main(String[] args) {
        for (int i = 1000; i <=9999; i++) {
                String s1 = Integer.toString(i);
                String s2 = new StringBuffer(s1).reverse().toString();
                if (s2.equals(s1))
                    System.out.println(i);
        }
    }
}

注：循环条件不要漏掉“=”！！！否则9999将无法输出从而导致结果错误！！！

思路：对回文数的判断有两种常见思路。1是用求余的方法解析数字，得到各个位数，但是个人感觉比较麻烦，如果不是因为要求和，我不会用这种方法；二是转换为字符串进行处理，如可以直接通过判断倒置后的字符串是否与原来相等得到。

类题2：完美的代价

问题描述

回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
　　交换的定义是：交换两个相邻的字符
　　例如mamad
　　第一次交换 ad : mamda
　　第二次交换 md : madma
　　第三次交换 ma : madam (回文！完美！)

输入格式

第一行是一个整数N，表示接下来的字符串的长度(N <= 8000)
　　第二行是一个字符串，长度为N.只包含小写字母

输出格式

如果可能，输出最少的交换次数。
　　否则输出Impossible

样例输入

5
mamad

样例输出

3

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int len = s.nextInt();
        String string = s.next();
        char[] arr = string.toCharArray();
        char tmp;
        int count = 0;
        int n = len - 1;
        int flag = 0;

        for (int i = 0; i < n; i++) {//从前往后直到倒数第二个字符
            for (int j = n; j >= i; j--) {//从后往前直到与i重合
                if (j == i) {//没有找到与a[i]相同的字符，即a[i]是特殊的孤立值，如果仅此一个，可移动它到中间实现回文
                    if (flag == 1 || len % 2 == 0) {
                        System.out.println("Impossible");
                        System.exit(0);
                    }
                    flag = 1;
                    count += len / 2 - i;
                } else if (arr[i] == arr[j]) {
                    for (int k = j; k < n; k++) {
                        swap(arr, k, k + 1);
                        count++;
                    }
                    n--;
                    break;
                }
            }
        }
        System.out.println(count);
    }

    public static void swap(char[] arr, int a, int b) {
        char tmp;
        tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
    }
}

注：这题我是将网上c++大佬的解法换成Java格式。我自己原本的想法是每次都用字符串逆置的方式判断回文。但是我没办法想出移动的规律以及相对应的移动次数。

我觉得这道题的本质不在回文判断，而在于这个最少移动的方式（贪婪算法）的实现。

类型3：特殊数字

题目1：输出所有三位的水仙花数

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                for (int k = 0; k <10 ; k++) {
                    if((i*100+j*10+k)==(i*i*i+j*j*j+k*k*k))
                        if((i*100+j*10+k)!=0&&(i*100+j*10+k)!=1)
                        System.out.println(i*100+j*10+k);
                }
            }
        }
    }
}

(碎碎念：其实这种写法算不上什么优解，我只是为了快点过评测，还有if那里如果不介意看着乱的话，可以把判断条件都合在一处）

类题1：分解质因数

问题描述

求出区间[a,b]中所有整数的质因数分解。

输入格式

输入两个整数a，b。

输出格式

每行输出一个数的分解，形如k=a1a2a3…(a1<=a2<=a3…，k也是从小到大的)(具体可看样例)

样例输入

3 10

样例输出

3=3
4=22
5=5
6=23
7=7
8=222
9=33
10=25

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int m = s.nextInt();
        int n = s.nextInt();
        for (int i = m; i <= n; i++) {
            System.out.print(i + "=");
            int t = i;//记录i的数字，内循环不能直接用i，否则会有逻辑错误
            for (int j = 2; j <= t; ) {
                if (j == t) {
                    System.out.println(j);
                    break;
                } else if (t % j == 0) {
                    System.out.print(j + "*");
                    t /= j;
                } else j++;
            }
        }
    }
}

类型4：二维数组

题目1：杨辉三角

问题描述

杨辉三角形又称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

题解：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int N=s.nextInt()+1;
 int [][] arr=new int [N][N];
 arr[0][1]=0;
        for (int i = 0; i <N-1 ; i++) {
            arr[i][0]=1;
            arr[i][i]=1;
            for (int j = 1; j <N; j++) {
                arr[i+1][j]=arr[i][j-1]+arr[i][j];
            }
        }//赋值过程

        for (int i = 0; i < N-1; i++) {
            for (int j = 0; j <=i; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }//输出过程，只输出数组下半部分
    }
}

一些体悟：刷题的策略分两种，一种是平时练习，一种是比赛应试。

像杨辉三角的概念，上过中学的人应该都对它不陌生。但是将来可能会遇到很多听都没听过的模型题。

如果是平时练习，遇到了不熟悉的概念、领域，可以多去网上查阅与这个概念相关的知识点，就当是开拓视野（比如我看到网上有利用杨辉三角的其他性质来写的题解）；

但如果是比赛或者应试，心态非常关键。遇到不熟悉的概念时，临场应变、阅读理解、建模分析的能力非常重要。哪怕你不懂这是什么（事实上也可以不懂），你只需要抓住输入输出两条线，抓住问题的实质并且将它与自己接触过的模型（或算法或数据结构）一一对应起来，问题就可以解决了。

类题1：

问题描述

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

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

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

输入格式

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

输出格式

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

样例输入

5 7

样例输出

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

分析：二维数组，对角线上的元素都是A；对每个A 往下、往右依次按字母表顺序递增

java中ASCII码与字符的转换相当简单！（比javascript简单）只需要进行强制类型转换！

如
```
public class pra {
    public static void main(String[] args) {
        char A='A';
        System.out.println((char)(A+1));
    }

}
```
输出结果会是B

我一开始的提交代码:

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int M = s.nextInt();
        char[][] arr = new char[N][M];
        for (int i = 0; i < N; i++) {
            arr[i][i] = 'A';//对角线上的元素赋值为A
         int tmpj=i;
         int countj=0;
            while(tmpj<M){
                arr[i][tmpj]=(char)('A'+countj);
                countj++;
                tmpj++;
            }//向右赋值
            int tmpi=i;
            int counti=0;
            while(tmpi<N){
                arr[tmpi][i]=(char)('A'+counti);
                counti++;
                tmpi++;
            }//向下赋值
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}

这段代码在本地ide输入给出的样例输入时运行正常，但到了测评平台却显示有问题。

我查看了输出异常的三个测试样例，发现是当行数>列数时会发生溢出

后来加入了以下修改，即分情况讨论

int e=0;
if(N<=M) e=N;
 else e=M;

初始化对角线的for循环也相应改成了：

for (int i = 0; i < e; i++)

最终通过了评测。完整代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int M = s.nextInt();
        char[][] arr = new char[N][M];
        int e = 0;

        if (N <= M) e = N;
        else e = M;

        for (int i = 0; i < e; i++) {
            arr[i][i] = 'A';//对角线上的元素赋值为A
            int tmpj = i;
            int countj = 0;
            while (tmpj < M) {
                arr[i][tmpj] = (char) ('A' + countj);
                countj++;
                tmpj++;
            }//向右赋值
            int tmpi = i;
            int counti = 0;
            while (tmpi < N) {
                arr[tmpi][i] = (char) ('A' + counti);
                counti++;
                tmpi++;
            }//向下赋值
        }

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}

类题2：芯片测试

问题描述

有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
　　每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
　　给出所有芯片的测试结果，问哪些芯片是好芯片。

输入格式

输入数据第一行为一个整数n，表示芯片个数。
　　第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。

输出格式

按从小到大的顺序输出所有好芯片的编号

样例输入

3
1 0 1
0 1 0
1 0 1

样例输出

1 3

思路:用二维数组存储芯片检测数据；先想办法确定其中一块好芯片；最后将这个好芯片判断为好芯片的芯片编号输出

如何确定呢？这要用到一点概率知识。按照题目所说，“已知好芯片比坏芯片多”，也就是如果某一块芯片是好芯片，那么其他芯片判定它为好芯片的次数一定大于或等于判定ta为坏芯片的次数。（因为其他芯片大多都是好芯片，坏芯片对它的误判率也只是一半）

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int[][] arr = new int[N][N];
        //将芯片评测数据读入二维数组
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                arr[i][j] = s.nextInt();
            }
        }
        //找到第一片好芯片
        int goodloc = -1;//虽然题目假定一定会有好芯片，不过以防万一
        for (int i = 0; i < N; i++) {
            int tmpj = 0;
            int truecount = 0;
            int falsecount = 0;
            while (tmpj < N) {
                if (arr[i][tmpj] == 1) truecount++;
                if (arr[i][tmpj] == 0) falsecount++;

                tmpj++;
            }
            if (truecount >= falsecount) {
                goodloc = i;//好芯片的下标是i，标号是i+1
                break;//找到一片就可以了
            }

        }

        //利用这块好芯片去找其他好芯片
        if (goodloc == -1) System.out.println("error!can not find a good");
        else {
            for (int i = 0; i < N; i++) {
                if (arr[goodloc][i] == 1) {
                    System.out.print(i + 1 + " ");//同理，好芯片的下标是i，标号是i+1
                }
            }
        }
    }


}

类题3：回形取数

问题描述

回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。

输入格式

输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。

输出格式

输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。

思路：由题意可知，读数路径相当于一个方形花卷，一开始向下走是j不变，i增加；当i=m-1时，i不再变化，j递增（转弯）；之后i递减，j不变（转弯）；再之后j递减，i不变（转弯）；当j+1回到最初位置时，花卷的边长要减一（进入内层），以此类推……

先贴上我倒数第二稿的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int m = s.nextInt();
        int n = s.nextInt();
        int[][] a = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = s.nextInt();
            }
        }

        int count = m * n;//表示总点数，递减，为0时说明所有点均已访问完
        int circle = 0;//表示已走完的圈数，每绕完一圈，横纵坐标都要相应改变
        int i = 0, j = 0;
        while (count != 0) {
            //每次的新起始点都在新圈的左上角
            while (i < m - circle) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                i++;//向下
                count--;
            }
            i--;//解决数组越界问题

            j++;//为向右走做准备
            while (j < n - circle) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                j++;//向右
                count--;
            }
            j--;//解决数组越界问题

            i--;//为向上走做准备
            while (i >= circle) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                i--;//向右
                count--;
            }
            i++;//解决数组越界问题

            j--;//为向左走做准备
            while (j > circle) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                j--;//向左
                count--;
            }
            j++;//解决数组越界问题
            i++;//进入新一圈，新的下标
            circle++;
        }
    }

}

这次只过了60%的评测样例。

没过的样例都是行数与列数不等。

光是看评测平台上的输入输出数据没发现什么问题，感觉都是符合的，但是在本地IDE上跑的时候发现多打印了一些数，也导致了数组越界，这说明计数功能count失效了。

究其原因，我发现是代码逻辑出了问题。里层的四个while中，就算count被清零，程序仍然会进入后续的while。

因此解决的方法是：给里层每个while的判断条件都加上“&&(count>0)”

虽然看上去很多余，但是实际操作就会发现这样的逻辑才是正确的。

最终通关的完整代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int m = s.nextInt();
        int n = s.nextInt();
        int[][] a = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = s.nextInt();
            }
        }

        int count = m * n;//表示总点数，递减，为0时说明所有点均已访问完
        int circle = 0;//表示已走完的圈数，每绕完一圈，横纵坐标都要相应改变
        int i = 0, j = 0;
        while (count > 0) {
            //每次的新起始点都在新圈的左上角
            while ((i < m - circle) && (count > 0)) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                i++;//向下
                count--;
            }
            i--;//解决数组越界问题

            j++;//为向右走做准备
            while ((j < n - circle) && (count > 0)) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                j++;//向右
                count--;
            }
            j--;//解决数组越界问题

            i--;//为向上走做准备
            while ((i >= circle) && (count > 0)) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                i--;//向右
                count--;
            }
            i++;//解决数组越界问题

            j--;//为向左走做准备
            while ((j > circle) && (count > 0)) {
                System.out.print(a[i][j]);
                System.out.print(" ");
                j--;//向左
                count--;
            }
            j++;//解决数组越界问题
            i++;//进入新一圈，新的下标
            circle++;
        }
    }
}

类题4：求N阶矩阵的M次幂

第一行输入两个参数，分别为矩阵的阶N与将要进行的M次幂运算

接下来的几行，是矩阵的数值

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();//阶数
        int M = s.nextInt();//幂数
        int[][] a = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                a[i][j] = s.nextInt();
            }
        }

        if (M > 1) {//中间三个for为矩阵相乘核心代码，最外层for解决幂次问题
            int[][] c = a;//不要忘记把c初始为a

            for (int m = 1; m < M; m++) {
                int[][] tmp = new int[N][N];
                for (int i = 0; i < N; i++) {
                    for (int j = 0; j < N; j++) {

                        for (int k = 0; k < N; k++) {
                            tmp[i][j] += a[i][k] * c[k][j];
                        }
                    }
                }
                c = tmp;
            }
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    System.out.print(c[i][j]);
                    System.out.print(" ");
                }
                System.out.println();
            }
        } else if (M == 0) {
            //打印单位矩阵
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (i == j) {
                        System.out.print(1);
                        System.out.print(" ");
                    } else {
                        System.out.print(0);
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        } else if (M == 1) {
            //打印A本身
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    System.out.print(a[i][j]);
                    System.out.print(" ");
                }
                System.out.println();
            }
        } else {
            System.out.println("M必须大于等于0！");
        }
    }
}

解题过程中踩的坑已经标注在注释里了，就不详细说了。

类型5：一维数组

题目1：

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

输入格式

第一行包含一个整数n。

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

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

输出格式

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

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int[] arr = new int[N];

        for (int i = 0; i < N; i++) {
            arr[i] = s.nextInt();
        }//读取数据并存入数组
        int goalnum = s.nextInt();
        boolean flag = false;
        for (int i = 0; i < N; i++) {
            if (arr[i] == goalnum) {
                System.out.println(i + 1);
                flag = true;
                break;
            }
        }
        if (flag == false)
            System.out.println(-1);
    }
}

类题1：输出给定一串数的最大值、最小值、和

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int N = s.nextInt();
        int[] arr = new int[N];

        for (int i = 0; i < N; i++) {
            arr[i] = s.nextInt();
        }//读取数据并存入数组
        int max=arr[0];
        int min=arr[0];
        int sum=0;
        for (int i = 0; i <N ; i++) {
            if(arr[i]>=max) max=arr[i];
            if(arr[i]<=min) min=arr[i];
            sum+=arr[i];
        }
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
    }
}

类题2：报时助手

问题描述

给定当前的时间，请用英文的读法将它读出来。
　　时间用时h和分m表示，在英文的读法中，读一个时间的方法是：
　　如果m为0，则将时读出来，然后加上“o’clock”，如3:00读作“three o’clock”。
　　如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。
　　时和分的读法使用的是英文数字的读法

样例输入

0 15

样例输出

zero fifteen

思路：这题需要用到的知识点有：条件判断（这里if else 即可）；创建一个长度为60的一维字符串数组（下标加1为数字，单个元素为数字对应的字母）

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int h = s.nextInt();
int m=s.nextInt();
String [] a={"zero","one","two","three","four","five","six","seven","eight","nine","ten",
        "eleven","twelve","thirteen","fourteen","fifteen","sixteen" ,"seventeen","eighteen","nineteen","twenty",
        "twenty one","twenty two","twenty three","twenty four","twenty five","twenty six","twenty seven","twenty eight","twenty nine","thirty",
        "thirty one","thirty two","thirty three","thirty four","thirty five","thirty six","thirty seven","thirty eight","thirty nine","forty",
        "forty one","forty two","forty three","forty four","forty five", "forty six","forty seven","forty eight","forty nine","fifty",
       "fifty one","fifty two","fifty three","fifty four","fifty five","fifty six","fifty seven","fifty eight","fifty nine","sixty"};
if(m==0){
    System.out.println(a[h]+" o'clock");
}
else{
    System.out.println(a[h]+" "+a[m]);
}
    }
}

类型6：字符串处理

题目1：

问题描述

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

00000

00001

00010

00011

00100

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

输入格式

本试题没有输入。

输出格式

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

题解：

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i <32 ; i++) {
            String tmp=Integer.toBinaryString(i);

            //接下来要解决补零问题
            int len=tmp.length();
            while(len<5) {
                tmp ="0"+tmp;
                len++;
            }
            System.out.println(tmp);
        }
    }
}

一点感受：

做这道题时我首先想到的就是对输出0到31数字的二进制表示字符串（for循环遍历，toBinaryString()方法）；

但是首次在本地IDE运行之后发现无法补全位数0。

对此，我一开始想用String.format(%is,string)的方法，（因为总共m个数，当前字符串长度为n，则需要补0的个数为m-n）。

但是，发现%后面跟的不是一个确切数字好像不行？也有可能是代码逻辑有误？（比如五位数时我不需要补0，但是我需要输出啊，输出0个空格是来搞笑的？）

然而，不要在一棵树上吊死，我选择里面再加个循环直接手动加0，好像还更方便跟容易理解一些。

类题1：字符串对比

问题描述

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

思路：if-else条件判断，可以考虑简化代码逻辑，不必完全按照题目给定的顺序

题解：

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

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String string1 = s.next();
        String string2 = s.next();
        if (string1.equals(string2)) System.out.println(2);
        else if ((string1.length()) != (string2.length())) System.out.println(1);
        else {
            if (string1.toLowerCase().equals(string2.toLowerCase())) System.out.println(3);
            else System.out.println(4);
        }
    }
}

类题2：FJ的字符串

问题描述

FJ在沙盘上写了这样一些字符串：
　　A1 = “A”
　　A2 = “ABA”
　　A3 = “ABACABA”
　　A4 = “ABACABADABACABA”
　　… …
　　你能找出其中的规律并写所有的数列AN吗？

输入格式

仅有一个数：N ≤ 26。

输出格式

请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。

样例输入

样例输出

ABACABA

分析：生成的字符串是回文；输入的数字n为字符串中出现的字母种类的个数；字母A的个数为2^(n-1)

思路1：先生成长度为2^(n-1)的全A字符串，后面再逐个插入其他字符（但是在我发现好像要手动分前后两段的时候我放弃了，感觉没必要搞得这么复杂）

思路2：递归法（牺牲一点资源，但是胜在代码简单）

从中间开始，递归地打印两边

贴上思路2的代码吧：

import java.util.Scanner;

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

    public static void FJprint(int n) {
        if (n == 1) System.out.print('A');
        else {
            FJprint(n - 1);
            System.out.print((char) ('A' + n - 1));
            FJprint(n - 1);
        }
    }
}

类题3：数的读法

你的任务是设计这样一个系统：给定一个阿拉伯数字串，按照中文读写的规范转为汉语拼音字串，相邻的两个音节用一个空格符格开。
　　注意必须严格按照规范，比如说“10010”读作“yi wan ling yi shi”而不是“yi wan ling shi”，“100000”读作“shi wan”而不是“yi shi wan”，“2000”读作“er qian”而不是“liang qian”。

输入格式

有一个数字串，数值大小不超过2,000,000,000。

输出格式

是一个由小写英文字母，逗号和空格组成的字符串，表示该数的英文读法。

样例输入

1234567009

样例输出

shi er yi san qian si bai wu shi liu wan qi qian ling jiu

题解：郑重声明：本代码只保证过得了蓝桥杯评测系统上的测试样例，并不保证对所有数都适用（因为不知道有没有被我漏掉的情况，还请大佬们指正）

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String string = s.next();
        int len = string.length();
        char[] arr = string.toCharArray();
        String[] sig = {"", "yi", "er", "san", "si", "wu", "liu", "qi", "ba", "jiu"};
        String[] wei = {"", "shi", "bai", "qian", "wan", "shi", "bai", "qian", "yi", "shi"};
        for (int i = 0; i < len; i++) {
            if ((arr[i] == '0') && (i < len - 1)) {//处理后面几个都是0的情况
                if (arr[i + 1] != '0') {
                    System.out.print("ling ");
                }
                continue;
            }
            if ((arr[i] == '1') && ((len - i - 1 == 9) || (len - i - 1 == 5))) {
                //处理特定yi shi 的情况,但是诸如12的情况、1212第二个1的情况也不在这里
                if ((len - i - 1 == 5) && (arr[i + 1] == 0))
                    System.out.print("shi wan ");//如100000 十万
                if ((len - i - 1 == 9) && (arr[i + 1] == 0))
                    System.out.print("shi yi ");
                else System.out.print("shi ");//如120000 十二万不能写成十万二万

            } else {
                System.out.print(sig[arr[i] - 48] + " ");
                System.out.print(wei[len - i - 1] + " ");
            }
        }

    }


}

类型7：条件判断

题目描述：输入年份，判断是否为闰年

问题描述

给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

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

\2. 年份是400的倍数。

其他的年份都不是闰年。

这题这么简单，就不多说了直接上题解吧

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int year = s.nextInt();
        if ((year % 4 == 0) && (year % 100) != 0) System.out.println("yes");
        else if (year % 400 == 0) System.out.println("yes");
        else System.out.println("no");
    }
}

类型8：斐波拉契数列

非递归版：

题目1：

问题描述

Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。

当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入格式

输入包含一个整数n。

输出格式

输出一行，包含一个整数，表示Fn除以10007的余数。

思路：直接在过程中求余比算出Fn求余更高效

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int a = 1;
        int b = 1;
        int tmp;
        for (int i = 1; i < n; i++) {
            tmp = b;
            b = (a + b) % 10007;
            a = tmp;
        }
        System.out.println(a);
    }
}

类型9：情景模拟

题目1：龟兔赛跑

给定兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值（一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。）以及赛道的长度l

输入格式

输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)

输出格式

输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
　　第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。

样例输入

10 5 5 2 20

样例输出

D
4

思路：所用基本公式
$路程 = 速度 * 时间$
题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //初始化
        int t1=0;//兔子所用时间
        int t2=0;//乌龟所用时间
        int s1=0;//兔子所走路程
        int s2=0;//乌龟所走路程
        Scanner scanner = new Scanner(System.in);
        int v1 = scanner.nextInt();//兔子速度
        int v2 = scanner.nextInt();//乌龟速度
        int t = scanner.nextInt();//兔子领先t米
        int s = scanner.nextInt();//就会休息s秒
        int l = scanner.nextInt();//赛道长度
//计时开始
        t1++;t2++;s1+=v1;s2+=v2;//按照一秒钟去计算，相当于s1+=v1*1
while(true){
    if((s1==l)&&(s2==l)){//同时到达
        System.out.println("D");
        System.out.println(t1);
        break;
    }
   if((s1==l)&&(s2<l)){//兔子先到达
       System.out.println("R");
       System.out.println(t1);
       break;
   }
    if((s2==l)&&(s1<l)){//乌龟先到达
        System.out.println("T");
        System.out.println(t2);
        break;
    }
    if((s1-s2)>=t){
        for (int i = 1; i <=s ; i++) {
            t1++;t2++;//时间在流逝
            s2+=v2;//兔子在原地休息，乌龟在前行
            //如果在这个过程中乌龟到终点了
            if(s2==l){
                System.out.println("T");
                System.out.println(t2);
                System.exit(0);
            }
        }

    }else{
        t1++;t2++;
        s1+=v1;s2+=v2;
    }
}
    }
}

思路都在注释当中体现了

类型10：打印输出找规律

感觉之前很多题都可以归到这个类别？比如水仙花数、打印菱形之类的，只能说基础题其实没有分得那么明确。

题目1：sine之舞

不妨设
　　An=sin(1–sin(2+sin(3–sin(4+…sin(n))…)
　　Sn=(…(A1+n)A2+n-1)A3+…+2)An+1
　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式

输入格式

仅有一个数：N<201。

输出格式

请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。

样例输入

样例输出

((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1

题解：An的写法：

int i = 1;
        while (i < n) {
            System.out.print("sin(");
            System.out.print(i);
            if (i % 2 == 0) System.out.print("+");
            if (i % 2 == 1) System.out.print("-");
            i++;
        }
        if (i == n) {
            System.out.print("sin(");
            System.out.print(n);
            for (int j = 0; j < i; j++) {
                System.out.print(")");
            }
        }

之后在打印Sn时要多次重复用到这段代码，所以将其封装为方法An

Sn的写法：

        int j = 1;
        while (j < n) {
            System.out.print("(");
            j++;
        }
        j=1;
        while(j<n){
            An(j);
            System.out.print("+"+(n-j+1)+")");
            j++;
        }
        if(j==n){
            An(n);
            System.out.print("+"+1);
        }

完整代码如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        //Sn
        int j = 1;
        while (j < n) {
            System.out.print("(");
            j++;
        }
        j=1;
        while(j<n){
            An(j);
            System.out.print("+"+(n-j+1)+")");
            j++;
        }
        if(j==n){
            An(n);
            System.out.print("+"+1);
        }

    }
    public static void An(int n){
        int i = 1;
        while (i < n) {
            System.out.print("sin(");
            System.out.print(i);
            if (i % 2 == 0) System.out.print("+");
            if (i % 2 == 1) System.out.print("-");
            i++;
        }
        if (i == n) {
            System.out.print("sin(");
            System.out.print(n);
            for (int j = 0; j < i; j++) {
                System.out.print(")");
            }
        }
    }
}

类题1：秒转时分秒格式输出

样例输入

5436

样例输出

1:30:36

import java.util.Scanner;

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

类题2：矩阵面积交

输入格式

输入仅包含两行，每行描述一个矩形。
　　在每行中，给出矩形的一对相对顶点的坐标，每个点的坐标都用两个绝对值不超过10^7的实数表示。

输出格式

输出仅包含一个实数，为交的面积，保留到小数后两位。

样例输入

1 1 3 3
2 2 4 4

样例输出

1.00

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        double x1=s.nextDouble();
        double y1=s.nextDouble();
        double x2=s.nextDouble();
        double y2=s.nextDouble();
        double a1=s.nextDouble();
        double b1=s.nextDouble();
        double a2=s.nextDouble();
        double b2=s.nextDouble();
        double lx=Math.max(Math.min(x1,x2),Math.min(a1,a2));
        double ly=Math.max(Math.min(y1,y2),Math.min(b1,b2));
        double rx=Math.min(Math.max(x1,x2),Math.max(a1,a2));
        double ry=Math.min(Math.max(y1,y2),Math.max(b1,b2));
        if(rx>lx&&ry>ly){
            System.out.printf("%.2f\n",(rx-lx)*(ry-ly));
        }
        else System.out.println("0.00");
    }
    }

类型11：高精度问题

题目1：

问题描述

输入两个整数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输出即可。

碎碎念：其实前面也有一道高精度的题目，被我用BigInteger打发了……

（注：java.math.BigInteger可以用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数，实际上就是对题目想要我们手写的方法的一种封装抽象）

以下先附上这道题的调包打发版：

import java.math.BigInteger;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        BigInteger a=s.nextBigInteger();
        BigInteger b=s.nextBigInteger();
        BigInteger c=a.add(b);
        System.out.println(c);
    }
}

(java yyds!)

具体数组实现等我有空再写

类型12:动态数组

题目1：

问题描述

Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
　　给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：

1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
　　2. 重复步骤1，直到{pi}中只剩下一个数。
在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
　　　　　　　　　　　　本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。

输入格式

输入的第一行包含一个正整数n（n<=100）。
　　接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。

输出格式

输出用这些数构造Huffman树的总费用。

样例输入

5
5 3 8 2 9

样例输出

59

题解：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
 Scanner s=new Scanner(System.in);
 int n=s.nextInt();
 //创建动态数组，方便删除元素
        ArrayList <Integer>list=new ArrayList<>();
        for (int i = 0; i <n ; i++) {
            list.add(s.nextInt());
        }
        int sum=0;int tmp=0;
 list.sort(Comparator.naturalOrder());//升序排序
        while(list.size()>1){
            tmp=list.get(0)+list.get(1);
            list.remove(0);
            list.remove(0);
            list.add(tmp);
            list.sort(Comparator.naturalOrder());
            sum+=tmp;
        }
        System.out.println(sum);
    }
}

总结：刚看到这题的时候就想着要用动态数组，在过程中用排序，但是因为对动态数组不太熟悉，所以花了一些时间查阅API文档。以下点需要注意：

ArrayList <Integer>list=new ArrayList<>();
//要说明动态数组的数据类型，不然再之后对list操作的代码会报错；new语句后面<>里可以不填

 list.sort(Comparator.naturalOrder());
 //升序排序参数是：Comparator.naturalOrder()

为什么循环条件是

list.size()>1

因为，第一，size为1时以下语句会导致数组越界从而抛出异常；

tmp=list.get(0)+list.get(1);

其次，剩下的一个元素是最后才加上去的，其结果已经被加到sum中，所以不用管它。

类型13：回溯法

题目：2n皇后问题

问题描述

给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。

输入格式

输入的第一行为一个整数n，表示棋盘的大小。
　　接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，如果一个整数为0，表示对应的位置不可以放皇后。

输出格式

输出一个整数，表示总共有多少种放法。

样例输入

4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1

样例输出

2

解题过程及思考：

我曾经选择n皇后问题作为离散数学A1的大作业，也在当时了解了回溯法的概念，但是实际代码编写经验不足。这道题我参考的是CSDN上名叫“0error（s）”的博主的解法，相关链接如下：

https://blog.csdn.net/qq_42318488/article/details/105037937

我在自认为理解了ta的代码并尝试复现的过程中，也遇到了一些问题。

我对java全局变量的理解还不够深入，一开始我在main函数之外直接创建goal，导致后续出现了“index 0 out of length 0"的错误。解决方法就是像博主一样把声明放在全局，把创建放在main里面。
我在查看博主的eqs()方法时，以为可以用！s1.equals(s2)代替，也能通过题目预先给的测试范例，但是提交评测时却发现有一半的测试样例输出结果都比实际结果大。

我分析了一下，两种方法是有区别的。

博主的思路是只有当字符串里的每个位置的字符都不相同时才会输出“true”，（每个位置都不冲突）；而在java原有的euqals前面加个！，只要字符串不一样就输出“true”，但有可能仅仅是其中一两个位置的字符不一样，（仅仅是一两个位置不冲突，其他都冲突），所以会会多算一些不符合的情况。

所以最后，我也自己写了一遍判断方法，问题就解决了。

写代码不容易，看懂和真正吃透别人的代码也不容易。

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

public class Main {
    static int n;
static int [][] goal;
    static ArrayList<String> method=null;
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
      n = s.nextInt();
        int[][] tmp = new int[n][n];//存储输入数据，即可放皇后的位置
        goal = new int[n][n];//存储每种最终落子位置
        method = new ArrayList<>();//用动态字符串数组存储可行放法，以便比对
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                tmp[i][j] = s.nextInt();
            }
        }
        dfs(tmp,0);
        int num=0;
        for (int i = 0; i < method.size(); i++) {
            for (int j = i+1; j < method.size(); j++) {
                if(noteqs(method.get(i),method.get(j)))
                    num+=2;
            }
        }
        System.out.println(num);
    }

    public static void dfs(int[][] tmp, int row) {
        if (row < n) {
            for (int i = 0; i < n; i++) {
                if((tmp[row][i]==1)&&(notConflict(row,i))){
                    goal[row][i]=1;
                    dfs(tmp,row+1);
                    goal[row][i]=0;
                }
            }

        } else {
            StringBuilder sb=new StringBuilder();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j <n ; j++) {
                    if(goal[i][j]==1)
                        sb.append(j);
                }
            }
            method.add(sb.toString());
        }
    }

    public static boolean notConflict(int row,int column){
        int r=row, c=column;
        //检查上方
        while(--r>=0){
            if(goal[r][c]==1) return false;
        }
        //左上
        r=row; c=column;
        while(--r>=0&&--c>=0){
            if(goal[r][c]==1) return false;
        }
        //右上
        r=row;c=column;
        while(--r>=0&&++c<n){
            if(goal[r][c]==1) return false;
        }
        return true;
    }

public static boolean noteqs(String s1,String s2){
        int len=s1.length();
    for (int i = 0; i < len; i++) {
        if(s1.charAt(i)==s2.charAt(i)) return false;
    }
    return true;
}
}

心中有光，不惧路长

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【蓝桥】做题笔记及心得总结（基础篇）

基础题类型1：考察数据类型方面的应用题目1：时间限制：1.0s 内存限制：512.0MB问题描述　　给定n个十六进制正整数，输出它们对应的八进制数。输入格式　　输入的第一行为一个正整数n （1<=n<=10）。　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。输出格式　　输出n行，每行为输入对应的八进制正整数。【注意】　　输入的十六进制数不会有前导0，比如012A。　　输出的八进制数也不能有
复制链接

扫一扫

专栏目录