牛客网的ACM输入输出模式_牛客网输入输出模式详解

---

一、输入测试用例形式确定，数量不确定

输入包括两个正整数a,b(1 <= a, b <= 1000),输入数据包括多组。
输出a+b的结果

#include <iostream>
using namespace std;

int main(){
    int a,b;
	int c;
    while(cin>>a>>b){
        c=a+b;
        cout<<c<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

二、输入测试用例形式确定，数量确定（数量单独输入）

输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 1000)
输出a+b的结果

#include <iostream>
using namespace std;

int main(){
    int t;
    int a,b;
    int res;
    cin>>t;
    for(int i=0;i<t;i++){
        cin>>a>>b;
        res=a+b;
        cout<<res<<endl;
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三、输入测试用例形式确定，数量确定（数量由最后一次特殊输入决定）

输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入
输出a+b的结果

#include <iostream>
using namespace std;

int main(){
    int a,b;//新建输入存放对象
    int res;//新建输出存放对象
    
    while(cin>>a>>b){//循环处理
    		//在循环体里执行对一次输入的数据的处理
        if(a||b){
            res=a+b;
            cout<<res<<endl;
        }
        else{
            break;
        }
    }
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、输入测试用例形式不确定，数量不确定

输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。
每组数据输出求和的结果

#include <iostream>
using namespace std;

int main(){
    int n;
    int a;
    int res=0;
    
    while(cin>>n){
        res=0;//特别注意，每轮执行后都要把res清空
        if(n==0) break;//终止条件可以放在else分支，也可以这样写
        for(int i=0;i<n;i++){
            cin>>a;
            res+=a;
        }
        cout<<res<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

五、测试用例组数要手动输入，每组测试用例数据个数要手动输入

输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
每组数据输出求和的结果

#include <iostream>
using namespace std;

int main(){
    int t,n;
    int temp; 
    int res=0;
    
    cin>>t;
    for(int i =0;i<t;i++){
        res=0;//记住在每一组求和之前将res清0；
        cin>>n;
        for(int i=0;i<n;i++){
            cin>>temp;
            res+=temp;
        }
        cout<<res<<endl;
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

六、测试用例组数不确定，每组测试用例个数手动输入

输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
每组数据输出求和的结果

#include <iostream>
using namespace std;

int main(){
    int n;
    int temp;
    int res=0;
    
    while(cin>>n){
        res=0;
        for(int i=0;i<n;i++){
            cin>>temp;
            res+=temp;
        }
        cout<<res<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

七、输入测试用例组数不确定，每组测试用例个数有最后一次输入决定

输入数据有多组, 每行表示一组输入数据。
每行不定有n个整数，空格隔开。(1 <= n <= 100)。
每组数据输出求和的结果

#include <iostream>
using namespace std;

int main(){
    //int n;//每行的数个数不确定，定义n没有意义
    int temp;
    int res=0;
    
    while(cin>>temp){//每输入一个字符，执行一次循环
        res+=temp;
        if(cin.get()=='\n'){
            cout<<res<<endl;
            res=0;
        }
    }    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

八、输入测试用例的组数为1组，每组测试用例的个数手动输入

输入有两行，第一行n
第二行是n个字符串，字符串之间用空格隔开

输出一行排序后的字符串，空格隔开，无结尾空格

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

int main(){
    int n;
    cin>>n;
    
    vector<string> a(n);
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    
    sort(a.begin(),a.end());
    
    for(int i=0;i<a.size();i++){
        cout<<a[i]<<" ";
    }
    
    cout<<endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

九、输入测试用例的组数不确定，每组测试用例的个数需要通过换行符来确定

多个测试用例，每个测试用例一行。
每行通过空格隔开，有n个字符，n＜100

对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

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

int main(){
    char c;
    vector<char> a;
    while(cin>>c){
        a.push_back(c);
        
        if(cin.get()=='\n'){
            sort(a.begin(),a.end());
        
            for(int i=0;i<a.size();i++){
                cout<<a[i]<<' ';
            }
            cout<<endl;

            a.clear();
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

十、

多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100

对于每组用例输出一行排序后的字符串，用’,'隔开，无结尾空格

//这个解法不行
#include <iostream>
#include <vector>
//#include <string>//使用string类不用包含头文件
#include <algorithm>
using namespace std;

int main(){
    char c;
    vector<char> a;
    string s;
    
    while(cin>>c){//注意本题输入的字符之间没有用空格隔开，所以实际上是输入字符串
        if(cin.get()!=','){//注意不要直接写if(c!=',')
            a.push_back(c);
        }
        
        if(cin.get()=='\n'){
            sort(a.begin(),a.end());
            
            s.push_back(a[0]);
            for(int i=1;i<a.size();i++){
                
                s.push_back(',');
                s.push_back(a[i]);
            }
            cout<<s<<endl;
            
            a.clear();
            s.clear();
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

十一、

输入有多组测试用例，每组空格隔开两个整数

对于每组数据输出一行两个整数的和

#include <iostream>
using namespace std;

int main(){
    long long a,b;//注意看题目所给的整数范围
	long long c;
    while(cin>>a>>b){
        c=a+b;
        cout<<c<<endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

---

总结

外层循环，如果指定了输入组数就用for，没有就用while(1)
内层循环，如果指定了每组输入个数就用for，没有就用while(1)
死循环没有合适的跳出机制，导致输入结束后也不能跳出循环，从而报错