OJ输入输出总结

╰半橙微兮° 2022-12-13 12:51 451阅读 0赞

### OJ输入输出总结 ###

*   *  0.牛客练习场
     *  1.标准输入输出
     *   *  1.1.cin>>
         *  1.2.cin.get()不带参数
         *  1.3.cin.get(ch)带一个参数
         *  1.4.cin.get(字符数组， 字符个数n, 终止字符)带三个参数
         *  1.5.cin.getline()
         *  1.6.getline(cin,str)
     *  2.文件输入输出
     *   *  2.1.文件流类与文件流对象
         *  2.2.打开(输出)文件
         *  2.3.关闭文件
     *  3.字符串流的读写
     *   *  3.1.概念
         *  3.2.建立输入输出字符串流对象
     *  4.OJ.IO练习

## 0.牛客练习场 ##

*  [牛客练习场][Link 1]

## 1.标准输入输出 ##

*  [参考][Link 2]
 *  cin是istream类的对象
 *  cout不是C++预定义的关键字，是ostream流类的对象

cin、cout为流对象，类中还有许多函数可以调用。如cin.get()等 。

![在这里插入图片描述][20201011205233353.png_pic_center]

按照格式输出：

#include <iostream>
    #include <iomanip>//不要忘记包含此头文件
    using namespace std;
    int main()
    {
        
       int a;
       cout<<"input a:";
       cin>>a;
       cout<<"dec:"<<dec<<a<<endl;  //以十进制形式输出整数
       cout<<"hex:"<<hex<<a<<endl;  //以十六进制形式输出整数a
       cout<<"oct:"<<setbase(8)<<a<<endl;  //以八进制形式输出整数a
       char *pt="China";  //pt指向字符串"China"
       cout<<setw(10)<<pt<<endl;  //指定域宽为,输出字符串
       cout<<setfill('*')<<setw(10)<<pt<<endl;  //指定域宽,输出字符串,空白处以'*'填充
       double pi=22.0/7.0;  //计算pi值
       //按指数形式输出,8位小数
       cout<<setiosflags(ios::scientific)<<setprecision(8);
       cout<<"pi="<<pi<<endl;  //输出pi值
       cout<<"pi="<<setprecision(4)<<pi<<endl;  //改为位小数
       cout<<"pi="<<setiosflags(ios::fixed)<<pi<<endl;  //改为小数形式输出
       return 0;
    }

### 1.1.cin>> ###

cin>>当读取字符串的时候需要注意，cin不能读取空白字符，比如空格，如果遇到空格则会直接终止字符串。

当遇到无效字符或遇到文件结束符（不是换行符，是文件中的数据已读完）时，输入流cin就处于出错状态，即无法正常提取数据。此时对cin流的所有提取操作将终止。在 IBM PC及其兼容机中，以Ctrl + Z表示文件结束符。在UNIX和Macintosh系统中，以 Ctrl + D表示文件结束符。当输入流cin处于出错状态时，如果测试cin的值，可以发现它的值为false(假)，即cin为0值。如果输入流在正常状态，cin的值为true(真)，即cin为 一个非0值。可以通过测试cin的值，判断流对象是否处于正常状态和提取操作是否成功。

可用于判断：`while(cin>>a)`

#include <iostream>
    #include <string>
    using namespace std;
    int main() {
        
    	string s;
    	cin >> s; // 读到空白就结束当前的字符串
    	cout << s;
    	return 0;
    }

### 1.2.cin.get()不带参数 ###

#include <iostream>
    using namespace std;
    int main( )
    {
        
       int c;
       cout<<"enter a sentence:"<<endl;
       while((c=cin.get())!=EOF)//不带参数的cin.get(),返回值为读入的字符
          cout.put(c);
       return 0;
    }

### 1.3.cin.get(ch)带一个参数 ###

从输入流中读取一个字符，赋给字符变量ch。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。

#include <iostream>
    using namespace std;
    int main( )
    {
        
       char c;
       cout<<"enter a sentence:"<<endl;
       while(cin.get(c))  //读取一个字符赋给字符变量c,如果读取成功,cin.get(c)为真
       {
        
       		cout.put(c);	
       }
       cout<<"end"<<endl;
       return 0;
    }

### 1.4.cin.get(字符数组， 字符个数n, 终止字符)带三个参数 ###

#include <iostream>
    using namespace std;
    int main( )
    {
        
       char ch[20];
       cout<<"enter a sentence:"<<endl;
       cin.get(ch,10,'\\n');//指定换行符为终止字符
      cout<<ch<<endl;
       return 0;
    }

get函数中第3个参数可以省写，此时默认为’\\n’。下面两行等价：

cin.get(ch,10,'\\n');
       cin.get(ch,10);

终止字符也可以用其他字符。如

cin.get(ch,10,'x');

在遇到字符’x’时停止读取操作。

### 1.5.cin.getline() ###

`getline`函数的作用是从输入流中读取一行字符,其用法与带3个参数的get函数类似。即 `cin.getline(字符数组(或字符指针), 字符个数n, 终止标志字符)`

#include <iostream>
    using namespace std;
    int main( )
    {
        
       char ch[20];
       cout<<"enter a sentence:"<<endl;
       cin>>ch;
       cout<<"The string read with cin is:"<<ch<<endl;
       cin.getline(ch,20,'/');  //读个字符或遇'/'结束
       cout<<"The second part is:"<<ch<<endl;
       cin.getline(ch,20);  //读个字符或遇'/n'结束
       cout<<"The third part is:"<<ch<<endl;
       return 0;
    }

### 1.6.getline(cin,str) ###

getline(cin,str)，读取整行数据到str中.

#include <iostream>
    #include <string>
    using namespace std;
    int main() {
        
    	string s;
    	getline(cin, s);
    	cout << s;	
    	system("pause");
    	return 0;
    }

## 2.文件输入输出 ##

### 2.1.文件流类与文件流对象 ###

类比标准输入输出流类istream、ostream和iostream类，有3个用于文件操作的文件类：

*  ifstream类，它是从istream类派生的，用来支持从磁盘文件的输入。
 *  ofstream类，它是从ostream类派生的，用来支持向磁盘文件的输出。
 *  fstream类，它是从iostream类派生的，用来支持对磁盘文件的输入输出。

对磁盘文件的操作是通过文件流对象（而不是cin和cout）实现的。文件流对象是用文件流类定义的，而不是用istream和ostream类来定义的。可以用下面的方法建立一个输出文件流对象： `ofstream outfile;`

如同在头文件iostream中定义了流对象cout —样，现在在程序中定义了outfile为 ofstream类（输出文件流类）的对象。

### 2.2.打开(输出)文件 ###

**1) 调用文件流的成员函数open**

ofstream outfile;  //定义ofstream类(输出文件流类)对象outfile
        outfile.open("f1.dat",ios::out);  //使文件流与f1.dat文件建立关联

调用成员函数open的一般形式为： **文件流对象.open(磁盘文件名, 输入输出方式);**

**2) 在定义文件流对象时指定参数**  
`ostream outfile("f1.dat",ios::out);`一般多用此形式，比较方便。作用与open函数相同。

> ios::in 以输入方式打开文件  
> ios::out 以输出方式打开文件（这是默认方式），如果已有此名字的文件，则将其原有内容全部清除  
> ios::app 以输出方式打开文件，写入的数据添加在文件末尾  
> ios::ate 打开一个已有的文件，文件指针指向文件末尾  
> ios: :trunc 打开一个文件，如果文件已存在，则删除其中全部数据，如文件不存在，则建立新文件。如已指定了 ios::out 方式，而未指定ios: :app，ios::ate，ios: :in，则同时默认此方式  
> ios:: binary 以二进制方式打开一个文件，如不指定此方式则默认为ASCII方式  
> ios::nocreate 打开一个已有的文件，如文件不存在，则打开失败。nocrcate的意思是不建立新文件  
> ios:: noreplace 如果文件不存在则建立新文件，如果文件已存在则操作失败，replace 的意思是不更新原有文件  
> ios::in l ios::out 以输入和输出方式打开文件，文件可读可写  
> ios:: out | ios::binary 以二进制方式打开一个输出文件  
> ios::in l ios::binar 以二进制方式打开一个输入文件

可以用“位或”运算符“|”对输入输出方式进行组合.

> ios::in | ios:: noreplace //打开一个输入文件，若文件不存在则返回打开失败的信息  
> ios::app | ios::nocreate //打开一个输出文件，在文件尾接着写数据，若文件不存在，则返回打开失败的信息  
> ios::out l ios::noreplace //打开一个新文件作为输出文件，如果文件已存在则返回打开失败的信息  
> ios::in l ios::out I ios::binary //打开一个二进制文件，可读可写

如果打开操作失败，open函数的返回值为0(假)，如果是用调用构造函数的方式打开文件的，则流对象的值为0。可以据此测试打开是否成功。如

if(outfile.open("f1.bat", ios::app) ==0)
           cout <<"open error";

或

if( !outfile.open("f1.bat", ios::app) )
            cout <<"open error";

例子：输出保存。从键盘输入个整数给数组，将此数组送到磁盘文件中存放。

#include <fstream>
    using namespace std;
    int main( )
    {
        
       int a[10];
       ofstream outfile("f1.dat",ios::out);//定义文件流对象,打开磁盘文件"f1.dat"
       if(!outfile)                        //如果打开失败,outfile返回值
       {
        
          cerr<<"open error!"<<endl;
          exit(1);
       }
       cout<<"enter 10 integer numbers:"<<endl;
       for(int i=0;i<10;i++)
       {
        
          cin>>a[i];
          outfile<<a[i]<<" ";
       }            //向磁盘文件"f1.dat"输出数据
       outfile.close();                   //关闭磁盘文件"f1.dat"
       return 0;
    }

例子：输入数据。从上例建立的数据文件f1.dat中读入个整数放在数组中，找出并输出个数中的最大者和它在数组中的序号。

#include <fstream>
    using namespace std;
    int main( )
    {
        
       int a[10],max,i,order;
       //定义输入文件流对象,以输入方式打开磁盘文件f1.dat
       ifstream infile("f1.dat",ios::in|ios::nocreate);
       if(!infile)
       {
        
          cerr<<"open error!"<<endl;
          exit(1);
       }
       for(i=0;i<10;i++)
       {
        
          infile>>a[i];  //从磁盘文件读入10个整数,顺序存放在a数组中
          cout<<a[i]<<" ";  //在显示器上顺序显示10个数
       }         
       cout<<endl;
       max=a[0];
       order=0;
       for(i=1;i<10;i++)
          if(a[i]>max)
          {
        
             max=a[i];  //将当前最大值放在max中
             order=i;  //将当前最大值的元素序号放在order中
          }
       cout<<"max="<<max<<endl<<"order="<<order<<endl;
       infile.close();
       return 0;
    }

例子。将磁盘文件内容读入内存，然后输出到显示器。

#include <fstream>
    using namespace std;
    void display_file(char *filename)
    {
        
       ifstream infile(filename,ios::in|ios::nocreate);
       if(!infile)
       {
        
          cerr<<"open error!"<<endl;
          exit(1);
       }
       char ch;
       while(infile.get(ch))
          cout.put(ch);
       cout<<endl;
       infile.close();
    }
    // 然后在调用时给出文件名即可
    int main( )
    {
        
       display_file("f3.dat");//将f3.dat的入口地址传给形参filename
       return 0;
    }

### 2.3.关闭文件 ###

在对已打开的磁盘文件的读写操作完成后，应关闭该文件。关闭文件用成员函数close。如

outfile.close( );  //将输出文件流所关联的磁盘文件关闭

所谓关闭，实际上是解除该磁盘文件与文件流的关联，原来设置的工作方式也失效，这样，就不能再通过文件流对该文件进行输入或输出。此时可以将文件流与其他磁盘文件建立关联，通过文件流对新的文件进行输入或输出。如

outfile.open("f2.dat",ios::app|ios::nocreate);

## 3.字符串流的读写 ##

### 3.1.概念 ###

*  基类：istream，ostream，iostream
 *  文件流类：ifstream，ofstream，fstream
 *  字符串流类：istrstream，ostrstream，strstream
 *  C++11中字符串流类：sstream

向内存中的一个字符数组写数据就如同向文件写数据一样,但有3点不同：

*  1.输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据。在严格的意义上说，这不属于输入输出，称为读写比较合适。 因为输入输出一般指的是在计算机内存与计算机外的文件（外部设备也视为文件）之间 的数据传送。但由于C++的字符串流采用了 C++的流输入输出机制，因此往往也用输入和输出来表述读写操作。
 *  2.字符串流对象关联的不是文件,而是内存中的一个字符数组,因此不需要打开和关闭文件。
 *  3.每个文件的最后都有一个文件结束符,表示文件的结束。而字符串流所关联的字符数组中没有相应的结束标志,用户要指定一个特殊字符作为结束符,在向字符数组写入全部数据后要写入此字符。

### 3.2.建立输入输出字符串流对象 ###

**(1)将一组数据保存在字符数组中**

#include <strstream>
    using namespace std;
    struct student
    {
        
       int num;
       char name[20];
       float score;
    };
    int main( )
    {
        
       student stud[3]={
        1001,"Li",78,1002,"Wang",89.5,1004,"Fun",90};
       char c[50];  //用户定义的字符数组
       ostrstream strout(c,30);  //建立输出字符串流,与数组c建立关联,缓冲区长
       for(int i=0;i<3;i++)  //向字符数组c写个学生的数据
          strout<<stud[i].num<<stud[i].name<<stud[i].score;
          //strout<<" "<<stud[i].num<<" "<<stud[i].name<<" "<<stud[i].score;
       strout<<ends;  //ends是C++的I/O操作符,插入一个'\\0'
       cout<<"array c:"<<c<<endl;  //显示字符数组c中的字符
    }
    //输出：
    //array c:
    //1001Li781002Wang89.51004Fun90

**(2)在一个字符数组c中存放了50个整数,以空格相间隔,要求将它们放到整型数组中,再按大小排序,然后再存放回字符数组c中**

#include <strstream>
    using namespace std;
    int main( )
    {
        
       char c[50]="12 34 65 -23 -32 33 61 99 321 32";
       int a[10],i,j,t;
       cout<<"array c:"<<c<<endl;  //显示字符数组中的字符串
       istrstream strin(c,sizeof(c));  //建立输入串流对象strin并与字符数组c关联
       for(i=0;i<10;i++)
          strin>>a[i];  //从字符数组c读入个整数赋给整型数组a
       cout<<"array a:";
       for(i=0;i<10;i++)
          cout<<a[i]<<" ";  //显示整型数组a各元素
       cout<<endl;
       for(i=0;i<9;i++)  //用起泡法对数组a排序
          for(j=0;j<9-i;j++)
             if(a[j]>a[j+1])
             {
        t=a[j];a[j]=a[j+1];a[j+1]=t;}
       ostrstream strout(c,sizeof(c));  //建立输出串流对象strout并与字符数组c关联
          for(i=0;i<10;i++)
             strout<<a[i]<<" ";  //将个整数存放在字符数组c
       strout<<ends;  //加入'\\0'
       cout<<"array c:"<<c<<endl;  //显示字符数组c
       return 0;
    }
    //运行结果如下：
    //array c: 12 34 65 -23 -32 33 61 99 321 32    (字符数组c原来的内容)
    //array a: 12 34 65 -23 -32 33 61 99 321 32    (整型数组a的内容)
    //array c: -32 –12 32 33 34 61 65 99 321    (字符数组c最后的内容)

## 4.OJ.IO练习 ##

#include<iostream>
    #include<vector>
    #include<string>
    using namespace std;
    
    /*
    题目描述：输入包括两个正整数a, b(1 <= a, b <= 10 ^ 9), 输入数据包括多组。输出a + b的结果
    输入
    	1 5
    	10 20
    输出
    	6
    	30
    */
    
    int CinTwoInt() {
        
    	int a, b;
    	while (cin >> a >> b) {
        
    		cout << (a + b) << endl;
    	}
    	return 0;
    }
    
    /*
    题目描述：输入第一行包括一个数据组数t(1 <= t <= 100)，接下来每行包括两个正整数a,b(1 <= a, b <= 10^9).输出a+b的结果。
    输入
    	2
    	1 5
    	10 20
    输出
    	6
    	30
    */
    
    int CinTwoInt2() {
        
    	int n;
    	cin >> n;
    	for (int i = 0; i < n; i++)
    	{
        
    		int a, b;
    		cin >> a >> b;
    		cout << (a + b) << endl;
    	}
    	return 0;
    }
    
    
    /*
    题目描述：输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入。输出a+b的结果
    输入
    	1 5
    	10 20
    	0 0
    输出
    	6
    	30
    */
    
    int CinTwoInt3() {
        
    	int a, b;
    	while (cin >> a >> b) {
        
    		if (a == 0 && b == 0)
    			break;
    		cout << a + b << endl;
    	}
    	return 0;
    }
    
    
    /*
    计算一系列数的和:输入数据包括多组。
    每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
    接下来n个正整数,即需要求和的每个正整数。
    输出描述:每组数据输出求和的结果
    
    输入
    	4 1 2 3 4
    	5 1 2 3 4 5
    	0
    输出
    	10
    	15
    */
    
    int CinTwoInt4() {
        
    	int numPerArr;//每个数组元素个数
    	int tmp, sum;
    	while (cin >> numPerArr) {
        
    		sum = 0;
    		if (numPerArr == 0)
    			break;
    		for (int i = 0; i < numPerArr; i++) {
        
    			cin >> tmp;
    			sum += tmp;
    		}
    		cout << sum << endl;
    	}
    	return 0;
    }
    
    /*
    计算一系列数的和:输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
    接下来t行, 每行一组数据。每行的第一个整数为整数的个数n(1 <= n <= 100)。
    接下来n个正整数, 即需要求和的每个正整数。
    输出描述:每组数据输出求和的结果
    
    输入
    	2
    	4 1 2 3 4
    	5 1 2 3 4 5
    输出
    	10
    	15
    */
    
    int CinTwoInt5() {
        
    	int numOfArr;//数组个数
    	int tmp, sum;
    	while (cin >> numOfArr) {
        
    		for (int i = 0; i < numOfArr; i++) {
        
    			int numPerArr;//每个数组元素个数
    			while (cin >> numPerArr) {
        
    				sum = 0;
    				for (int j = 0; j < numPerArr; j++)
    				{
        
    					cin >> tmp;
    					sum += tmp;
    				}
    				cout << sum << endl;
    			}
    		}
    	}
    	return 0;
    }
    
    
    /*
    计算一系列数的和:输入数据有多组, 每行表示一组输入数据。
    每行的第一个整数为整数的个数n(1 <= n <= 100)。
    接下来n个正整数, 即需要求和的每个正整数。
    输出描述:每组数据输出求和的结果
    
    输入
    	4 1 2 3 4
    	5 1 2 3 4 5
    输出
    	10
    	15
    */
    
    int CinTwoInt6() {
        
    	int numPerArr;
    	int tmp, sum;
    	while (cin >> numPerArr) {
        
    		if (numPerArr == 0)
    			break;
    		sum = 0;
    		for (int i = 0; i < numPerArr; i++) {
        
    			cin >> tmp;
    			sum += tmp;
    		}
    		cout << sum << endl;
    	}
    	return 0;
    }
    
    /*
    计算一系列数的和:输入数据有多组, 每行表示一组输入数据。
    每行不定有n个整数，空格隔开。(1 <= n <= 100)。
    输出描述:每组数据输出求和的结果
    
    输入
    	1 2 3
    	4 5
    	0 0 0 0 0
    输出
    	6
    	9
    	0
    */
    int CinTwoInt7() {
        
    	int tmp, sum;
    	sum = 0;
    	while (cin>>tmp) {
        
    		sum += tmp;
    		if (getchar() == '\n') {
        //这里的getchar平时是空格，所以sum+=tmp不能放后面
    			cout << sum << endl;
    			sum = 0;
    		}
    	}
    	return 0;
    }
    
    /*
    对输入的字符串进行排序后输出:输入有两行，第一行n;第二行是n个空格隔开的字符串
    输出描述:输出一行排序后的字符串，空格隔开，无结尾空格
    
    输入
    	5
    	c d a bb e
    输出
    	a bb c d e
    */
    
    #include<algorithm>
    bool cmp(string a, string b) {
        
    	return a > b;
    }
    void stringSort() {
        
    	int numOfStr;
    	string tmpStr;
    	vector<string> res;
    
    	cin >> numOfStr;
    	for (int i = 0; i < numOfStr; i++) {
        
    		cin >> tmpStr;
    		res.push_back(tmpStr);
    	}
    
    	//sort(res.begin(), res.end(), cmp);//按照自定义方式比较
    	sort(res.begin(), res.end());//按照自定义方式比较
    
    	for (int i = 0; i < numOfStr; i++) {
        
    		if (i == numOfStr - 1) {
        //结尾无空格
    			cout << res[i];
    			break;
    		}
    		cout << res[i] << " ";
    	}
    	cout << endl;
    }
    
    
    /*
    对输入的字符串进行排序后输出:多个测试用例，每个测试用例一行。
    每行通过空格隔开，有n个字符，n＜100. 
    输出描述:对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开
    
    输入
    	a c bb
    	f dddd
    	nowcoder
    输出
    	a bb c
    	dddd f
    	nowcoder
    */
    
    void stringSort2() {
        
        string strtmp;
        vector<string> res;
        while(cin >> strtmp) {
        
            res.push_back(strtmp);
            if(cin.get() == '\n') {
        
                sort(res.begin(), res.end());
                int num = res.size() - 1;
                for(int i = 0; i < num; ++i) {
        
                    cout <<res[i] <<' ';
                }
                cout <<res[num] <<endl;
                res.clear();
            }
        }
        return 0;
    }
    
    /*
    对输入的字符串进行排序后输出:多个测试用例，每个测试用例一行。
    每行通过,隔开，有n个字符，n＜100
    输出描述:对于每组用例输出一行排序后的字符串，用','隔开，无结尾空格
    
    输入
    	a,c,bb
    	f,dddd
    	nowcoder
    输出
    	a,bb,c
    	dddd,f
    	nowcoder
    */
    
    void stringSort3() {
        
    	string tmpStr;
    	vector<string> res;
    
    	while (cin >> tmpStr) {
        //注意这里使用","隔开一个字符串就是一个数组
    		char* ptr = &tmpStr[0];
    		string childStr;
    		res.clear();
    		while(*ptr != '\0'){
        
    			if (*ptr == ',') {
        
    				res.push_back(childStr);
    				childStr.clear();
    			}
    			else {
        
    				childStr.push_back(*ptr);
    			}
    			ptr++;
    		}
    		res.push_back(childStr);//最后一次没加入进去，单独添加一次
    		childStr.clear();
    
    		sort(res.begin(), res.end());
    		for (int i = 0; i < res.size(); i++) {
        
    			if (i == res.size() - 1) {
        //结尾无空格
    				cout << res[i]<<endl;
    				continue;
    			}
    			cout << res[i] << ",";
    		}
    	}
    
    }
    
    
    
    #include<string>
    int StrSort3(){
        
    //    string strtmp;
    //    vector<string> res;
    //		这里是字符串，注释部分均为错误尝试
    //     while(cin>>strtmp){
        
    //         res.push_back(strtmp);
    //         if(cin.get() == ',')
    //             continue;
    //         else if(cin.get() == '\n'){
        
    //             sort(res.begin(),res.end());
    //             int num = res.size();
    //             for(int i=0; i<num; i++){
        
    //                 cout<<res[i]<<',';
    //             }
    //             cout<<res[num]<<endl;
    //             res.clear();
    //         }
    //     }
        
    //     while(getline(cin,strtmp)){
        
    //         for(int i = 0; i<sizeof(strtmp); i++){
        
    //             string childstr = "";
    //             if(strtmp[i] == ',' || strtmp[i] == '\0'){
        
    //                 res.push_back(childstr);
    //             }else{
        
    //                 childstr += strtmp[i];
    //             }
    //         }
    //         sort(res.begin(),res.end());
    //         int num = res.size()-1;
    //         for(int i=0; i<num; i++){
        
    //             cout<<res[i]<<",";
    //         }
    //         cout<<res[num];
    //         res.clear();
    //     }
        string line;
        while (getline(cin, line)) {
        
            istringstream sin(line);//istringstream将一个字符串变成了流，这样能被getline使用
            string childstr;
            vector<string> res;
            while (getline(sin, childstr, ',')) {
        
                res.push_back(childstr);
            }
            sort(res.begin(),res.end());
            int num = res.size() - 1;
            for(int i = 0; i < num; ++i) {
        
                cout <<res[i] <<',';
            }
            cout <<res[num] <<'\n';
        }
        return 0;
    }
    
    
    //int main() {
        
    //
    //	//CinTwoInt();
    //	//CinTwoInt2();
    //	//CinTwoInt3();
    //	//CinTwoInt4();
    //	//CinTwoInt5();
    //	//CinTwoInt6();
    //	//CinTwoInt7();
    //	//stringSort();
    //	//stringSort2();
    //	stringSort3();
    //	system("pause");
    //	return 0;
    //}
    
    
    
    #define LEN 10
    
    int len_foo() {
        
    	int i = 2;
    	return i;
    }
    
    constexpr int len_foo_constexpr() {
        
    	return 5;
    }
    
    constexpr int fibonacci(const int n) {
        
    	return n == 1 || n == 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    constexpr int add2num(const int a, const int b) {
        
    	return a + b;
    }
    
    template<typename T, typename... Ts>
    auto pintf3(T value, Ts... args) {
        
    	cout << value << endl;
    	(void)std::initializer_list<T>{
         ([&args] {
        
    		cout << args << endl;
    	}(), value)...};
    }
    
    template<typename... T>
    auto sum(T... t) {
        
    	return (t + ...);
    }
    
    int main2() {
        
    	char arr_1[10];
    	char arr_2[LEN];//合法
    
    	int len = 10;
    	//char arr_3[len];//非法
    	const int len_2 = len + 1;
    	constexpr int len_2_constexpr = 1 + 2 + 3;
    	//char arr_4[len_2];//非法
    	char arr_4[len_2_constexpr];//合法
    
    	//constexpr int len_3 = len + 1;//非法
    	int const size1 = 2+3;
    	char arr_5[size1];
    
    	char arr_6[sizeof(int)];
    
    	int a = 2;
    	int b = 3;
    	char arr_7[add2num(2, 3)];
    
    	auto arr = new auto(10);
    	int* arr1 = new int(10);
    	cout << sum(1,2.0,3,'m')<<endl;
    	auto important = std::make_unique<int>(1);
    	system("pause");
    	return 0;
    }

[Link 1]: https://ac.nowcoder.com/acm/contest/5650?from=hr_test#question
[Link 2]: http://c.biancheng.net/cpp/biancheng/cpp/rumen_13/
[20201011205233353.png_pic_center]: /images/20221123/4a62d86975c146ed922abf39f1645c47.png