读入优化＆输出优化

注意了注意了注意了，重要的事情说3遍，这个东西是骗分神器，骗分神器，骗分神器！！！
众所周知：scanf比cin快得多，printf比cout快得多，如果你不知道就……就现在知道了
那有没有更快的呢？当然。
请看：
我懵逼了，至于慢近100ms吗?
好吧，这就是读入优化的效果，在数据很恐怖的情况下能比scanf多过1-5个点……
比如说这种：
都说了要读入优化你还不读入优化，那不是找死吗……

---

前面都是废话，现在开始说正事

读入优化

首先，读入优化这里是只是针对整数，getchar读字符是非常快的，所以我们就用getchar了。（下面都假设输入的数为x）

负数处理

很简单，用一个标志变量f，开始时为1，当读入了’-’时，f变为-1，最后x*=f即可

绝对值部分处理

显然getchar每次只能读一位，所以，每当读了一位时x*=10，为这一位“留位置”。
举个例子：现在读入了123，x为123，再读入了一个4，x*=10,变为了1230，现在它的最后一位空出来了，正好留给4,x+=4，x就变为了1234，当然，这里的’4’是char类型，需要减去’0’才是4，即：x=x*10+s-'0'（s为当前输入的字符）

关于细节

很多时候是有多余空格或者其他的乱码字符输入，为了防止bug，我们要严谨~详见代码。

代码

void read(int &x)//'&'表示引用，也就是说x是一个实参，在函数中改变了x的值就意味着在外面x的值也会被改变
{
    int f=1;//标记正负
    x=0;//归零（这就是潜在bug，有可能传进来时x没有归零）
    char s=getchar();//读入第一个字符
    while(s<'0'||s>'9')//不是数字字符
    {
        if(s=='-')//不能直接把f=-1，有可能输入的不是'-'而是其他乱七八糟的东西
            f=-1;
        s=getchar();//继续读
    }
    while(s>='0'&&s<='9')//是字符（一旦不是字符就意味着输入结束了）
    {
        x=x*10+s-'0';
        s=getchar();
    }
    x*=f;//改变正负
}
    
    

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

简洁一些：

void read(int &x)
{
    int f=1;x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
    
    

     
     
1
     
     
2
     
     
3
     
     
4
     
     
5
     
     
6
     
     
7
    
    

这就是完整的读入优化了，你可以直接这样用：

int N;
read(N);
    
    

     
     
1
     
     
2
    
    

当然还有更装逼的代码：

#define num ch-'0'
void get(int &res){
    char ch;bool flag=0;
    while(!isdigit(ch=getchar()))
        (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
}
    
    

     
     
1
     
     
2
     
     
3
     
     
4
     
     
5
     
     
6
     
     
7
     
     
8
    
    

这个就真的很跳了。
首先：isdigit是判断一个字符是否为数字字符，需要头文件#include<cctype>，刚刚忘了说，getchar需要cstdio。
然后，那个诡异的(ch=='-')&&(flag=true)和(flag)&&(res=-res);是个什么玩意？我们发挥聪明才智，想起&&是“短路运算符”，短路运算符是啥？就是看到第一个条件错误就不会执行第二个条件，直接跳过了，所以这两句代码就不难理解了，唯一颠覆宝宝们的认知的是&&可以脱离if和return什么的直接用……

输出优化

如果有50%的人知道输入优化，那知道输出优化的最多不过20%，输出还能怎么优化？putchar啊！putchar是比printf快的。（下面都假设输出的数为x）
ps:居然还有putchar这种东西？！

负数处理

输出就简单了，如果是负数，直接putchar('-');x=-x;即可，不解释。

绝对值部分处理

这里是不是还是用循环呢？答案是——否定的，为了极致的速度，我们用递归！递归什么？递归下一位啊，即x/10，然后，注意边界，x要>9才能继续递归，否则要输出x%10（因为还有最后一位）。

关于细节

无……

代码

void print(int x)//这里当然不用实参
{
    if(x<0)//负数
    {
        putchar('-');
        x=-x;
    }
    if(x>9)//只要x还是2位数或更多就继续分解
        print(x/10);//这里递归完后栈里面x的每一位是倒过来的（关于递归，我也实在解释不清楚，各位去看看神犇们的递归解释吧）
    putchar(x%10+'0');//输出（要把int型变为char型，加'0'即可）
}
    
    

     
     
1
     
     
2
     
     
3
     
     
4
     
     
5
     
     
6
     
     
7
     
     
8
     
     
9
     
     
10
     
     
11
    
    

至于输出优化，目前还没发现什么太跳的，毕竟写输出优化的就少。

对比

为了能看出优势，我做了一个对比：
Test.cpp:

#include<cstdio>
#include<ctime>
#include<windows.h>
using namespace std;
#define TIMES 1000000
double A[5];
void print(int x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)print(x/10);
    putchar(x%10+'0');
}
void read(int &x)
{
    int f=1;x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int main()
{
    freopen("in.txt","r",stdin);
    freopen("111.txt","w",stdout);
    int a;
    double t1,t2;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        scanf("%d",&a);
    t2=clock();
    A[1]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        read(a);
    t2=clock();
    A[2]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        printf("%d",a);
    t2=clock();
    A[3]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        print(a);
    t2=clock();
    A[4]=(t2-t1)/1000;
    fclose(stdout);//为了不输出前面一堆东西
    freopen("out.txt","w",stdout);
    printf("Scanf:  %.4lf S\n",A[1]);
    printf("Read:   %.4lf S\n",A[2]);
    printf("Printf: %.4lf S\n",A[3]);
    printf("Print:  %.4lf S",A[4]);
}
    
    

     
     
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
     
     
35
     
     
36
     
     
37
     
     
38
     
     
39
     
     
40
     
     
41
     
     
42
     
     
43
     
     
44
     
     
45
     
     
46
     
     
47
     
     
48
     
     
49
     
     
50
     
     
51
     
     
52
    
    

Data.cpp:

#include<cstdio>
#include<ctime>
#include<cstdlib>
#define TIMES 1000000
#define MAXN 100000
int main()
{
    srand(time(NULL));
    freopen("in.txt","w",stdout);
    for(int i=1;i<=TIMES*2;i++)
    {
        if(rand()%2)
            printf("-");
        printf("%d\n",rand()%MAXN);
    }
}
    
    

     
     
1
     
     
2
     
     
3
     
     
4
     
     
5
     
     
6
     
     
7
     
     
8
     
     
9
     
     
10
     
     
11
     
     
12
     
     
13
     
     
14
     
     
15
     
     
16
    
    

如果你想测cin，cout，自己试试吧……
以下是我的测试结果（测5次，数据一模一样）：

次数	scanf耗时	read耗时	printf耗时	print耗时
1	0.2960 S	0.0790 S	0.1870 S	0.0630 S
2	0.2960 S	0.0940 S	0.1720 S	0.0630 S
3	0.2810 S	0.0780 S	0.1870 S	0.0630 S
4	0.2960 S	0.0790 S	0.1870 S	0.0470 S
5	0.2970 S	0.0780 S	0.1720 S	0.0630 S

这里用了1000000组数据，输入优化比scanf快了约0.2秒，也就是说，每50万组数据读入优化要快0.1秒（100ms），刚好符合了最开始的数据范围。

        <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
            </div>

注意了注意了注意了，重要的事情说3遍，这个东西是骗分神器，骗分神器，骗分神器！！！
众所周知：scanf比cin快得多，printf比cout快得多，如果你不知道就……就现在知道了
那有没有更快的呢？当然。
请看：
我懵逼了，至于慢近100ms吗?
好吧，这就是读入优化的效果，在数据很恐怖的情况下能比scanf多过1-5个点……
比如说这种：
都说了要读入优化你还不读入优化，那不是找死吗……

---

前面都是废话，现在开始说正事

读入优化

首先，读入优化这里是只是针对整数，getchar读字符是非常快的，所以我们就用getchar了。（下面都假设输入的数为x）

负数处理

很简单，用一个标志变量f，开始时为1，当读入了’-’时，f变为-1，最后x*=f即可

绝对值部分处理

显然getchar每次只能读一位，所以，每当读了一位时x*=10，为这一位“留位置”。
举个例子：现在读入了123，x为123，再读入了一个4，x*=10,变为了1230，现在它的最后一位空出来了，正好留给4,x+=4，x就变为了1234，当然，这里的’4’是char类型，需要减去’0’才是4，即：x=x*10+s-'0'（s为当前输入的字符）

关于细节

很多时候是有多余空格或者其他的乱码字符输入，为了防止bug，我们要严谨~详见代码。

代码

void read(int &x)//'&'表示引用，也就是说x是一个实参，在函数中改变了x的值就意味着在外面x的值也会被改变
{
    int f=1;//标记正负
    x=0;//归零（这就是潜在bug，有可能传进来时x没有归零）
    char s=getchar();//读入第一个字符
    while(s<'0'||s>'9')//不是数字字符
    {
        if(s=='-')//不能直接把f=-1，有可能输入的不是'-'而是其他乱七八糟的东西
            f=-1;
        s=getchar();//继续读
    }
    while(s>='0'&&s<='9')//是字符（一旦不是字符就意味着输入结束了）
    {
        x=x*10+s-'0';
        s=getchar();
    }
    x*=f;//改变正负
}
  
  

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

简洁一些：

void read(int &x)
{
    int f=1;x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
  
  

   
   
1
   
   
2
   
   
3
   
   
4
   
   
5
   
   
6
   
   
7
  
  

这就是完整的读入优化了，你可以直接这样用：

int N;
read(N);
  
  

   
   
1
   
   
2
  
  

当然还有更装逼的代码：

#define num ch-'0'
void get(int &res){
    char ch;bool flag=0;
    while(!isdigit(ch=getchar()))
        (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
}
  
  

   
   
1
   
   
2
   
   
3
   
   
4
   
   
5
   
   
6
   
   
7
   
   
8
  
  

这个就真的很跳了。
首先：isdigit是判断一个字符是否为数字字符，需要头文件#include<cctype>，刚刚忘了说，getchar需要cstdio。
然后，那个诡异的(ch=='-')&&(flag=true)和(flag)&&(res=-res);是个什么玩意？我们发挥聪明才智，想起&&是“短路运算符”，短路运算符是啥？就是看到第一个条件错误就不会执行第二个条件，直接跳过了，所以这两句代码就不难理解了，唯一颠覆宝宝们的认知的是&&可以脱离if和return什么的直接用……

输出优化

如果有50%的人知道输入优化，那知道输出优化的最多不过20%，输出还能怎么优化？putchar啊！putchar是比printf快的。（下面都假设输出的数为x）
ps:居然还有putchar这种东西？！

负数处理

输出就简单了，如果是负数，直接putchar('-');x=-x;即可，不解释。

绝对值部分处理

这里是不是还是用循环呢？答案是——否定的，为了极致的速度，我们用递归！递归什么？递归下一位啊，即x/10，然后，注意边界，x要>9才能继续递归，否则要输出x%10（因为还有最后一位）。

关于细节

无……

代码

void print(int x)//这里当然不用实参
{
    if(x<0)//负数
    {
        putchar('-');
        x=-x;
    }
    if(x>9)//只要x还是2位数或更多就继续分解
        print(x/10);//这里递归完后栈里面x的每一位是倒过来的（关于递归，我也实在解释不清楚，各位去看看神犇们的递归解释吧）
    putchar(x%10+'0');//输出（要把int型变为char型，加'0'即可）
}
  
  

   
   
1
   
   
2
   
   
3
   
   
4
   
   
5
   
   
6
   
   
7
   
   
8
   
   
9
   
   
10
   
   
11
  
  

至于输出优化，目前还没发现什么太跳的，毕竟写输出优化的就少。

对比

为了能看出优势，我做了一个对比：
Test.cpp:

#include<cstdio>
#include<ctime>
#include<windows.h>
using namespace std;
#define TIMES 1000000
double A[5];
void print(int x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)print(x/10);
    putchar(x%10+'0');
}
void read(int &x)
{
    int f=1;x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
int main()
{
    freopen("in.txt","r",stdin);
    freopen("111.txt","w",stdout);
    int a;
    double t1,t2;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        scanf("%d",&a);
    t2=clock();
    A[1]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        read(a);
    t2=clock();
    A[2]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        printf("%d",a);
    t2=clock();
    A[3]=(t2-t1)/1000;
    t1=clock();
    for(int i=1;i<=TIMES;i++)
        print(a);
    t2=clock();
    A[4]=(t2-t1)/1000;
    fclose(stdout);//为了不输出前面一堆东西
    freopen("out.txt","w",stdout);
    printf("Scanf:  %.4lf S\n",A[1]);
    printf("Read:   %.4lf S\n",A[2]);
    printf("Printf: %.4lf S\n",A[3]);
    printf("Print:  %.4lf S",A[4]);
}
  
  

   
   
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
   
   
35
   
   
36
   
   
37
   
   
38
   
   
39
   
   
40
   
   
41
   
   
42
   
   
43
   
   
44
   
   
45
   
   
46
   
   
47
   
   
48
   
   
49
   
   
50
   
   
51
   
   
52
  
  

Data.cpp:

#include<cstdio>
#include<ctime>
#include<cstdlib>
#define TIMES 1000000
#define MAXN 100000
int main()
{
    srand(time(NULL));
    freopen("in.txt","w",stdout);
    for(int i=1;i<=TIMES*2;i++)
    {
        if(rand()%2)
            printf("-");
        printf("%d\n",rand()%MAXN);
    }
}
  
  

   
   
1
   
   
2
   
   
3
   
   
4
   
   
5
   
   
6
   
   
7
   
   
8
   
   
9
   
   
10
   
   
11
   
   
12
   
   
13
   
   
14
   
   
15
   
   
16
  
  

如果你想测cin，cout，自己试试吧……
以下是我的测试结果（测5次，数据一模一样）：

次数	scanf耗时	read耗时	printf耗时	print耗时
1	0.2960 S	0.0790 S	0.1870 S	0.0630 S
2	0.2960 S	0.0940 S	0.1720 S	0.0630 S
3	0.2810 S	0.0780 S	0.1870 S	0.0630 S
4	0.2960 S	0.0790 S	0.1870 S	0.0470 S
5	0.2970 S	0.0780 S	0.1720 S	0.0630 S

这里用了1000000组数据，输入优化比scanf快了约0.2秒，也就是说，每50万组数据读入优化要快0.1秒（100ms），刚好符合了最开始的数据范围。

        <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
            </div>