蓝桥杯练习系统习题-基础训练

> 点个赞，看一看，好习惯！本文 **GitHub** [https://github.com/OUYANGSIHAI/JavaInterview](https://github.com/OUYANGSIHAI/JavaInterview) 已收录，这是我花了 3 个月总结的一线大厂 Java 面试总结，本人已拿大厂 offer。

> 另外，原创文章首发在我的个人博客：[blog.ouyangsihai.cn](https://blog.ouyangsihai.cn)，欢迎访问。

文章推荐

• 精选java等全套学习资源
• 精选java电子图书资源
• 精选大数据学习资源
• java项目练习精选

蓝桥杯练习系统习题-基础训练

题目搜索方式：Ctrl+F—-> 输入题目名称—>定位到解答。

入门训练（详见 算法-蓝桥杯习题（1-1））

基础练习（详见 算法-蓝桥杯习题（2-1））

基础练习（详见 算法-蓝桥杯习题（2-2））

算法训练（详见 算法-蓝桥杯习题（3-1））

算法训练（详见 算法-蓝桥杯习题（3-2））

算法训练（详见 算法-蓝桥杯习题（3-3））

算法训练（详见 算法-蓝桥杯习题（3-4））

算法训练（详见 算法-蓝桥杯习题（3-5））

算法训练（详见 算法-蓝桥杯习题（3-6））

算法提高（详见 算法-蓝桥杯习题（4-1））

算法提高（详见 算法-蓝桥杯习题（4-2））

历届试题（详见 算法-蓝桥杯习题（5-1））

历届试题（详见 算法-蓝桥杯习题（5-2））

基础练习 闰年判断

问题描述
给定一个年份，判断这一年是不是闰年。

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

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

2. 年份是400的倍数。

   其他的年份都不是闰年。

   输入格式
   输入包含一个整数y，表示当前的年份。
   输出格式
   输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
   说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。

   样例输入
   2013
   样例输出
   no
   样例输入
   2016
   样例输出
   yes
   数据规模与约定
   1990 <= y <= 2050。

  #include<stdio.h>  
  main()  
  {  
      int y;  
      scanf("%d",&y);  
      if(y%4==0&&y%100!=0||y%400==0)  
          printf("yes\n");  
      else  
          printf("no\n");  
      return 0;  
  }  

基础练习 01字串

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

00000

00001

00010

00011

00100

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

输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>

  #include<stdio.h>  
  main()  
  {  
      int a,b,c,d,e;  
      for(e=0;e<=1;e++)  
      for(d=0;d<=1;d++)  
      for(c=0;c<=1;c++)  
      for(b=0;b<=1;b++)  
      for(a=0;a<=1;a++)  
      printf("%d%d%d%d%d\n",e,d,c,b,a);  
      return 0;  
  }  

基础练习 字母图形

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

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

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

输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。

 #include <stdio.h>  
  #include <math.h>  
  main()  
  {  
      int n,m,j,k;  
      scanf("%d %d",&n,&m);  
      if(n>=1&&m<=26)  
      for(j=0;j<n;j++)  
      {  
          for(k=0;k<m;k++)  
          printf("%c",65+abs(j-k));  
          printf("\n");  
      }  
      return 0;  
  }  
  #include <stdio.h>  
  #include <stdlib.h>  
  #define MAXSIZE 26  
  //输出  
  void Print(char matrix[MAXSIZE][MAXSIZE],int n,int m)  
  {  
      int i,j;  
      for(i=0;i<n;i++)  
      {  
          for(j=0;j<m;j++)  
          {  
              printf("%c",matrix[i][j]);  
          }  
          printf("\n");  
      }  
  }  
  //实现字母图形  
  void Drawing(int n,int m)  
  {  
      int i,j;  
      int point=0;  
      char str;  
      char matrix[MAXSIZE][MAXSIZE];  
      for(i=0;i<n;i++)  
      {  
          str='A';  
          for(j=i;j<m;j++)  
          {  
              matrix[i][j]=str++;  
          }  
          str='A';  
          for(j=i-1;j>=0;j--)  
          {  
              matrix[i][j]=++str;  
          }  
      }  
      Print(matrix,n,m);  
  }  
  int main()  
  {  
      int n,m;  
      scanf("%d%d",&n,&m);  
      Drawing(n,m);  
      return 0;  
  }  

基础练习 数列特征

问题描述
给出n个数，找出这n个数的最大值，最小值，和。

输入格式
第一行为整数n，表示数的个数。

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

输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000。

 #include <stdio.h>  
  #define MaxSize 10000  
  main()  
  {  
      int n;  
      int sum=0,min=MaxSize,max=-MaxSize;  
      scanf("%d",&n);  
      while(n--)  
      {  
          int temp,st;  
          scanf("%d",&temp);  
          if(temp>max)  
          {  
              max=temp;  
          }  
          if(temp<min)  
          {  
              min=temp;  
          }  
          sum+=temp;  
      }  
      printf("%d\n%d\n%d\n",max,min,sum);  
      return 0;  
  }  

基础练习 查找整数

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

输入格式
第一行包含一个整数n。

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

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

输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

 #include<stdio.h>  
  #define MaxSize 1000+5  
  main()  
  {  
      int n,i,a[MaxSize],s,m=0;  
      scanf("%d",&n);  
      for(i=0;i<n;i++)  
      {  
          scanf("%d ",&a[i]);  
      }   
      scanf("%d",&s);  
      for(i=0;i<n;i++)  
      {  
          if(s==a[i])  
          {  
              printf("%d\n",i+1);  
              return 0;  
          }  
      }  
      printf("-1\n");  
      return 0;      
  }  

基础练习 杨辉三角形

问题描述
杨辉三角形又称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。

  #include<stdio.h>  
  main()  
  {  
      int n,x,y,a[35][35]={0};  
      int i,j;  
      scanf("%d",&n);  
      if(n>=1&&n<=34)  
      //赋值对角线元素为1   
      {  
          for(x=1;x<=n;x++)  
          {  
              a[x][1]=1;  
              a[x][x]=1;  
          }  
          //赋值其他元素   
          for(x=3;x<=n;x++)  
          for(y=2;y<=n;y++)  
          a[x][y]=a[x-1][y]+a[x-1][y-1];  
          //输出对应元素   
          for(j=1,x=1;x<=n;x++)  
          {  
              for(y=1;y<=j;y++)  
              {  
                  printf("%d ",a[x][y]);  
              }  
              j++;  
              printf("\n");  
          }  
      }  
      return 0;  
  }  

基础练习 特殊的数字

问题描述
　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。
输出格式
　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

#include<stdio.h>  
  main()  
  {  
      int i,j,k;  
      int n;  
      for(i=1;i<=9;i++)  
      for(j=0;j<=9;j++)  
      for(k=0;k<=9;k++)  
      {  
          if(i*100+j*10+k==i*i*i+j*j*j+k*k*k)  
          printf("%d%d%d\n",i,j,k);  
      }  
      return 0;  
  }  

基础练习 回文数

问题描述
　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
　　按从小到大的顺序输出满足条件的四位十进制数。

  #include<stdio.h>  
  main()  
  {  
      int a,b,i;  
      for(a=1;a<=9;a++)  
      for(b=0;b<=9;b++)  
      {  
          printf("%d%d%d%d\n",a,b,b,a);  
      }  
      return 0;  
  }  
  #include<stdio.h>  
  int main()  
  {  
   int a,b,c,d,i;  
   for(i=1000;i<=9999;i++)  
   {    
     a=i/1000;  
     b=i/100%10;  
     c=i/10%10;  
     d=i%10;  
    if(a==d&&b==c)  
      printf("%d\n",i);  
   }  
  return 0;  
  }  

基础练习 特殊回文数

问题描述
　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
　　输入一行，包含一个正整数n。
输出格式
　　按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
　　1<=n<=54。

  #include<stdio.h>  
  main()  
  {  
      int n,a,b,c;  
      scanf("%d",&n);  
      for(a=1;a<=9;a++)  
      for(b=0;b<=9;b++)  
      for(c=0;c<=9;c++)  
      {  
          if(n==2*a+2*b+c)  
          printf("%d%d%d%d%d\n",a,b,c,b,a);  
      }  
      for(a=1;a<=9;a++)  
      for(b=0;b<=9;b++)  
      for(c=0;c<=9;c++)  
      {  
          if(n==2*a+2*b+2*c)  
          printf("%d%d%d%d%d%d\n",a,b,c,c,b,a);  
      }  
      return 0;  
  }  
  #include<stdio.h>  
  int main()  
  {  
      int a,b,c,d,e,f,t,all;  
      scanf("%d",&t);  
      for(a=1;a<10;a++)  
          for(b=0;b<10;b++)  
              for(c=0;c<10;c++)  
                  for(d=0;d<10;d++)  
                      for(e=0;e<10;e++)  
                      {  
                          if(a==e)  
                              if(b==d)  
                                  {  
                                      all=a+b+c+d+e;  
                                      if(all==t)  
                                      printf("%d\n",a*10000+b*1000+c*100+d*10+e);  
                                  }  
                      }  
      for(a=1;a<10;a++)  
          for(b=0;b<10;b++)  
              for(c=0;c<10;c++)  
                  for(d=0;d<10;d++)  
                      for(e=0;e<10;e++)  
                          for(f=0;f<10;f++)  
                          {  
                              if(a==f)  
                                  if(b==e)  
                                      if(c==d)  
                                      {  
                                          all=a+b+c+d+e+f;  
                                          if(all==t)  
                                              printf("%d\n",a*100000+b*10000+c*1000+d*100+e*10+f);  
                                      }  
                          }  
      return 0;  
  }  

基础练习 十进制转十六进制

问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

  #include<stdio.h>  
  main()  
  {  
      int a;  
      scanf("%d",&a);  
      if(0<=a&&a<=2147483647)  
      printf("%X",a);  
      return 0;  
  }  
  #include <stdio.h>  
  #include <stdlib.h>  
  char data[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};  
  //输出  
  void Print(char *num,int n)  
  {  
      int i;  
      for(i=n-1;i>=0;i--) printf("%c",num[i]);  
      printf("\0");  
      printf("\n");  
  }  
  //将十六进制数转换为十进制数  
  int Transform(char *num,long long value)  
  {  
      int n=0;  
      while(value>=16)  
      {  
          num[n++]=data[value%16];  
          value/=16;  
      }  
      num[n++]=data[value%16];  
      return n;  
  }  
  int main()  
  {  
      long long value;  
      char num[10];  
      int n;  
      scanf("%I64d",&value);  
      n=Transform(num,value);  
      Print(num,n);  
      return 0;  
  }  

基础练习 十六进制转十进制

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

 #include<stdio.h>  
  #include<string.h>  
  int main()  
  {  
      char a[9];  
      int i;  
      unsigned int n=1,b=0;  
      scanf("%s",a);  
      for(i=strlen(a)-1;i>=0;i--)  
      {  
          if(a[i]<='9')  
          b+=(a[i]-'0')*n;  
          else  
          b+=(a[i]-'A'+10)*n;  
          n=16*n;  
      }  
      printf("%u\n",b);  
      return 0;  
  }  
  #include<stdio.h>  
  #include<string.h>   
  #include<math.h>  
  int main()  
  {   
   double sum=0,x;  
   char a[8];  
   int len,i=0;  
   gets(a);  
   len=strlen(a);  
   while(len)  
   {  
    if(a[len-1]>='A'&&a[len-1]<='F')  
      x=(a[len-1]-'7')*pow(16,i++);  
    else  
        x=(a[len-1]-'0')*pow(16,i++);  
    sum+=x;  
    len--;  
   }  
   printf("%.0lf",sum);  
   return 0;  
   }  

基础练习 十六进制转八进制

问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0~{9}、大写字母{A}~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
　　输出n行，每行为输入对应的八进制正整数。
注意
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
提示
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

 #include <cstdio>  
  #include <iostream>  
  #include <cstring>  
  #include <string>  
  #include <cmath>  
  #include <algorithm>  
  #include <set>  
  using namespace std;  
  char str[100005], num;  
  void Fun(int i, int state)  
  {  
  int temp;  
  if(i < 0)  
  {  
  if(num != 0)  
  {  
  printf("%d", num);  
  }  
  return;  
  }  
  if(state != 3)  
  {  
  temp = str[i] >= '0' && str[i] <= '9' ? str[i] - '0' : str[i] - 'A' + 10;  
  temp <<= state;  
  num |= temp;  
  temp = num;  
  num >>= 3;  
  Fun(i - 1, state + 1);  
  printf("%d", (temp & 1) + (temp & 2) + (temp & 4));  
  }  
  else  
  {  
  temp = num;  
  num >>= 3;  
  Fun(i, 0);  
  printf("%d", (temp & 1) + (temp & 2) + (temp & 4));  
  }  
  }  
  int main()  
  {  
  int n;  
  scanf("%d", &n);  
  while(n--)  
  {  
  num = 0;  
  scanf("%s", str);  
  Fun(strlen(str) - 1, 0);  
  printf("\n");  
  }  
  return 0;  
  }  
  #include <stdio.h>  
  #include <stdlib.h>  
  #include <string.h>  
  #define MaxSize 100000  
  void saveB(char *b,char c3,char c2,char c1,char c0,int start)  
  {  
      b[start]=c3;  
      b[start+1]=c2;  
      b[start+2]=c1;  
      b[start+3]=c0;  
  }  
  int htob(char *h,char *b)  
  {  
      int i,j;  
      int hl=strlen(h);  
      for(i=0;i<hl;i++)  
          switch(h[i])  
          {  
              case '0':  
                  {  
                      saveB(b,'0','0','0','0',4*i);  
                      break;  
                  }  
              case '1':  
                  {  
                      saveB(b,'0','0','0','1',4*i);  
                      break;  
                  }  
              case '2':  
                  {  
                      saveB(b,'0','0','1','0',4*i);  
                      break;  
                  }  
              case '3':  
                  {  
                      saveB(b,'0','0','1','1',4*i);  
                      break;  
                  }  
              case '4':  
                  {  
                      saveB(b,'0','1','0','0',4*i);  
                      break;  
                  }  
              case '5':  
                  {  
                      saveB(b,'0','1','0','1',4*i);  
                      break;  
                  }  
              case '6':  
                  {  
                      saveB(b,'0','1','1','0',4*i);  
                      break;  
                  }  
              case '7':  
                  {  
                      saveB(b,'0','1','1','1',4*i);  
                      break;  
                  }  
              case '8':  
                  {  
                      saveB(b,'1','0','0','0',4*i);  
                      break;  
                  }  
              case '9':  
                  {  
                      saveB(b,'1','0','0','1',4*i);  
                      break;  
                  }  
              case 'A':  
                  {  
                      saveB(b,'1','0','1','0',4*i);  
                      break;  
                  }  
              case 'B':  
                  {  
                      saveB(b,'1','0','1','1',4*i);  
                      break;  
                  }  
              case 'C':  
                  {  
                      saveB(b,'1','1','0','0',4*i);  
                      break;  
                  }  
              case 'D':  
                  {  
                      saveB(b,'1','1','0','1',4*i);  
                      break;  
                  }  
              case 'E':  
                  {  
                      saveB(b,'1','1','1','0',4*i);  
                      break;  
                  }  
              case 'F':  
                  {  
                      saveB(b,'1','1','1','1',4*i);  
                      break;  
                  }  
          }  
      return 4*hl;  
  }  
  int btoo(char *b,char *o,int bl)  
  {  
      int i,j;  
      int ol;  
      int value;  
      if(bl%3==0)  
          ol=bl/3;  
      else  
          ol=bl/3+1;  
      j=bl-1;  
      for(i=ol-1;i>=0;i--)  
      {  
          if(i>0)  
              o[i]=b[j]-48+(b[j-1]-48)*2+(b[j-2]-48)*4+48;  
          else  
          {  
              switch(j)  
              {  
                  case 2:  
                      o[i]=b[j]-48+(b[j-1]-48)*2+(b[j-2]-48)*4+48;  
                      break;  
                  case 1:  
                      o[i]=b[j]-48+(b[j-1]-48)*2+48;  
                      break;  
                  case 0:  
                      o[i]=b[j];  
                      break;  
              }  
          }  
          j=j-3;  
      }  
      return ol;  
  }  
  void printO(char *o,int ol)  
  {  
      int i=0;  
      if(o[0]=='0')  
          i=1;  
      for(;i<ol;i++)  
      {  
          printf("%c",o[i]);  
      }  
      printf("\n");  
  }  
  main()  
  {  
      char h[MaxSize];  
      char b[4*MaxSize];  
      char o[4*MaxSize/3+1];  
      int n,i,bl,ol;  
      scanf("%d",&n);  
      getchar();  
      for(i=0;i<n;i++)  
      {  
          gets(h);  
          bl=htob(h,b);  
          ol=btoo(b,o,bl);  
          printO(o,ol);  
      }  
  }  

基础练习 数列排序

问题描述
　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
　　输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9

  #include <stdio.h>  
  int main()  
  {  
      int n,i,j,s,a[200];  
      scanf("%d",&n);  
      for(i=1;i<=n;i++)  
      {  
          scanf("%d",&a[i]);  
      }  
      i=n+1;  
      while(i--)  
      for(j=1;j<i;j++)  
      {  
          if(a[j]>a[j+1])  
          {  
              s=a[j+1];  
              a[j+1]=a[j];  
              a[j]=s;  
          }  
      }  
      for(i=1;i<=n;i++)  
      printf("%d ",a[i]);  
      return 0;  
  }  
  #include <stdio.h>  
  #include <stdlib.h>  
  void Print(int *data,int n)  
  {  
      int i;  
      for(i=0;i<n;i++)  
      {  
          printf("%d ",data[i]);  
      }  
      printf("\n");  
  }  
  int Split(int *data,int pre,int rear)  
  {  
      int value=data[pre];  
      while(pre<rear)  
      {  
          while(data[rear]>=value && pre<rear) rear--;  
          data[pre]=data[rear];  
          while(data[pre]<value && pre<rear) pre++;  
          data[rear]=data[pre];  
      }  
      data[pre]=value;  
      return pre;  
  }  
  //快速排序  
  void QuickSort(int *data,int pre,int rear)  
  {  
      if(pre<rear)  
      {  
          int mid=Split(data,pre,rear);  
          QuickSort(data,pre,mid-1);  
          QuickSort(data,mid+1,rear);  
      }  
  }  
  int main()  
  {  
      int i;  
      int n;  
      int *data;  
      scanf("%d",&n);  
      data=(int *)malloc(sizeof(int)*n);  
      for(i=0;i<n;i++)  
      {  
          scanf("%d",&data[i]);  
      }  
      QuickSort(data,0,n-1);  
      Print(data,n);  
      return 0;  
  }