基础练习（更新中。。。）

BASIC-01 A+B问题

问题描述

输入A、B，输出A+B。

样例输入

12 45

样例输出

#include<iostream>
using namespace std;
int main()
{
    int a, b;
    cin >> a >> b;
    cout << a + b << endl;
    return 0;
}

BASIC-02序列求和

问题描述

求1+2+3+...+n的值。

输入格式

输入包括一个整数n。

输出格式

输出一行，包括一个整数，表示1+2+3+...+n的值。

样例输入

样例输出

数据规模与约定

1 <= n <= 1,000,000,000。

说明：请注意这里的数据规模。

本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。

本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。

如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

#include<iostream>
using namespace std;
int main() 
{
    int n;
    long long sum=0;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        sum += i;
    }
    cout << sum;
}

总结：第一次没把sum定义为“long long ”型，输出结果只有50%正确。除了暴力相加以外，sum=(n+1)*n/2,等差数列求和。

BASIC-03圆的面积

问题描述

给定圆的半径r，求圆的面积。

输入格式

输入包含一个整数r，表示圆的半径。

输出格式

输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。

说明：在本题中，输入是一个整数，但是输出是一个实数。

对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，

输出过多或者过少的小数位数都是不行的，都会被认为错误。

实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。

样例输入

样例输出

50.2654825

数据规模与约定

1 <= r <= 10000。

提示：

本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。

#include<iostream>
#include<math.h>
#define PI  atan(1.0) * 4
using namespace std;
int main() 
{
    int r;
    cin >> r;
    double S;
    S = PI * r * r;
    printf("%.7lf", S);
    return 0;
}

总结：第一次知道PI可以用一个函数来表示，如果用“PI=atan(1.0)*4”一定要调用头文件“#include<math.h>"对于vs219不调用同文件能运行出结果且不会报错，蓝桥杯就不行了。

关于输出小数位数问题：另一种方法，通过cout,借助fixed和setprecision,引入iomanip库

cout<<fixed<<setprecision(7)<<S<<endl;//输出变量S的7位小数

fixed：表示普通方式输入，不采用科学计数法。

setprecision:控制输出流，显示浮点数的数字个数，和fixed合用的话，可以控制小数点右面的位数需要添加头文件“#include<iomanip>"。

BASIC-04 Fibonacci数列

问题描述

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

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

输入格式

输入包含一个整数n。

输出格式

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

说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

样例输入

样例输出

样例输入

样例输出

7704

数据规模与约定

1 <= n <= 1,000,000。

方法一、for循环

#include<iostream>
using namespace std;
int main() 
{
    int n,t;
    cin>> n;
    int a = 1, b = 1, c;
    if (n == 1 || n == 2)
        cout << 1 << endl;
    else
    { 
        for (int i = 3; i <= n; i++)
        {
            t = a;
            a = b;
            b = (b +t)% 10007;
        }

  　　　　cout << b;

　　　}  
　　return 0;
 }

方法二、vector

#include<vector>
#include<iostream>
using namespace std;
int main() 
{
    int n;
    cin >> n;
    vector<int> lst(2,1);
if (n == 1 || n == 2)
        cout << 1 << endl;
    else
    {
        for (int i = 3; i <= n; i++)
        {
            lst.push_back((lst[lst.size() - 1] + lst[lst.size() - 2]) % 10007);
        }
        cout << lst[lst.size() - 1] << endl;
    }

    return 0;
}

蓝桥杯的编译系统为C++98,以下方式初始化编译显示错误。

in C++98 'lst' must be initialized by constructor, not by '{...}'

vector<int> lst={2,1);

方法三、矩阵乘法下的快速幂

// 试题 入门训练 Fibonacci数列

#include<iostream>
#include<vector>
#include<algorithm>
#include<string.h>
using namespace std;

const int N=2;
const int mod=10007;

int tmp[N][N],res[N][N];

// temp记录矩阵a和矩阵b的乘积结果 ，这里的b矩阵就是常数/转移矩阵 
void multi(int a[][N],int b[][N],int N){ 
    memset(tmp,0,sizeof(tmp));    
    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]*b[k][j])%mod; // 代表tmp[i][j]为A的第i行和B的第j列所有数 
                }
                 tmp[i][j]=tmp[i][j]%mod;
        }
    }
    
    //更新A矩阵，为下一次使用做准备 
    for(int i=0;i<N;i++)
    for(int j=0;j<N;j++)
    a[i][j]=tmp[i][j];
     
}

//n是幂次数，N是矩阵大小,矩阵a代表的就是幂矩阵，将整数快速幂的整数换成矩阵即可 
void Pow(int a[][N],int n){
    memset(res, 0, sizeof res);
    for (int i=0;i<N;i++) res[i][i]=1; //单位矩阵初始化，对角线值为1 
    while (n) {
        if (n&1)
            multi(res,a,N);//res=res*a;复制直接在multi里面实现了；
        multi(a,a,N);//a=a*a
        n>>=1;
    }
}

// 矩阵快速幂
int main(){

    int n;
    cin>>n;
    int a[N][N]={{1,1},{1,0}}; 

    Pow(a,n);
    cout << res[0][1]<<endl; 
    
    return 0;
}

此题矩阵快速幂链接：https://blog.csdn.net/Lurker_hunter/article/details/104549360

快速幂：

https://www.cnblogs.com/yewanting/p/10743018.html
https://blog.csdn.net/Harington/article/details/87602682

BASIC-1 闰年判断

问题描述

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

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

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

2. 年份是400的倍数。

其他的年份都不是闰年。

输入格式

输入包含一个整数y，表示当前的年份。

输出格式

输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。

样例输入

2013

样例输出

样例输入

2016

样例输出

yes

数据规模与约定

1990 <= y <= 2050。

#include<iostream> 
using namespace std;
int main()
{
    int y;
    cin>>y;
    if((y%4==0&&y%100!=0)||y%400==0)
         cout<<"yes";
    else
        cout<<"no";
    return 0;
}

BASIC-2 01字串

问题描述

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

00000

00001

00010

00011

00100

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

输入格式

本试题没有输入。

输出格式

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

样例输出

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

方法一：for循环，二进制转十进制

#include<iostream>
using namespace std;
int main()
{
    int i,j,m ;
    for (i = 0; i < 32; i++)
    {
        int a[5] = { 0 };
        j = 0;
        for ( m = i; m != 0; j++)
        {
            a[j] = m % 2;
            m = int(m / 2);
        }
        for (int i = 4; i >= 0; i--)
        {
            cout << a[i];
        }
        cout << endl;
    }
    return 0;
 }

方法二、bitset用法，直接转二进制

#include<bitset>
#include<iostream>
using namespace std;
int main()
{ 
    for(int i=0;i<32;i++)
    {
        bitset<5> res(i);
        cout<<res<<endl;
    }
    return 0;
 }

参考博文：

bitset用法：bitset详解 - Grit_L。 - 博客园 (cnblogs.com)

C++蓝桥杯基础练习之01字串_Lurker_hunter的博客-CSDN博客_蓝桥杯01字串，里面有很多种方法。

BASIC-3 字母图形

问题描述

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

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 <iostream>
using namespace std;
int main(){
    int n,m;
    cin>>n>>m;
    for(int row=0;row<n;row++){
        int col=m;
        int c=65+row;
        for(;c>65&&col>0;c--, col--){
            cout<<(char)c;
        }
        for(;col>0;c++, col--){
            cout<<(char)c;
        }
        cout<<endl;
    }
    return 0;
}

我之前写的代码运行后只有70分，一直没找到自己错在那，后来看了小白的代码后才发现自己的代码在行大于列的时候输出结果就不对了。

先附上错误的代码，我觉得错的挺有意思的（是憨😓！！！

#include<iostream>
using namespace std;
int main()
{ 
     int row,column;
     cin>>row>>column;
     if(row>26||column>26)
         cin>>row>>column;
    for(int i=1;i<=row;i++)
    {
        if(i!=1)
                for(int m=i;m>1;m--)//这里如果col<row时会导致一行输出的字母数多余col;
                    {
                        printf("%c",64+m) ;
                    }    
        for(int j=1;j<=column-i+1;j++)
        {
             printf("%c",64+j) ;
        }
        cout<<endl;
    } 
    return 0;
 }

运行结果

6 3//输入
ABC
BAB
CBA
DCB
EDCB
FEDCB

修改后就正确啦！

#include<iostream>
using namespace std;
int main()
{
    int row, col;
    cin >> row >> col;
    if (row > 26 || col > 26)
        cin >> row >> col;
    for (int i = 1; i <= row; i++)
    { 
        int n = col;
        if (i != 1)
            for (int m = i; m > 1&&n>0; m--,n--)
            {
                printf("%c", 64 + m);
            }
        for (int j = 1; j <= n; j++)
        {
            printf("%c", 64 + j);
        }
        cout << endl;
    }
    return 0;
}

BACSIC-4 数列特征

资源限制

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

问题描述

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

输入格式

第一行为整数n，表示数的个数。

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

输出格式

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

样例输入

5
1 3 -2 4 5

样例输出

5
-2
11

数据规模与约定

1 <= n <= 10000。

方法一、for循环

#include <iostream>
#include<stdlib.h>
using namespace std;
int main()
{
    int n,min,max,sum=0;
    cin>>n;
    int *p=(int*) malloc(n*sizeof(int));
    for(int i=0;i<n;i++)
    {
        cin>>p[i];
    }
    min=p[0];
    max=p[0];
    for(int i=0;i<n;i++)
    {
        sum+=p[i];
        if(min>p[i])
             min=p[i];
         if(max<p[i])
             max=p[i];
    }
    cout<<max<<endl;
     cout<<min<<endl;
     cout<<sum<<endl;
    return 0;
}

方法二、min_element、max_element

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n,sum=0;
    cin >> n;
    vector<int> lst(n);
    for (int i = 0; i < n; i++)
    {
        cin >> lst[i];
        sum += lst[i];
    }
    cout << *min_element(lst.begin(), lst.end())<<endl;
    cout << *max_element(lst.begin(), lst.end())<<endl;
    cout << sum << endl;
    return 0;
}

参考链接：std :: max()函数 - Grit_L。 - 博客园 (cnblogs.com)

BASIC-5 查找整数

问题描述

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

输入格式

第一行包含一个整数n。

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

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

输出格式

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

样例输入

6
1 9 4 8 3 9
9

样例输出

数据规模与约定

1 <= n <= 1000。

方法一、常规方法new、for循环

#include<iostream>
using namespace std;
int main()
{
    int n,i;
    cin >> n;
    int* p = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> p[i];
    }
    int ser,pos;
    cin >> ser;
    for ( i = 0; i < n; i++)
    {
        if (p[i] == ser)
        {
            pos = i + 1;
            break;
        }
    }
    if (i >= n)
        cout << -1;
    else
        cout << pos;
    return 0;
}

方法二、STL map函数

这个思维是first存位置，second存元素

#include<iostream>
#include<map>
using namespace std;
int main() {
    int n,a;
    cin >> n;
    map<int, int> lst;
    for (int i = 1; i <= n; i++) {
        cin >> lst[i];
    }
    cin >> a;
    map<int, int > ::iterator iter;
    for (iter = lst.begin(); iter != lst.end(); iter++) {
        if (iter->second == a)
            break;
    }
    if (iter == lst.end())
        cout << -1 << endl;
    else
        cout << iter->first << endl;
    return 0;
}

这个思维是first存元素，second存位置

贴网上的代码，其实可以直接用find（）函数

#include<iostream>
#include<map>
using namespace std;

int main(){
    int t,n,a;
    cin>>n;
    map<int ,int> dic;
    
    for (int i=1;i<=n;i++){
        cin>>t;
        if (dic.count(t)==0) dic[t]=i;
        
    }
    cin>>a;
    if (dic.count(a)==0) cout<<-1<<endl;
    else{
        cout<<dic[a]<<endl;        
    }

    return 0;
}

BASIC-6杨辉三角形

资源限制

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

问题描述

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

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

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

1 1

1 2 1

1 3 3 1

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

输入格式

输入包含一个数n。

输出格式

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

样例输入

样例输出

1
1 1
1 2 1
1 3 3 1

数据规模与约定

1 <= n <= 34。

#include<iostream>
using namespace std;
int main(){
    int n,i,j;
    cin>>n;
    int lst[n][n];
    
    for ( i=0;i<n;i++){
         lst[i][0]=1;
         lst[i][i]=1;
    }
    for (i=2;i<n;i++){
        for (j=1;j<i;j++){
             lst[i][j]=lst[i-1][j-1]+lst[i-1][j];
        } 
    }
    for(i=0;i<n;i++){
         for(j=0;j<=i;j++){
        cout<<lst[i][j]<<"  ";
    }
    cout<<endl;
    }
     
    return 0;
}

这道题看了网上的方法，那些语句确实写的高级些，但都是基于for循环。这道题输出的是直角三角形，如果输出等腰等腰三角形，难度要大点。

BASIC-7 特殊数字

资源限制

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

问题描述

　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。

输出格式

　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

#include<iostream>
#include<math.h>
using namespace std;
int main() 
{
    int i, t;
    for (i = 100; i <= 999; i++)
    {
        if (i == (pow(i % 10, 3) + pow(i / 10 % 10, 3) + pow(i / 100 % 10, 3)))
        cout << i << endl;
    }

    return 0;
}

BASIC-8 回文数

资源限制

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

问题描述

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

输出格式

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

#include<iostream>
using namespace std;
bool Pal(int m) {
    int a[4], r = 10, i,t=m;
    for (int i = 0; i < 4; i++)
    {
        a[i] = t % r;
        t = t / r;
    }
    for (i = 0; i < 2;)
    {
        if (a[i] == a[3 - i])
            i++;
        else
            break;
    }
    if (i >= 2)
        return true;
    else
        return false;
};
int main() {
    int n,count=0;
    for (int i = 1000; i <= 9999; i++)
    {
        n=Pal(i);
        if (n == true)
        {
            cout << i<<endl;
            count++;
            /*if (count % 10 == 0)
                cout << endl;*/  //这个是一行输出10个数
        }
    }
    cout << endl;
    return 0;
}

这道题真的狗，他不说清楚怎么个输出形式，搞得我一直错误。还有还久没刷题了，都忘记怎么取位数了。

如果想一行输出10个的话，一定要把关键语句写在if（n==true)里面。网上有很简洁的代码，后天贴，明天去爬青城山。

本来可以找点贴的，因为点事，给耽搁了。

BASIC-9 特殊回文数

资源限制

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

问题描述

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

输入格式

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

输出格式

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

样例输入

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

方法同上：

#include<iostream>
using namespace std;
int main() 
{
    int i,j,k,n;
    cin >> n;
     for(i=1;i<=9;i++)
         for(j=0;j<=9;j++)
             for (k = 0; k <= 9; k++)
             {
                 if (2 * (i + j) + k == n)
                     cout << i << j << k << j << i << endl;
             }
     for (i = 1; i <= 9; i++)
         for (j = 0; j <= 9; j++)
             for (k = 0; k <= 9; k++)
             {
                 if (2 * (i + j+k) == n)
                     cout << i << j << k << k << j << i << endl;
             }
    return 0;
}

BASIC-10 十进制转十六进制

资源限制

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

问题描述

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

样例输入

样例输出

#include <iostream>
using namespace std;
int main() {
    string s = "0123456789ABCDEF";
    int lst[100] = { 0 }, count = 0;
    int a, t;
    cin >> a;
    for (count = 0; a != 0; count++)
    {
        t = a % 16;
        lst[count] = s[t];
        a = a / 16;
    }
    if(count>0)
    for (int i = count-1; i>=0; i--)
    {
        printf("%c", lst[i]);
    }
     else
     cout<<0<<endl;
    return 0;

}

BASIC-11十六进制转十进制

资源限制

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

问题描述

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

样例输入

FFFF

样例输出

65535

#include <iostream>
#include<math.h>
using namespace std;
int main() {
    long long s = 0;
    int i, j;
    string a;
    cin >> a;
    int t = a.size();
    for (i = t - 1, j = 0; i >= 0; i--, j++)
    {
        if (a[i] >= 'A')
            s += (int)(a[i] - 'A' + 10) * pow(16, j);
        else
            s += (int)(a[i] - '0') * pow(16, j);

    }
    cout << s;
    return 0;
}

定义类型时除了看输出的数据的范围还要看输入数据的要求，然后定义，像这道题输入数据最大可以为FFFFFFFF，int完全存不下，long long 型才可。

BASIC-12 十六进制转八进制

资源限制

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

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

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

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

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

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

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

#include<iostream>
#include<math.h>
#include<map>
using namespace std;

//思路：100000位的十六进制数，这么大的数不好直接处理，以二进制字符串转换为八进制即可 
int main(){
    int n;
    cin>>n;
    while(n--){
        string s;
        cin>>s;
        
        int len1 = s.length();
        string res1="";
        //将16进制转换为二进制字符串 
        for (int i=0;i<len1;i++){
            switch(s[i]){
                case '0': res1 += "0000"; break;
                case '1': res1 += "0001"; break;
                case '2': res1 += "0010"; break;
                case '3': res1 += "0011"; break;
                case '4': res1 += "0100"; break;
                case '5': res1 += "0101"; break;
                case '6': res1 += "0110"; break;
                case '7': res1 += "0111"; break;
                case '8': res1 += "1000"; break;
                case '9': res1 += "1001"; break;
                case 'A': res1 += "1010"; break;
                case 'B': res1 += "1011"; break;
                case 'C': res1 += "1100"; break;
                case 'D': res1 += "1101"; break;
                case 'E': res1 += "1110"; break;
                case 'F': res1 += "1111"; break;
            }
        }
        //二进制字符串每四个数就是一个16进制数，每3个数就是一个8进制数，这里可能存在缺0的情况，需要补充
        int len2=res1.length() ;
        switch(len2%3){
            case 1: res1 = "00"+res1; break;
            case 2: res1 = "0"+res1; break;
        }
        
        //此时的res1就是一个合法的二进制表示8进制的字符串了,下面开始生成八进制字符串了 
        string res2="";
        len2=res1.length();
        for (int i=0;i<len2;i+=3){
            string t = res1.substr(i,3); 
            // 避免因为000带来导致转为为八进制时候有前导0 
            if (i==0&&t=="000") res2+="";
            else res2 += (4*((t[0])-'0')+ 2*((t[1])-'0' )+ ((t[2])-'0'))+'0';
            
        }
        cout<<res2<<endl;
    } 
    
    return 0;
}

我之前做题的思路是吧把输入的n个字符串存入一个字符串数组里面，但是完全没必要，运行了结果都没法输出。来一个数输出一个数就可。

BASIC-13 数列排序

问题描述

　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式

　　输出一行，按从小到大的顺序输出排序后的数列。

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

方法一：冒泡排序法

#include<iostream>
#include<stdlib.h>
using namespace std;
int main()
{
    int n, t;
    cin >> n;
    int* p = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++)
        cin >> p[i];
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - 1 - i; j++)
        {
            if (p[j] > p[j+1])
            {
                t = p[j];
                p[j] = p[j+1];
                p[j+1] = t;
            }
        }
    }
    for (int i = 0; i < n; i++)
        cout << p[i]<<"  ";
　　free(p);
}

方法二STL sort（）函数

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int n;
    cin >> n;
    int* p = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++)
        cin >> p[i];
    sort(p, p + n);
    for (int i = 0; i < n; i++)
        cout << p[i] << " ";
    free(p);
}

Grit_L。

基础练习（更新中。。。）

BASIC-01 A+B问题

BASIC-02序列求和

BASIC-03圆的面积

BASIC-04 Fibonacci数列

BASIC-1 闰年判断

BASIC-2 01字串

BASIC-3 字母图形

BACSIC-4 数列特征

BASIC-5 查找整数

BASIC-6杨辉三角形

BASIC-7 特殊数字

BASIC-8 回文数

BASIC-9 特殊回文数

BASIC-10 十进制转十六进制

BASIC-11十六进制转十进制

BASIC-12 十六进制转八进制

BASIC-13 数列排序

公告