C++ 语法习题(3)

字符串

1.字符串长度

给定一行长度不超过 100 的非空字符串，请你求出它的具体长度。

输入格式

输入一行，表示一个字符串。注意字符串中可能包含空格。

输出格式

输出一个整数，表示它的长度。

数据范围

1≤字符串长度≤100
字符串末尾无回车

输入样例：

I love Beijing.

输出样例：

参考代码：

//fgets在读取的时候也会帮我们把回车（'\n）读进来。
#include <iostream>
#include <cstdio>

using namespace std;
int main()
{
    char str[101];
//fgets（字符串名，最大读取的长度+1，stdin（固定必备的））;
    fgets(str,101,stdin);//读取长度最多为100可包含空格的字符串。
    int count=0;
//for（）的第二句：字符串str第i个有效且不等于回车。
  for(int i=0;str[i]&&str[i]!='\n';i++)
  {
      count++;
  }
  cout<<count<<endl;
    return 0;
}

2.字符串中的数字个数

输入一行字符，长度不超过 100，请你统计一下其中的数字字符的个数。

输入格式

输入一行字符。注意其中可能包含空格。

输出格式

输出一个整数，表示数字字符的个数。

输入样例：

I am 18 years old this year.

输出样例：

参考代码：

#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
    char s1[101];
    fgets(s1,101,stdin);
    int c=0;
    for(int i=0;s1[i]&&s1[i]!='\n';i++)
    {
//if判断每个字符是否是数字也就是范围在字符串0-字符串9之间。
        if(s1[i]>='0'&&s1[i]<='9') c++;
    }
    cout<<c<<endl;
    return 0;
}

3.循环相克令

循环相克令是一个两人玩的小游戏。

令词为“猎人、狗熊、枪”，两人同时说出令词，同时做出一个动作——猎人的动作是双手叉腰;狗熊的动作是双手搭在胸前;枪的动作是双手举起呈手枪状。

双方以此动作判定输赢，猎人赢枪、枪赢狗熊、狗熊赢猎人，动作相同则视为平局。

现在给定你一系列的动作组合，请你判断游戏结果。

输入格式

第一行包含整数 T，表示共有 T 组测试数据。

接下来 T 行，每行包含两个字符串，表示一局游戏中两人做出的动作，字符串为 Hunter, Bear, Gun 中的一个，这三个单词分别代表猎人，狗熊和枪。

输出格式

如果第一个玩家赢了，则输出 Player1。

如果第二个玩家赢了，则输出 Player2。

如果平局，则输出 Tie。

数据范围

1≤T≤100

输入样例

3
Hunter Gun
Bear Bear
Hunter Bear

输出样例

Player1
Tie
Player2

参考代码：

//相当于剪子包袱锤之间的关系。
#include <iostream>
using namespace std;
int main()
{
    string s1,s2;
    int n=0;cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>s1>>s2;
        if(s1==s2) cout<<"Tie"<<endl;
        else 
        {
            if(s1=="Hunter")
            {
                if(s2=="Bear") cout<<"Player2"<<endl;
                else cout<<"Player1"<<endl;
            }
            else if(s1=="Bear")
            {
                if(s2=="Hunter") cout<<"Player1"<<endl;
                else cout<<"Player2"<<endl;
            }
            else if(s1=="Gun")
            {
                if(s2=="Hunter") cout<<"Player2"<<endl;
                else cout<<"Player1"<<endl;
            }
        }
    }
    return 0;
}

4.字符串加空格

给定一个字符串，在字符串的每个字符之间都加一个空格。

输出修改后的新字符串。

输入格式

共一行，包含一个字符串。注意字符串中可能包含空格。

输出格式

输出增加空格后的字符串。

数据范围

1≤字符串长度≤100

输入样例：

test case

输出样例：

t e s t   c a s e

参考代码：

#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
    char str[101];
    fgets(str,101,stdin);
//因为读入的字符串可能有空格所以用fgets读入。
    for(int i=0;str[i]&&str[i]!='\n';i++)
    {
//每次输出玩一个字符后再输出一个空格
        cout<<str[i]<<' ';
    }
    return 0;
}

5. 替换字符

给定一个由大小写字母构成的字符串。

把该字符串中特定的字符全部用字符 # 替换。

请你输出替换后的字符串。

输入格式

输入共两行。

第一行包含一个长度不超过 30的字符串。

第二行包含一个字符，表示要替换掉的特定字符。

输出格式

输出共一行，为替换后的字符串。

输入样例：

hello
l

输出样例：

he##o

参考代码：

#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
//因为最大字符串长度为40，我们定义字符串长度较多一些。
    char str[41];
    fgets(str,41,stdin);
    char s;
    cin>>s;
    for(int i=0;str[i] && str[i]!='\n';i++)
    {
//如果当前字符srt[i] == 要更改的字符s就更改成#
        if(str[i]==s) str[i]='#';
    }
      printf("%s",str);
    return 0;
}

6.字符串插入

有两个不包含空白字符的字符串 str 和 substr，str 的字符个数不超过 10，substr 的字符个数为 3。（字符个数不包括字符串结尾处的 \0。）

将 substr 插入到 str 中 ASCII 码最大的那个字符后面，若有多个最大则只考虑第一个。

输入格式

输入包括若干行，每一行为一组测试数据，格式为

str substr

输出格式

对于每一组测试数据，输出插入之后的字符串。

输入样例：

abcab eee
12343 555

输出样例：

abceeeab
12345553

参考代码：

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
    string s1,s2;
    while(cin>>s1>>s2)
    {
        int p=0;
       for(int i=1;i<s1.size();i++)
       {
//p用来保存字符串s1 ASCII码最大字符的下标。
          if(s1[i]>s1[p]) p=i;
       }
//substr（起始位置下标，想要截取到的位置下标+1）截取起始位置-截取到位置的字符串
       cout<<s1.substr(0,p+1)+s2+s1.substr(p+1)<<endl;
    }
    return 0;
}

7.只出现一次的字符

给你一个只包含小写字母的字符串。

请你判断是否存在只在字符串中出现过一次的字符。

如果存在，则输出满足条件的字符中位置最靠前的那个。

如果没有，输出 no。

输入格式

共一行，包含一个由小写字母构成的字符串。

数据保证字符串的长度不超过 100000。

输出格式

输出满足条件的第一个字符。

如果没有，则输出 no。

输入样例：

abceabcd

输出样例：

参考代码：

//如果在全局定义的数组那么默认所有元素都为为0，在局部定义的数组如果不初始化默认元素为随机值。
#include <iostream>
#include <cstring>
using namespace std;
//将字符串数组a定义在全局中
char a[100010];
int s[26];
int main()
{
    cin>>a;

    for(int i=0;a[i];i++)
    {
//字符a-z 减去a后变成数子0-25
//统计每个字符出现的次数
        s[a[i]-'a']++;
    }
    for(int i=0;a[i];i++)
    {
        if(s[a[i]-'a']==1) 
        {
        cout<<a[i]<<endl;
        return 0;
        }
    }
    cout<<"no"<<endl;
    return 0;
}

8.字符串匹配

给定两个长度相同的字符串 a 和字符串 b。

如果在某个位置 i上，满足字符串 a 上的字符 a[i] 和字符串 b 上的字符 b[i]相同，那么这个位置上的字符就是匹配的。

如果两个字符串的匹配位置的数量与字符串总长度的比值大于或等于 k，则称两个字符串是匹配的。

现在请你判断给定的两个字符串是否匹配。

输入格式

第一行包含一个浮点数 k，第二行包含字符串 a，第三行包含字符串 b。

输入的字符串中不包含空格。

输出格式

如果两个字符串匹配，则输出 yes。

否则，输出 no。

数据范围

0≤k≤10,
字符串的长度不超过 100。

输入样例：

0.4
abcde
xbacd

输出样例：

no

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string a,b;
    double k;
    cin>>k>>a>>b;
    int count=0;
//string类型的变量 变量名字.size()：获得变量的长度。
    for(int i=0;i<a.size();i++)
    {
        if(a[i]==b[i]) count++;
    }
    if((double)count/a.size()>=k) cout<<"yes";
    else cout<<"no";
    return 0;
}

9.忽略大小写比较字符串大小

一般我们用 strcmp 可比较两个字符串的大小，比较方法为对两个字符串从前往后逐个字符相比较（按 ASCII 码值大小比较），直到出现不同的字符或遇到 \0 为止。

如果全部字符都相同，则认为相同；如果出现不相同的字符，则以第一个不相同的字符的比较结果为准；如果两字符串长度不同，但所有相同位置的字符均相同，则认为较长字符串更大。

在有些时候，我们比较字符串的大小时，希望忽略字母的大小，例如 Hello 和 hello 在忽略字母大小写时是相等的。

请写一个程序，实现对两个字符串进行忽略字母大小写的大小比较。

输入格式

输入为两行，每行一个字符串，共两个字符串。

注意字符串中仅可能包含大小写字母和空格。

输出格式

如果第一个字符串比第二个字符串小，输出一个字符 <。

如果第一个字符串比第二个字符串大，输出一个字符 >。

如果两个字符串相等，输出一个字符 =。

数据范围

每个字符串的长度范围 [1,80][1,80]。

输入样例1：

Hello
hello

输出样例1：

输入样例2：

How are you
How old are you

输出样例2：

参考代码：

题意将两个字符串进行不区分大小写的比较，因为小写字母-32就是它对应的大写字母。

可以都转换成大写字母来计算。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
   char a[101],b[101];
   
   fgets(a,101,stdin);
   fgets(b,101,stdin);
//先判断最后一个字符是否为换行符，若是的话改成0，因为后续要对每个字符小写转大写
   if(a[strlen(a)-1]=='\n') a[strlen(a)-1]=0;
    if(b[strlen(b)-1]=='\n') b[strlen(b)-1]=0;
    for(int i=0;a[i];i++)
    {
        if(a[i]>='a' && a[i]<='z')
        a[i]-=32;
    }
    for(int i=0;b[i];i++)
    {
        if(b[i]>='a' && b[i]<='z')
        b[i]-=32;
    }
    if(strcmp(a,b)==0) printf("=");
    else if(strcmp(a,b)<0) printf("<");
    else printf(">");
    return 0;
}

10.去掉多余的空格

输入一个字符串，字符串中可能包含多个连续的空格，请将多余的空格去掉，只留下一个空格。

输入格式

共一行，包含一个字符串。

输出格式

输出去掉多余空格后的字符串，占一行。

数据范围

输入字符串的长度不超过 200。
保证输入字符串的开头和结尾没有空格。

输入样例：

Hello      world.This is    c language.

输出样例：

Hello world.This is c language.

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string a;
//因为cout输出每次遇到空格就会停止，所以每次输入完一个完整的单词要输入空格的时候
//会自动停止输入并且输出已经输入的字符，再加一个空格就好。
   while(cin>>a) cout<<a<<' ';
    return 0;
}

11.信息加密

在传输信息的过程中，为了保证信息的安全，我们需要对原信息进行加密处理，形成加密信息，从而使得信息内容不会被监听者窃取。

现在给定一个字符串，对其进行加密处理。

加密的规则如下：

字符串中的小写字母，a 加密为 b，b 加密为 c，…，y 加密为 z，z 加密为 a。
字符串中的大写字母，A 加密为 B，B 加密为 C，…，Y 加密为 Z，Z加密为 A。
字符串中的其他字符，不作处理。

请你输出加密后的字符串。

输入格式

共一行，包含一个字符串。注意字符串中可能包含空格。

输出格式

输出加密后的字符串。

数据范围

输入字符串的长度不超过 100。

输入样例：

Hello! How are you!

输出样例：

Ifmmp! Ipx bsf zpv!

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string a;
    getline(cin,a);
    for(int i=0;a[i];i++)
    {
        if(a[i]>='a' && a[i]<='z')
//因为每个单词都往后平移，但z平移到a相当于a-z或A-Z组成一个圆环，每个一次往后平移
//可以用当前字符-a或A（转换成数字）+1 后在%26得到平移后的字符。
        a[i]=(a[i]-'a'+1)%26+'a';
       else if(a[i]>='A' && a[i]<='Z')
        a[i]=(a[i]-'A'+1)%26+'A';
    }
    cout<<a;
    return 0;
}

12.输出字符串

给定一个字符串 a，请你按照下面的要求输出字符串 b。

给定字符串 a 的第一个字符的 ASCII 值加第二个字符的 ASCII 值，得到 b 的第一个字符；

给定字符串 a 的第二个字符的 ASCII 值加第三个字符的 ASCII 值，得到 b 的第二个字符；

…

给定字符串 a 的倒数第二个字符的 ASCII 值加最后一个字符的 ASCII 值，得到 b 的倒数第二个字符；

给定字符串 a 的最后一个字符的 ASCII 值加第一个字符的 ASCII 值，得到 b 的最后一个字符。

输入格式

输入共一行，包含字符串 a。注意字符串中可能包含空格。

数据保证字符串内的字符的 ASCII 值均不超过 63。

输出格式

输出共一行，包含字符串 b。

数据范围

2≤a的长度≤100

输入样例：

1 2 3

输出样例：

QRRSd

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string a,b;
//因为包含空格，所以用getline（cin，字符串名）来读取
    getline(cin,a);
//相当于首字符-尾端连起来组成一个圆环，每个字符变成加后面一个字符ASCII码的值。
    for(int i=0;i<a.size();i++) b+=(char)a[i]+a[(i+1)%a.size()];
    cout<<b;
    return 0;
}

13.单词替换

输入一个字符串，以回车结束（字符串长度不超过 100）。

该字符串由若干个单词组成，单词之间用一个空格隔开，所有单词区分大小写。

现需要将其中的某个单词替换成另一个单词，并输出替换之后的字符串。

输入格式

输入共 3行。

第 1 行是包含多个单词的字符串 s;

第 2 行是待替换的单词 a(长度不超过 100);

第 3行是 a 将被替换的单词 b(长度不超过 100)。

输出格式

共一行，输出将 s中所有单词 a 替换成 b 之后的字符串。

输入样例：

You want someone to help you
You
I

输出样例：

I want someone to help you

参考代码：

#include <iostream>
#include <sstream>
using namespace std;
int main()
{
     string s,a,b;
//因为s中读取包含空格所以用getline（）
     getline(cin,s);
     cin>>a>>b;
//先将s保存在数据流ssin中
     stringstream ssin(s);
     string str;
//再将s依次读入到str
     while(ssin >> str) 
     if(str==a) cout<<b<<' ';
     else cout<<str<<' ';
    return 0;
}

*14.字符串中最长的连续出现的字符

求一个字符串中最长的连续出现的字符，输出该字符及其出现次数，字符串中无空白字符（空格、回车和 tab），如果这样的字符不止一个，则输出第一个。

输入格式

第一行输入整数 N，表示测试数据的组数。

每组数据占一行，包含一个不含空白字符的字符串，字符串长度不超过 200。

输出格式

共一行，输出最长的连续出现的字符及其出现次数，中间用空格隔开。

输入样例：

2
aaaaabbbbbcccccccdddddddddd
abcdefghigk

输出样例：

d 10
a 1

参考代码：

#include <iostream>
using namespace std;
int main()
{
  int n=0;
  cin>>n;
                    
  while(n--)
  {
        string s; 
      cin>>s;
      int count=0; char c;
      for(int i=0;i<s.size();i++)
      {
          int j=i;
          while(j<s.size()  && s[i]==s[j]) j++;
          if(j-i>count) 
          {
              count=j-i;
              c=s[i];
          }
          i=j-1;
      }
      cout<<c<<' '<<count<<endl;
  }
    return 0;
}

15.最长单词

一个以 . 结尾的简单英文句子，单词之间用单个空格分隔，没有缩写形式和其它特殊形式，求句子中的最长单词。

输入格式

输入一行字符串，表示这个简单英文句子，长度不超过 500。

输出格式

该句子中最长的单词。如果多于一个，则输出第一个。

输入样例：

I am a student of Peking University.

输出样例：

University

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string str,rea;
    while(cin>>str)
    {
//将每次读取的单词当作一个字符进行判断
//若为.则删除，然后每次比较新读取的和之前存的最长字符串的长度。

        if(str.back()=='.') str.pop_back();
        if(str.size()>rea.size()) rea=str;
    }
    cout<<rea<<endl;
    return 0;
}

16.倒排单词

编写程序，读入一行英文(只包含字母和空格，单词间以单个空格分隔)，将所有单词的顺序倒排并输出，依然以单个空格分隔。

输入格式

输入为一个字符串（字符串长度至多为 100）。

输出格式

输出为按要求排序后的字符串。

输入样例：

I am a student

输出样例：

student a am I

参考代码：

#include <iostream>
using namespace std;
int main()
{
开一个string数组，每个元素都是sring类型。
    string s[100];
    int n=0;
//将每个单词当作一个字符串读入
    while(cin>>s[n]) n++;
//倒着输出每个字符
    for(int i=n-1;i>=0;i--)
    {
        cout<<s[i]<<' ';
    }
    return 0;
}

*17.字符串移位包含问题

对于一个字符串来说，定义一次循环移位操作为：将字符串的第一个字符移动到末尾形成新的字符串。

给定两个字符串 s1 和 s2，要求判定其中一个字符串是否是另一字符串通过若干次循环移位后的新字符串的子串。

例如 CDAA 是由 AABCD 两次移位后产生的新串 BCDAA 的子串，而 ABCD 与 ACBD 则不能通过多次移位来得到其中一个字符串是新串的子串。

输入格式

共一行，包含两个字符串，中间由单个空格隔开。

字符串只包含字母和数字，长度不超过 30。

输出格式

如果一个字符串是另一字符串通过若干次循环移位产生的新串的子串，则输出 true，否则输出 false。

输入样例：

AABCD CDAA

输出样例：

true

参考代码：

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
    string a,b;
    cin>>a>>b;
    if(a.size()<b.size()) swap(a,b);
    for(int i=0;i<a.size();i++)
    {
        a=a.substr(1)+a[0];
        for(int j=0;j+b.size()<=a.size();j++)
        {
            int k=0;
            for(;k<b.size();k++)
                if(a[j+k]!=b[k])
                   break;
                   if(k==b.size())
                   {
                       puts("true");
                       return 0;
                   }
        }
    }
    puts("false");
    return 0;
}

*18.字符串乘方

给定两个字符串 a和 b，我们定义 a×b 为他们的连接。

例如，如果 a=abc 而 b=def，则 a×b=abcdef。

输入格式

输入包含不超过 1010 组测试样例，每组测试样例占一行。

每组样例包含一个由小写字母构成的字符串 s，s 的长度不超过 100，且不包含空格。

最后的测试样例后面将是一个点号作为一行。

输出格式

对于每一个 s，你需要输出最大的 n，使得存在一个字符串 a，让 s=a^n。

输入样例：

abcd
aaaa
ababab
.

输出样例：

1
4
3

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string str;
    while(cin>>str,str!=".")
    {
        int len=str.size();
        for(int n=len;n;n--)
        {
            int m=len/n;
            string s=str.substr(0,m);
            string r;
            for(int j=0;j<n;j++)  r+=s;
            if(r==str) 
            {
                cout<<n<<endl;
                break;
            }
        }
    }
    return 0;
}

*19.字符串最大跨距

有三个字符串 S,S1,S2，其中，S 长度不超过 300300，S1 和 S2 的长度不超过 10。

现在，我们想要检测 S1 和 S2是否同时在 S 中出现，且 S1 位于 S2 的左边，并在 S 中互不交叉（即，S1的右边界点在 S2 的左边界点的左侧）。

计算满足上述条件的最大跨距（即，最大间隔距离：最右边的 S2 的起始点与最左边的 S1 的终止点之间的字符数目）。

如果没有满足条件的 S1，S2存在，则输出 −1。

例如，S=�= abcd123ab888efghij45ef67kl, S1= ab, S2= ef，其中，S1 在 S 中出现了 2次，S2也在 S中出现了 2次，最大跨距为：18。

输入格式

输入共一行，包含三个字符串 S,S1,S2，字符串之间用逗号隔开。

数据保证三个字符串中不含空格和逗号。

输出格式

输出一个整数，表示最大跨距。

如果没有满足条件的 S1和 S2 存在，则输出 −1。

输入样例：

abcd123ab888efghij45ef67kl,ab,ef

输出样例：

参考代码：

#include <iostream>
using namespace std;
int main()
{
    string s,s1,s2;
    char c;
    while(cin>>c,c!=',') s+=c;
    while(cin>>c,c!=',') s1+=c;
    while(cin>>c) s2+=c;
    if(s.size()<s1.size() || s.size()<s2.size()) puts("-1");
    else
    {
        int l=0;
        while(l+s1.size()<=s.size())
        {
            int k=0;
            while(k<s1.size())
            {
                if(s[l+k]!=s1[k]) break;
                k++;
            }
            if(k==s1.size()) break;
            l++;
        }
        int r=s.size()-s2.size();
        while(r+s2.size()<=s.size())
        {
            int k=0;
            while(k<s2.size())
            {
                if(s[r+k]!=s2[k]) break;
                k++;
            }
            if(k==s2.size()) break;
            r--;
        }
        l+=s1.size()-1;
        if(l>=r) puts("-1");
        else printf("%d",r-l-1);
    }
    return 0;
}

*20. 最长公共字符串后缀

给出若干个字符串，输出这些字符串的最长公共后缀。

输入格式

由不超过 5 组输入组成。

每组输入的第一行是一个整数 N。

N 为 0 时表示输入结束，否则后面会继续有 N 行输入，每行是一个字符串（字符串内不含空白符）。

每个字符串的长度不超过 200。

输出格式

每组数据输出一行结果，为 N 个字符串的最长公共后缀（可能为空）。

数据范围

1≤N≤200

输入样例：

3
baba
aba
cba
2
aa
cc
2
aa
a
0

输出样例：

ba

a

参考代码：

#include <iostream>
using namespace std;
const int N=200;
int n;
string str[N];
int main()
{
    while(cin>>n,n)
    {
        int len=1000;
        for(int i=0;i<n;i++)
        {
            cin>>str[i];
            if(len>str[i].size()) len=str[i].size();
        }
    while(len)
    {
        bool success=true;
        for(int i=1;i<n;i++)
        {
            bool is_same=true;
            for(int j=1;j<=len;j++)
                if(str[0][str[0].size()-j]!=str[i][str[i].size()-j])
                {
                    is_same=false;
                    break;
                }
                if(!is_same)
                {
                    success=false;
                    break;
                }
       }
            if(success) break;
            len--;
    }
        cout<<str[0].substr(str[0].size()-len)<<endl;
    }
    return 0;
}

函数

1.n的阶乘

输入一个整数 n，请你编写一个函数，int fact(int n)，计算并输出 n 的阶乘。

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数表示 n 的阶乘的值。

数据范围

1≤n≤10

输入样例：

输出样例：

参考代码：

#include <iostream>
using namespace std;

int fact(int n)
{
//递归函数自己调用自己
    if(n==1) return 1;
    return n*fact(n-1);
}

int main()
{
    int n;
    cin>>n;
    cout<<fact(n)<<endl;
    return 0;
}

2.x和y的最大值

输入两个整数 x 和 y，请你编写一个函数，int max(int x, int y)，计算并输出 x 和 y的最大值。

输入格式

共一行，包含两个整数 x 和 y。

输出格式

共一行，包含一个整数，表示两个数中较大的那个数。

数据范围

−100≤x,y≤100

输入样例：

3 6

输出样例：

参考代码：

#include <iostream>
using namespace std;

int max(int a,int b)
{
    if(a>b) return a;
    return b;
}

int main()
{
    int a,b;
    cin>>a>>b;
    cout<<max(a,b);
    return 0;
}

3.最大公约数

输入两个整数 a 和 b，请你编写一个函数，int gcd(int a, int b), 计算并输出 a 和 b 的最大公约数。

输入格式

共一行，包含两个整数 a 和 b。

输出格式

共一行，包含一个整数，表示 a和 b 的最大公约数。

数据范围

1≤a,b≤1000

输入样例：

12 16

输出样例：

参考代码：

#include <iostream>
using namespace std;

int gcd(int a,int b)
//辗转相除法
{
   return b ? gcd(b,a%b) : a;
}

int main()
{
    int a,b;
    cin>>a>>b;
    cout<<gcd(a,b);
    return 0;
}

4.交换数值

输入两个整数 x和 y，请你编写一个函数, 交换两个整数的数值并输出交换后的 x 和 y。

C++中的格式为：void swap(int &x, int &y)。

Java中的格式为：void swap(int[] a)，交换a[0]和a[1]。

输入格式

共一行，包含两个整数 x和 y。

输出格式

共一行，包含交换后的 x 和 y。

数据范围

1≤x,y≤100

输入样例：

3 5

输出样例：

5 3

参考代码：

#include <iostream>
using namespace std;

void swap(int &a,int &b)
{
    
        int t=a;
        a=b;
        b=t;
}

int main()
{
    int a,b;
    cin>>a>>b;
    swap(a,b);
    cout<<a<<' '<<b;
    return 0;
}

5.打印数字

输入一个长度为 n 的数组 a 和一个整数 size，请你编写一个函数, void print(int a[], int size), 打印数组 a中的前 size 个数。

注意：对于Python语言，print是内置函数，所以本题中使用print1D()这个函数名，来避免跟内置函数产生冲突。

输入格式

第一行包含两个整数 n 和 size。

第二行包含 n 个整数 a[i]，表示整个数组。

输出格式

共一行，包含 size个整数，表示数组的前 size 个数。

数据范围

1≤n≤1000,
1≤size≤n

输入样例：

5 3
1 2 3 4 5

输出样例：

1 2 3

参考代码：

#include <iostream>
using namespace std;

int a[1000];

void size(int m)
{
    for(int i=0;i<m;i++)
    {
        cout<<a[i]<<" ";
    }
}
int main()
{
    int n ,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        cin>>a[i];
    }
    size(m);
    return 0;
}

6.打印矩阵

给定一个 row×col 的二维数组 a，请你编写一个函数，void print2D(int a[][N], int row, int col)，打印数组构成的 row 行，col列的矩阵。

注意，每打印完一整行需要输出一个回车。

输入格式

第一行包含两个整数 row,col。

接下来 row行，每行包含 col 个整数，表示完整二维数组 a。

输出格式

共 row 行，每行 col 个整数，表示打印出的矩阵。

数据范围

1≤row≤100,
1≤col≤100

输入样例：

输出样例：

1 3 4 5
2 6 9 4
1 4 7 5

参考代码：

#include <iostream>
using namespace std;
int a[100][100];
void print(int n,int m)
{
    for(int i=0;i<n;i++)
    {
    for(int j=0;j<m;j++)
    {
    cout<<a[i][j]<<' ';
    }
    cout<<endl;
    }
}

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            cin>>a[i][j];
        }
    }
    print(n,m);
    return 0;
}

7.递归求阶乘

请使用递归的方式求 n的阶乘。

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数，表示 n的阶乘的值。

数据范围

1≤n≤10

输入样例：

输出样例：

参考代码：

#include <iostream>
using namespace std;

int fun(int n)
{
    if(n==1) return 1;
    return n*fun(n-1);
}

int main()
{
    int n;
    cin>>n;
    cout<<fun(n);
    return 0;
}

8. 递归求斐波那契数列

请使用递归的方式求斐波那契数列的第 n项，下标从1开始。

斐波那契数列：1,1,2,3,5…，这个数列从第 3 项开始，每一项都等于前两项之和

输入格式

共一行，包含整数 n。

输出格式

共一行，包含一个整数，表示斐波那契数列的第 n项。

数据范围

1≤n≤30

输入样例：

输出样例：

参考代码：

#include <iostream>
using namespace std;

int fub(int n)
{
    if(n<=2) return 1;
    return fub(n-1)+fub(n-2);
}

int main()
{
    int n;
    cin>>n;
    cout<<fub(n);
    return 0;
}

9.绝对值

输入一个整数 x，请你编写一个函数，int abs(int x)，输出 x 的绝对值。

输入格式

共一行，包含一个整数 x。

输出格式

共一行，包含 x的绝对值。

数据范围

−100≤x≤100

输入样例：

-3

输出样例：

参考代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
int main()
{
    int n;
    cin>>n;
    cout<<abs(n)<<endl;
    return 0;
}

10.两个数的和

输入两个浮点数 x 和 y，请你编写一个函数，double add(double x, double y)，计算并输出 x与 y 的和。

输入格式

共一行，包含两个浮点数 x 和 y。

输出格式

共一行，包含一个浮点数，表示两个数的和，结果保留 2 位小数。

数据范围

−1000≤x,y≤1000

输入样例：

1.11 2.22

输出样例：

3.33

参考代码：

#include <cstdio>
double add(double a,double b)
{
    return a+b;
}
int main()
{
    double a,b;
    scanf("%lf %lf",&a ,&b);
    printf("%.2lf",add(a,b));
    return 0;
}

11.区间求和

输入两个整数 l 和 r，请你编写一个函数，int sum(int l, int r)，计算并输出区间 [l,r]内所有整数的和。

输入格式

共一行，包含两个整数 l 和 r。

输出格式

共一行，包含一个整数，表示所求的和。

数据范围

1≤l≤r≤1000

输入样例：

3 5

输出样例：

参考代码：

#include <iostream>
using namespace std;

int add(int n,int m)
{
    int sum=0;
    for(int i=n;i<=m;i++)
    {
        sum+=i;
    }
    return sum;
}

int main()
{
    int n,m; cin>>n>>m;
    cout<<add(n,m);
    return 0;
}

12.最小公倍数

输入两个整数 a 和 b，请你编写一个函数，int lcm(int a, int b)，计算并输出 a 和 b 的最小公倍数。

输入格式

共一行，包含两个整数 a和 b。

输出格式

共一行，包含一个整数，表示 a 和 b的最小公倍数。

数据范围

1≤a,b≤1000

输入样例：

6 8

输出样例：

参考代码：

#include <iostream>
using namespace std;
int gcd(int a,int b)
{
    return b ? gcd(b,a%b) : a;
}
int main()
{
    int n,m;
    cin>>n>>m;
//n和m最小公倍数=n*m / n和m的最大公约数。
    cout<<(n*m)/gcd(n,m);
    return 0;
}

13.复制数组

给定两个数组 a 和 b 以及一个整数 size，请你编写一个函数，void copy(int a[], int b[], int size)，将 a 数组中的前 size个数字，复制到 b 数组中。

复制完成后，输出 b 数组。

输入格式

第一行包含整数 n,m,size，分别表示 a 数组的长度，b数组的长度以及整数 size。

第二行包含 n 个整数，表示数组 a。

第三行包含 m 个整数，表示数组 b。

输出格式

共一行，包含 m 个整数，表示复制完成后的数组 b。

数据范围

1≤n≤m≤100,
1≤size≤n

输入样例：

3 5 2
1 2 3
4 5 6 7 8

输出样例：

1 2 6 7 8

参考代码：

#include <iostream>
using namespace std;
//题中的复制可以理解为将b的前n和更换为a的前n个数。
void copy(int a[],int b[],int size,int m)
{
    for(int i=0;i<size;i++) b[i]=a[i];
     for(int i=0;i<m;i++) cout<<b[i]<<' ';
}

int main()
{
    int n,m,size;
    cin>>n>>m>>size;
    int a[n],b[m];
    for(int i=0;i<n;i++) cin>>a[i];
    for(int i=0;i<m;i++) cin>>b[i];
    copy(a,b,size,m);
    return 0;
}

14.打印字符串

给定一个字符串，请你编写一个函数，void print(char str[])，将这个字符串打印出来。

注意：对于Python语言，print是内置函数，所以本题中使用print_str()这个函数名，来避免跟内置函数产生冲突。

输入格式

共一行，包含一个字符串。

输出格式

共一行，表示打印出的字符串。

数据范围

1≤字符串长度≤100

输入样例：

I love C++.

输出样例：

I love C++.

参考代码：

#include <iostream>
using namespace std;

void print(string s)
{
    cout<<s;
}
int main()
{
    string s;
//因为可能包含空格所以用getline（cin，字符串名）
    getline(cin,s);
    print(s);
    return 0;
}

15.数组翻转

给定一个长度为 n 的数组 a 和一个整数 size，请你编写一个函数，void reverse(int a[], int size)，实现将数组 a 中的前 size 个数翻转。

输出翻转后的数组 a。

输入格式

第一行包含两个整数 n和 size。

第二行包含 n个整数，表示数组 a。

输出格式

共一行，包含 n 个整数，表示翻转后的数组 a。

数据范围

1≤size≤n≤1000,
1≤a[i]≤1000

输入样例：

5 3
1 2 3 4 5

输出样例：

3 2 1 4 5

参考代码：

#include <iostream>
using namespace std;
//相当于把12345变成54321
//此函数将1和5，2和4进行交换。
void reserve(int a[],int size)
{
    for(int i=0,j=size-1;i<j;i++,j--)
    swap(a[i],a[j]);
}
int main()
{
    int n,size;
    cin>>n>>size;
    int a[1000];
    for(int i=0;i<n;i++) cin>>a[i];
     reserve(a,size);
     for(int i=0;i<n;i++) cout<<a[i]<<' ';
    return 0;
}

16.数组去重

给定一个长度为 n 的数组 a，请你编写一个函数：

int get_unique_count(int a[], int n);  // 返回数组前n个数中的不同数的个数

输入格式

第一行包含一个整数 n。

第二行包含 n 个整数，表示数组 a。

输出格式

共一行，包含一个整数表示数组中不同数的个数。

数据范围

1≤n≤1000,
1≤ai≤1000。

输入样例：

5
1 1 2 4 5

输出样例：

参考代码：

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

//排序玩的数组，依次遍历，找相邻两数是否不等
//不等则k++（k用来记录不相等的数量）
int fun(int a[],int n)
{
    int k=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]!=a[k-1])
            a[k++]=a[i];
    }
    return k;
}
int main()
{
    int n;
    cin>>n;
    int a[1000];
    for(int i=0;i<n;i++) cin>>a[i];
//sort（数组名，数组名+数组长度）将数组从小打到排序的函数。
    sort(a,a+n);
    cout<<fun(a,n);
    return 0;
}

17.数组排序

给定一个长度为 n 的数组 a 以及两个整数 l 和 r，请你编写一个函数，void sort(int a[], int l, int r)，将 a[l]∼a[r] 从小到大排序。

输出排好序的数组 a。

输入格式

第一行包含三个整数 n，l，r。

第二行包含 n 个整数，表示数组 a。

输出格式

共一行，包含 n 个整数，表示排序完成后的数组 a。

数据范围

0≤l≤r<n≤1000

输入样例：

5 2 4
4 5 1 3 2

输出样例：

4 5 1 2 3

参考代码：

#include <iostream>
using namespace std;

void sort(int a[],int l,int r)
{
//冒泡排序：
    for(int i=l;i<=r;i++)
    {
        for(int j=i+1;j<=r;j++)
        {
            if(a[i]>a[j])
            {
              swap(a[i],a[j]);
            }
        }
    }
}
int main()
{
    int a[1000];
    int n,l,r;
    cin>>n>>l>>r;
    for(int i=0;i<n;i++) cin>>a[i];
    sort(a,l,r);
    for(int i=0;i<n;i++) cout<<a[i]<<' ';
    return 0;
}

*18.跳台阶

一个楼梯共有 n 级台阶，每次可以走一级或者两级，问从第 0 级台阶走到第 n 级台阶一共有多少种方案。

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数，表示方案数。

数据范围

1≤n≤15

输入样例：

输出样例：

参考代码：

#include <iostream>

using namespace std;
int n;
int ans;

void fun(int k)
{
    if(k==n) ans++;
    else if(k<n)
    {
        fun(k+1);
        fun(k+2);
    }
}
int main()
{
    cin>>n;
    fun(0);
    cout<<ans;
    return 0;
}

19. 走方格

给定一个 n×m 的方格阵，沿着方格的边线走，从左上角 (0,0) 开始，每次只能往右或者往下走一个单位距离，问走到右下角 (n,m)一共有多少种不同的走法。

输入格式

共一行，包含两个整数 n 和 m。

输出格式

共一行，包含一个整数，表示走法数量。

数据范围

1≤n,m≤10

输入样例：

2 3

输出样例：

参考代码:

#include <iostream>
using namespace std;
int ans;
int n,m;

void fun(int a,int b)
{
    if(a==n && b==m) ans++;
    else  
    {
//每一步有两种走法：向下或向右
//但每次需要判断是否越界
       if(a<n) fun(a+1,b);
       if(b<m) fun(a,b+1);
    }
}
int main()
{
   cin>>n>>m;
   fun(0,0);
   cout<<ans;
    return 0;
}

*20.排列（DFS）

给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。

现在，请你按照字典序将所有的排列方法输出。

输入格式

共一行，包含一个整数 n。

输出格式

按字典序输出所有排列方案，每个方案占一行。

数据范围

1≤n≤9

输入样例：

输出样例：

参考代码：

#include <iostream>
using namespace std;

const int N=10;
int n;

void dfs(int u,int nums[],bool st[])
{
    if(u>n) 
    {
        for(int i=1;i<=n;i++) cout<<nums[i]<<' ';
        cout<<endl;
    }
    else
    {
        for(int i=1;i<=n;i++)
        {
            if(!st[i])
            {
                st[i]=true;
                nums[u]=i;
                dfs(u+1,nums,st);
                st[i]=false;
            }
        }
    }
}
int main()
{
    cin>>n;
    int nums[N];
    bool st[N]={0};
    dfs(1,nums,st);
    return 0;
}