2019.10.1 C语言入门及进阶 （国庆天天乐）

发表于 | 分类于 | |
-------------本文结束感谢您的阅读-------------

C语言入门及进阶

img

img

img

1569996007971

\t 制表符 与 空格的关系

https://www.cnblogs.com/guokai/p/3641953.html

tab

如何 在 C 输出 \ %

%% \ \

如何在 C使用 百分数 %

double n,x;

n=0.01*x;

2.各种类型输入输出

1569996057361

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
特别注意 A-Z区间的表示 以及 字符的 ''

#include <stdio.h>
int main()
{
	char n;
	scanf("%c",&n);
	if(n>='A'&&n<='Z')
{
	 printf("%c",n+32);

}
	else printf("%c",n);
	return 0;
}

1569996076721

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
#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	scanf("%c",&a);
	scanf("%c",&b);
	scanf("%c",&c);
	scanf("%c",&d);
	scanf("%c",&e);
	printf("password is %c%c%c%c%c",a+4,b+4,c+4,d+4,e+4);
	return 0;
}
方法	
#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	scanf("%c%c%c%c%c",&a,&b,&c,&d,&e);
	printf("password is %c%c%c%c%c",a+4,b+4,c+4,d+4,e+4);
	return 0;
}
方法三
#include <stdio.h>
int main()
{
	char a,b,c,d,e;
	a=getchar();
	b=getchar();
	c=getchar();
	d=getchar();
	e=getchar();
	printf("password is ");
	putchar(a+4);
	putchar(b+4);
	putchar(c+4);
	putchar(d+4);
	putchar(e+4);
	return 0;
}

1569996122298

这种 不行 会报错

1569996141954

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>
//实现摄氏温度和华氏温度的转化函数
float f_c(float F)
{
	return 5*(F-32)/9;
}
int main()
{
	float f,c;
	scanf("%f",&f);
	c=f_c(f);
	printf("%.2f",c);
	return 0;
}

3.简单运算

1569996169091

1
2
3
4
5
6
7
8
9
#include <stdio.h>
int main()
{
	int a,b,c;
	scanf("%d%d",&a,&b);
	c=(a/10)*1000+(a%10)*10+(b/10)*100+(b%10);
	printf("The result is: %d",c);
	return 0;
}

4.加点难度的运算

1569996196930

1
2
3
4
5
6
7
8
9
#include <stdio.h>
int main()
{
	int n,x;
	scanf("%d",&n);
	x=(n%10)*100+((n%100)/10)*10+(n/100);
	printf("%d",x);
	return 0;
}

1569996219298

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
#include <stdio.h>
int main()
{
     int a;
	 int b;
 scanf("%d %d", &a, &b);
 printf("%d", b/a+1);
 return 0;
}
化繁为简 考虑简单的

超时的程序？  ＞的话 反过来就要考虑 小于等于
#include <stdio.h>
int main()
{
	int a,b,m=1,z;
	scanf("%d%d",&a,&b);
	while(z<=b)
	{
		m++;
		z=a*m;
	}
	printf("%d",m);	
	return 0;
}
这里涉及了 C语言运行程序的计算 调试 

https://www.cnblogs.com/Emcikem/p/11518388.html
#include<stdio.h>
#include<time.h>   //用到clock()函数
int main() {
    int begintime,endtime;
    int i = 0;
    int a[1002];
    begintime=clock();  //计时开始
    

        /*
        代码块
        */

    endtime = clock();  //计时结束
    printf("\n\nRunning Time：%dms\n", endtime-begintime);
    return 0;
}

1569996236148

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main()
{
	int x,y,n,m;
	scanf("%d%d",&n,&m);
	y=(m-2*n)/2;
	x=n-y;
	printf("%d %d",x,y);
	return 0;
}
数学果然是个好东西

5.简单选择结构

1569996279157

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int main()
{
	int a;
	scanf("%d",&a);
	if(a%3==0&&a%5==0)
	{
		printf("Yes");
	}
	else
	{
		printf("No");	
	}
	return 0;
}

1569996297996

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
#include <stdio.h>
int main()
{
	int a,b,c,t;
	scanf("%d %d %d",&a,&b,&c);
	if(a>b)
	{
		t=a;
		a=b;
		b=t;
	}
	if(a>c)
	{
		t=a;
		a=c;
		c=t;		
	}
	if(b>c)
	{
		t=b;
		b=c;
		c=t;		
	}
	printf("%d",b);
	return 0;
}

三目运算符

三数比较
1
2
3
4
5
6
7
8
9
#include <stdio.h>
int main()
{
	int a,b,c,max;
	scanf("%d%d%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	printf("max=%d",max);
	return 0;
}
二数比较
1
2
3
4
5
6
7
8
9
#include <stdio.h>
int main()
{
	int a,b,max;
	scanf("%d%d",&a,&b);
	max=a>b?a:b;
	printf("max=%d",max);
	return 0;
}

1570026933714

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
#include<stdio.h>
int main()
{
	int a,b,c,x,y,z,max;
 	scanf("%d %d %d",&a,&b,&c);
 	x=a+b;
 	y=a+c;
 	z=b+c;
 	max=(x>y)?((x>z)?x:z):((y>z)?y:z);
 	printf("%d",max);
	return 0;
}



#include<stdio.h>
int main()
{
int a,b,c;
int x,y,z;
 scanf("%d%d%d",&a,&b,&c);
 x=a+b;
 y=a+c;
 z=b+c;
 if(x>=y&&x>=z)
 {
	 printf("%d",x);
 }else{
	 if(y>z&&y>x)
	 {
		 printf("%d",y);
	 }else{
		 printf("%d",z);
	 }
 }
}

1570027083270

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main()
{
	int a,b,c,max,min,n;
	scanf("%d%d%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	min=(a<b)?((a<c)?a:c):((b<c)?b:c);
	n=max-min;
	printf("%d",n);
	return 0;
}

1570028728045

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>

int main()
{C
	int a,b,c,d;
	scanf("%d.%d.%d.%d",&a,&b,&c,&d); 
	if(0<=a&&a<=255&&
	   0<=b&&b<=255&&
	   0<=c&&c<=255&&
	   0<=d&&d<=255)
		printf("YES");
	else
		printf("NO");
	return 0;	
}

6.加强选择结构

1570065565631

1570065584358

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
#include<stdio.h>
int main()
{
	int month,year;
	scanf("%d\\%d",&year,&month);
	if(month==1||month==3||month==5||month==7||month==8||month==10||month==12)
	printf("31");
	else if(month==4||month==6||month==9||month==11)
	printf("30");
	if(month==2)
	{
	if(year%4==0&&year%100!=0||year%400==0)
	printf("29");
	else 
	printf("28");
	}
	return 0;
}


#include<stdio.h>
int main()
{
 int year,month,day;
 scanf("%d\\%d",&year,&month);
 switch(month)
 {
 case 1:
 case 3:
 case 5:
 case 7:
 case 8:
 case 10:
 case 12:day=31;break;
 case 4:
 case 6:
 case 9:
 case 11:day=30;break;
 }
 if(month==2)
 {
 	if((year%4==0&&year%100!=0)||year%400==0)
 	day=29;
 	else  day=28;
 }
	printf("%d",day);
 return 0;
}

1570067530883

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h>
#include<math.h>
int main()
{
	float a,b,c;
	float x1,x2,d;
	scanf("%f %f %f",&a,&b,&c);
	if(a!=0)
{
	d=sqrt((b*b)-(4.0*a*c));
	x1=((-b+d)/(2.0*a));
	x2=((-b-d)/(2.0*a));
	if(x1>=x2)
	{
		printf("%.2f %.2f",x1,x2);
	}
	else 	printf("%.2f %.2f",x2,x1);
}
	else printf("not root!");
 return 0;
}

强调 实数的定义 数学知识的补充 课外知识的背景 还有 学好英语！！！！！

上面挖个坑 你把函数 指针 学熟 再来补

1570076451487

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<stdio.h>  
#include<math.h>  
int main()  
{     
   double a,b,c,x1,x2,m,n;  
   scanf("%lf%lf%lf",&a,&b,&c); 
   if(a==0)printf("%.2f %.2f\n",-c/b,-c/b); 
   else if(b*b-4*a*c<0)
   {
   	 m=-b/(2*a);  n=sqrt(4*a*c-b*b);
     if(a>0)printf("%.2f+%.2fi %.2f-%.2fi\n", m,n/(2*a),m,n/(2*a) );
     else printf("%.2f+%.2fi %.2f%.2fi\n", m,-n/(2*a),m,n/(2*a));
   }
   else
    {
   	 x1=(-b+sqrt(b*b-4*a*c))/(2*a);  
     x2=(-b-sqrt(b*b-4*a*c))/(2*a);  
     if(x1>x2)printf("%.2f %.2f",x1,x2);  
     else printf("%.2f %.2f",x2,x1);  
    } 
    return 0;  
}

1570076854406

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
#include<stdio.h>  
int main()  
{
	int x,y,z;
	scanf("%d,%d,%d",&x,&y,&z);
	if(x>y&&x>z)
	{
		if(y>z)
		printf("%d %d %d",z,y,x);
		else 
		printf("%d %d %d",y,z,x);
	}
	else if(y>x&&y>z)
	{
		if(x>z)
		printf("%d %d %d",z,x,y);
		else 
		printf("%d %d %d",x,z,y);
}
	else if(z>y&&z>x)
{
	if(x>y)
	printf("%d %d %d",y,x,z);
	else 
	printf("%d %d %d",x,y,z);
}
return 0;  
}  


#include<stdio.h>
int main()
{
	int a,b,c,max,min,mid;
	scanf("%d,%d,%d",&a,&b,&c);
	max=(a>b)?((a>c)?a:c):((b>c)?b:c);
	min=(a<b)?((a<c)?a:c):((b<c)?b:c);
	mid=a+b+c-max-min;
	printf("%d %d %d",min,mid,max);
	return 0;
}

1570084249670

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include<stdio.h>
typedef struct Time{
	int h,m,s;
}Time;
/*
	描述时间的结构体 
*/
/*
	输入时间函数 
*/
void ReadTime(Time *time)
{
	scanf("%d:%d:%d",&time->h,&time->m,&time->s);
}
/*
	输出时间函数 
*/
void PrintTime(Time *time)
{
	printf("%d:",time->h);
	if(time->m<10)
		printf("0");
	printf("%d:",time->m);
	if(time->s<10)
		printf("0");
	printf("%d",time->s);	
}
//计算两个时间只差 
void TimeSub(Time *time1,Time *time2,Time *time)
{
	long t1,t2,t;
	t1=time1->h * 3600 + time1->m *60 + time1->s;
	t2=time2->h * 3600 + time2->m *60 + time2->s;
	t=t1-t2;//将时间转化为秒 
	if(t<0)
		t=t*(-1);
	//将秒转化为时间 
	time->h= t/3600;
	time->m= (t-time->h*3600)/60;
	time->s= t%60; 
}
int main()
{
	Time time1,time2,time;
	ReadTime(&time1);//读时间 
	ReadTime(&time2);//读第一个时间 
	TimeSub(&time1,&time2,&time);//计算减法 
	PrintTime(&time);//返回一个时间 
	return 0;
 }




#include<stdio.h>
int main()
{
	int h1, m1, s1;
	int h2, m2, s2;
	int a, b, c;
	scanf("%d:%d:%d", &h1, &m1, &s1);
	scanf("%d:%d:%d", &h2, &m2, &s2);
	if (h1 * 3600 + m1 * 60 + s1 < h2 * 3600 + m2 * 60 + s2)
	{
		a = h2 - h1, b = m2 - m1, c = s2 - s1;
		if (c < 0)
		{
			c = 60 + c;
			b--;
		}
		if (b < 0)
		{
			b = b + 60;
			a--;
		}
	}
	else
	{
		a = h1 - h2, b = m1 - m2, c = s1 - s2;
		if (c < 0)
		{
			c = 60 + c;
			b--;
		}
		if (b < 0)
		{
			b = b + 60;
			a--;
		}
	}
	printf("%d:%02d:%02d", a, b, c);
}



#include<stdio.h>
int main()
{
    int h1, h2, m1, m2, s1, s2, t1, t2, del;
    t1 = t2 = 0;
    scanf("%d:%d:%d",&h1, &m1, &s1);
    scanf("%d:%d:%d",&h2, &m2, &s2);
    t1 = h1 * 3600 + m1 * 60 + s1;
    t2 = h2 * 3600 + m2 * 60 + s2;
    if(t1 > t2)
    {
        del = t1 - t2;
    }
    else
    {
        del = t2 - t1;
    }
    int a, b, c;
    a = del / 3600;
    b = del / 60 % 60;
    c = del % 60;
    printf("%02d:%02d:%02d\n",a, b, c);
    return 0;
}

7.简单一重循环

1570084516452

1
2
3
4
5
6
7
8
9
#include<stdio.h>
int main()
{
	int n,i;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	printf("%d\n",i);
    return 0;
}

1570171357405

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<stdio.h>
int main()
{
	float sum=0.0;
	int a=1,i;
	for (i=1;i<=100;i++){
		sum+=(1.0*a)/i;
		a=-a;
	}
	printf("%f",sum);
	return 0;
}



#include <stdio.h>

int main(void)
{
    int i = 1;
    float sum = 0;

    while(i <= 100)
    {
        if(i % 2 == 0)
        {
            sum -=1/(i++*1.0);
        }else
        {
            sum +=1/(i++*1.0);
        }
    }
    printf("%f\n",sum);
}

​

1.0 的重要性

1570172575930

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include<stdio.h>
int main(void)
{
    int num=0,i=0,a=0;
    int str[1000];
    scanf("%d",&num);
    for(i=0;i<num;i++)
    {
        scanf("%d",&a);
        str[i]=a;
    }
    for(i=0;i<num;i++)
    {
        printf("%c",str[i]);
    }
    return 0;
}

#include <stdio.h>
int main()
{
	int n;
	scanf("%d",&n);
	int i,a;
	for( i=0;i<n;i++)
{
		scanf("%d",&a);
		printf("%c",a);
}
}

 

#include<stdio.h>
#include<string.h>
using namespace std;
int main(){
	int n,i;
	char s[100];
	int len=0;
	scanf("%d",&n);
	for(i=0;i<n;i++){
		int a;
		scanf("%d",&a);
		if(a>=0&&a<=256) s[len++]=a; //ASCll范围[0,256] 
	}
	 s[len]='\0';
	 printf("%s",s);  
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    char c[1001];
    int x[1001];
    cin>>n;
 
    for(int i=0;i<n;i++)
    {
        scanf("%d",&x[i]);
        c[i]=x[i];
 
    }
    for(int i=0;i<n;i++)
        printf("%c",c[i]);
}

https://www.cnblogs.com/kimsimple/p/6874988.html

#include<bits/stdc++.h>包含了目前c++所包含的所有头文件

1570172873515

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
int main()
{
float a;
int n,i;
float sum=0,average;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%f",&a);
sum=sum+a;
}
average=sum/n;
printf("%.2f",average);
return 0;
}

1570241687368

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<stdio.h>
int main()
{
	int t,a,b,sum;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d",&a,&b);
		sum=(a%100+b%100)%100;//实验证明若用sun=(a+b)%100，在hdoj上提交会WA 
		printf("%d\n",sum);
	}
	return 0;
}

关于while(n–)知识点的补充

下面这段代码我们都很熟悉

#include <stdio.h>
int main()
{
int n=5;
while(n)
{
n=n-1;
}
printf(“%d\n”,n);
return 0;
}
它的输出结果为0.
再看下面这一段代码：

#include <stdio.h>
int main()
{
int n=5;
while(n–)
{
;
}
printf(“%d\n”,n);
return 0;
}
它的输出结果却是-1.
很多人都认为这两段代码是等价的，我之前也误认为它们等价，但是实验证明这不是等价的。

第二段代码中，while(n–)，当n=0时，并没有马上跳过循环条件和循环体，而是将循环条件执行完再跳过循环体。

原因：n–是一个整体，从编译器gcc角度看，先将n赋值给一个临时变量，然后自身减去1，返回的不是n而是临时变量。此时临时变量0，n为-1。故n–操作是一个整体，必须完整的执行完，不是割裂看的。之前，我误认为while中判断n为0时就直接结束。

1570243137961

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
int main()
{
   int n,a,b,i;
   float sum =0;
   scanf("%d",&n);
   a = 1;
   b = 2;
   for(i =0; i<n;i++)
   {
      sum = sum + 1.0/a - 1.0/b;
      a = a+2;
      b = b+2;
   }
   printf("%0.2f\n",sum);
}

1570243326085

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
#include<stdio.h>
int main()
{ 
	int i,n,fm=0;
	double sum=0;
	scanf("%d",&n);
	for ( i=0;i<n;i++ ) //总共n次循环，加n项
{ 	fm+=(i+1); //分母每次累加当前项号：0+1,1+2,3+3,...
	sum+=(double)1/fm; //累加当前项
}
	printf("%.2f\n",sum);
}



#include<stdio.h>
int main()
{	
	int i,n;
	double s=0,m=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
{
	m+=i;
	s+=1.0/m;
}
	printf("%.2lf",s);
}






#include<stdio.h>
int main()
{
	int n,i;
	float sum=0,s=0;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		sum=sum+i;
		s=s+(1.0/sum);
	}
	printf("%.2f",s);
	return 0;
}

论 sum=0的重要性

1570248277561

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
#include<math.h>
int main()
{
	double x1,x0,d;
	x1=0.0;
	x1=cos(x0);
	scanf("%lf",&d);
	while(fabs(x0-x1)>d)
{
	x0=x1;
	x1=cos(x0);
}
	printf("%.2f\n",x1);
	return 0;
}

迭代

迭代法是数值计算中一类典型方法，应用于方程求根，方程组求解，矩阵求特征值等方面。其基本思想是逐次逼近，先取一个粗糙的近似值，然后用同一个递推公式，反复校正此初值，直至达到预定精度要求为止。

从概念上讲，递归就是指程序调用自身的编程思想，即一个函数调用本身；迭代是利用已知的变量值，根据递推公式不断演进得到变量新值得编程思想。

从直观上讲，递归是将大问题化为相同结构的小问题，从待求解的问题出发，一直分解到已经已知答案的最小问题为止，然后再逐级返回，从而得到大问题的解（一个非常形象的例子就是分类回归树 classification and regression tree，从root出发，先将root分解为另一个(root,sub-tree)，就这样一直分解，直到遇到leafs后逐层返回）；而迭代则是从已知值出发，通过递推式，不断更新变量新值，一直到能够解决要求的问题为止。

递归实际上不断地深层调用函数，直到函数有返回才会逐层的返回，因此，递归涉及到运行时的堆栈开销（参数必须压入堆栈保存，直到该层函数调用返回为止），所以有可能导致堆栈溢出的错误；但是递归编程所体现的思想正是人们追求简洁、将问题交给计算机，以及将大问题分解为相同小问题从而解决大问题的动机。

迭代大部分时候需要人为的对问题进行剖析，将问题转变为一次次的迭代来逼近答案。迭代不像递归一样对堆栈有一定的要求，另外一旦问题剖析完毕，就可以很容易的通过循环加以实现。迭代的效率高，但却不太容易理解，当遇到数据结构的设计时，比如图‘表、二叉树、网格等问题时，使用就比较困难，而是用递归就能省掉人工思考解法的过程，只需要不断的将问题分解直到返回就可以了。

总之，递归算法从思想上更加贴近人们处理问题的思路，而且所处的思想层级算是高层（神），而迭代则更加偏向于底层（人），所以从执行效率上来讲，底层(迭代)往往比高层(递归)来的高，但高层(递归)却能提供更加抽象的服务，更加的简洁。

从个人来讲，我非常认同“迭代是人，递归是神”！

编程中，循环、迭代、遍历和递归之间的区别

循环(loop) - 最基础的概念, 所有重复的行为
递归(recursion) - 在函数内调用自身, 将复杂情况逐步转化成基本情况
(数学)迭代(iterate) - 在多次循环中逐步接近结果
(编程)迭代(iterate) - 按顺序访问线性结构中的每一项
遍历(traversal) - 按规则访问非线性结构中的每一项
————————————————
版权声明：本文为CSDN博主「Never-say-Never」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/mad1989/article/details/8933078

当型循环和直到型循环

当型循环：
开始循环
判断循环条件，成立
执行循环体
判断循环条件，成立
执行循环体
…
判断循环条件，这一次条件不成立
不执行循环体，直接继续往下

直到型循环：
开始循环
执行循环体
判断循环条件，成立
执行循环体
…
判断循环条件，这一次条件不成立
不执行循环体，直接继续往下

“当型”
while(i<n)
{
…..
}则说明当满足条件i<n时执行{ }中代码；

“直到型”
do
{
} while(i<n)
则说明先执行{ }中代码，再判断是否是i<n;

1570248776362

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
#include<stdio.h>
int main()
{
	int n,max,i,j;
	scanf("%d",&n);
	if(n>=1&&n<=10)
	{
		for(i=0;i<n;i++)
		{
			scanf("%d",&j);
			if(i==0)
			{
				max=j;
			}
			else
			{
				max =(max>j)?max:j;
			}
		}
	}
	printf("%d",max);
	return 0;
}


#include <stdio.h>
int main()
{
	int i,n,max,a[20];
	scanf("%d",&n);
	scanf("%d",&a[0]);
	max=a[0];
	for(i=1;i<n;i++)
{
	scanf("%d",&a[i]);
	if(max<a[i]) max=a[i];
}
	printf("%d",max);
	return 0;
}

img

比较 输出 最大最小值

1570249059881

8.加强一重循环

https://blog.csdn.net/S1259364843/article/details/92420371

C语言求最小公倍数和最大公约数三种算法(经典)

1570366510076

1
2
3
4
5
6
7
8
9
10
#include<stdio.h> 
int main()   /*  辗转相除法求最大公约数 */ 
{ 
   int m, n, a, b, t, c;
   scanf("%d %d", &a,&b);
   m=a;   n=b;
   while(b!=0)  /* 余数不为0，继续相除，直到余数为0 */ 
   { c=a%b; a=b;  b=c;}
   printf("%d %d\n",m*n/a,a);
}

1570367176022

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
#include <stdio.h>

int check(int num);

int main()
{
   int i;
   int count;
   int num;

   count=0;
   scanf("%d", &num);

   for(i=1; i<=num; i++)
   {
	   if(i%3==0)
	   {
		   count++;
	   }
	   else if(check(i))
	   {
           count++;
	   }
   }

   printf("%d", count);
}

int check(int num)
{
   int flag=0;

   while(num)
   {
       if(num%10==3)
	   {
	      flag=1;
	   }
	   num/=10;
   }

   return flag;
}

1570367738794

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
int main()
{
   double n=2,m=1,N,t,sum=0.00;
   scanf("%Lf",&N);
while(N)
{
  sum=sum+n/m; 
  t=m;
  m=n;
  n=n+t;
  N--;
}	
printf("%.6f\n",sum);
return 0;

}

1570368173418

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>  
#include<math.h>  
int main()  
{     
    int n;
    double sum=0,i,t=1;
	scanf("%d",&n);
	for(i=1;i<=4*n-1;i=i+2)
	{  sum=sum+t/i;
	    t=-t;
    }
	printf("%.5f",4*sum);
    return 0;  
}

素数：除了1和它自己之外，不能被其他数整除的数。

以下用三种方法解答：

https://blog.csdn.net/yuemeicheng/article/details/81185154

1570367271887

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
#include <stdio.h>
int main()
{
    int i,j;
    int count=0;
    int a[100];
    //求素数
    for(i=100;i<=200;i++)    
    {
        for(j=2;j<i;j++)
        {
            if(i%j==0)   //如果i/j没有余数就跳出循环
            {
                break;
            }
        }
        if(i==j)   //判断是不是跳出循环的数，
        {
            a[count++]=i;   //把素数存入数组
        }
    }
    printf("%d\n",count);
    for (i=0;i<count;i++)
    {
        printf("%d",a[i] );  //输出
        if(i!=count-1)
        {
            printf(" ");
        }
    }
    return 0;
}

1570372685273

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main()
{
    double x, sum, t, item;
    int n, i;
    while (scanf("%lf %d", &x, &n)==2)
    {
        t = x*x;
        item = 1.0;
        sum = 1.0;
        for (i=1; i<=n; i++)
        {
            item *= -t;
            item /= (i*2-1)*(i*2);
            sum += item;
        }
        printf("%.4lf\n", sum);
    }
    return 0;
}

1570372995000

1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
int main()
{
	int sum=0,n,m,i;
	scanf("%d %d",&n,&m);
	for(i=n;i<=m;i++)
	{
		sum+=i*i;
	}
	printf("%d\n",sum);
	return 0;
}

9.多组数据格式

EOF的意义及用法(while(scanf(“%d”,&n) != EOF))

https://blog.csdn.net/wangzhen199009/article/details/8781152

EOF，为End Of File的缩写，通常在文本的最后存在此字符表示资料结束。
在微软的DOS和Windows中，读取数据时终端不会产生EOF。此时，应用程序知道数据源是一个终端（或者其它“字符设备”），并将一个已知的保留的字符或序列解释为文件结束的指明；最普遍地说，它是ASCII码中的替换字符（Control-Z，代码26）。
在C语言中，或更精确地说成C标准函数库中表示文件结束符（end of file）。在while循环中以EOF作为文件结束标志，这种以EOF作为文件结束标志的文件，必须是文本文件。在文本文件中，数据都是以字符的ASCII代码值的形式存放。我们知道，ASCII代码值的范围是0~127，不可能出现-1，因此可以用EOF作为文件结束标志。
档案存取或其它 I/O 功能可能传回等于象征符号值 (巨集) EOF 指示档案结束的情形发生。实际上 EOF 的值通常为 -1，但它依系统有所不同。巨集 EOF会在编译原始码前展开实际值给预处理器。
C语言中，EOF常被作为文件结束的标志。还有很多文件处理函数处错误后的返回值也是EOF，因此常被用来判断调用一个函数是否成功。
例如：

#include <stdio.h>
int main(){
int n;
while(scanf(“%d”,&n) != EOF){

}
return 0;
}

当上面的程序运行时，如果不加” != EOF”，那么这个程序就是个死循环，会一直运行下去；加上” != EOF”后该程序就不是死循环了，如果在终端不进行输入该程序会自动结束(while的意思就是说当当前输入缓存还有东西时就一直读取，直到输入缓存中的内容为空时停止)。
在这”scanf(“%d”,&n) != EOF”相当于”scanf(“%d”,&n) != EOF”，或”~scanf(“%d”,&n)”，或”scanf(“%d”,&n) == 1 “ 。scanf的返回值由后面的参数决定

scanf(“%d%d”, &a, &b);
如果a和b都被成功读入，那么scanf的返回值就是2；如果只有a被成功读入，返回值为1；如果a和b都未被成功读入，返回值为0；如果遇到错误或遇到end of file，返回值为EOF，且返回值为int型。

但是在C++中不存在这种用法，但相同作用的有while((cin >> a) != 0)：
以前不理解在while里面用cin >> a;是什么意思，cin是C++的输入流对象，”>>”是重载的运算符，cin>>的返回值是cin对象。用这个当条件的话，通过检测其流的状态来判断结束；
（1）若流是有效的，即流未遇到错误，那么检测成功；
（2）若遇到文件结束符，或遇到一个无效的输入时（例如本题输入的值不是一个整数），istream对象的状态会变为无效，条件就为假；读取失败的时候，就不能继续读取了，那么读取操作结束，while(cin>>a)就返回false，跳出循环！
C++中的while (cin>>n,n)：
他的作用是：输入一个数，这数不为0时进入循环，为0时跳出循环。
采纳：”https://www.cnblogs.com/tgycoder/p/4958519.html"
输入（cin）缓冲是行缓冲。当从键盘上输入一串字符并按回车后，这些字符会首先被送到输入缓冲区中存储。每当按下回车键后，cin 就会检测输入缓冲区中是否有了可读的数据，这种情况下cin对键盘上是否有作为流结束标志CTRL+Z或者CTRL+D，其检查的方式有两种：阻塞式以及非阻塞式。

阻塞式检查方式指的是只有在回车键按下之后才对此前是否有 Ctrl+Z 组合键按下进行检查，非阻塞式样指的是按下 Ctrl+D 之后立即响应的方式。如果在按 Ctrl+D 之前已经从键盘输入了字符，则 Ctrl+D的作用就相当于回车，即把这些字符送到输入缓冲区供读取使用，此时Ctrl+D不再起流结束符的作用。如果按 Ctrl+D 之前没有任何键盘输入，则 Ctrl+D 就是流结束的信号。
阻塞式的方式有一个特点：只有按下回车之后才有可能检测在此之前是否有Ctrl+Z按下。
————————————————
版权声明：本文为CSDN博主「一个奔跑的C」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/henu1710252658/article/details/83040281

1570526156269

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
#include <stdio.h>
int main()
{
        int a,b;
        int sum[100];
        int i=0,n;
        while(scanf("%d %d",&a,&b),a|b)
        {
                sum[i]=a+b;
                n=i++;
        }
        for(i=0;i<=n;i++)
        {
                printf("%d",sum[i]);
                if(i!=n)
                {
                        printf("\n\n");
                }
        }
        return 0;
}




错误判别
#include<stdio.h>
int main()
{   
	int c[100],i,t=0,a,b;
	scanf("%d %d",&a,&b);
	if(a==0&&b==0)return 0;
	while(a!=0&&b!=0)
{	c[t]=a+b;
	t++;
	scanf("%d%d",&a,&b);
} 
    for(i=0;i<t;i++)
	printf("%d\n",c[i]);
	return 0;
}

1570534755894

1
2
3
4
5
6
7
8
9
10
11
C#include<stdio.h> 
int main()
{
	int a,b,c;
	while(scanf("%d %d",&a,&b)!=EOF)
	{
		c=a+b;
		printf("%d\n",c);
	}
	return 0;
}

1570536409666

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
int main()
{
    int n=100;
    int a[n],b[n];
    int i;
    scanf("%d",&n);
    if(n>=1&&n<=10)
    {
        for(i=0;i<n;i++)
        {
            scanf("%d %d",&a[i],&b[i]);
            }
        for(i=0;i<n;i++)
        {
            printf("%d\n",a[i]+b[i]);
            }
        }
    return 0;
    }

1570541691800

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
int main()
{
    int n,a,b,c;
    while(scanf("%d",&n)!=EOF)
    {
        c=n%60;
        b=n/60;
        if(b<60)
            a=0;
        else
        {
            a=b/60;
            b=b%60;
        }
        printf("%.2d:%.2d:%.2d\n",a,b,c);
    }
    return 0;
}

1570790269651

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<stdio.h>
#include<math.h>
int main()
{
	float n;
	while(scanf("%f",&n)!=EOF)
	{
		printf("%.2f\n",fabs(n));
	}
    return 0;
}


#include<stdio.h>
float f(float a);
int main()
{
float a,b;
while(scanf("%f",&a)!=EOF)
{
   b=f(a);
   printf("%.2f\n",b);
}
   return 0;
}
float f(float a)
{
float b;
if(a<0)
b=-a;
else
b=a;
return b;
}

1570790852764

1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
#include<math.h>
int main()
{
	float a,b,c,d,e;
	while(scanf("%f %f %f %f",&a,&b,&c,&d)!=EOF)
	{
		e=sqrt((a-c)*(a-c)+(b-d)*(b-d));
		printf("%.2f\n",e);
	}
    return 0;
}

1570793342522

1
2
3
4
5
6
7
8
9
10
11
12
13
C#include<stdio.h>
#include<math.h>
int main()
{
	double d,n,m,p;
	p=acos(-1);
	while(scanf("%lf %lf",&d,&n)!=EOF)
	{
		m=d*p*n*1.0;
		printf("%.2f\n",m);
	}
    return 0;
}

1570793783184

1
2
3
4
5
6
7
8
9
10
11
12
13
#include<stdio.h>
#include<math.h>
int main()
{
	double a,b,c,p,S;
	while(scanf("%lf %lf %lf",&a,&b,&c)!=EOF)
	{
		p=(a+b+c)/2;
		S=sqrt(p*(p-a)*(p-b)*(p-c)*1.0);
		printf("%.3f\n",S);
	}
    return 0;
}

1570794453469

1
2
3
4
5
6
7
8
9
10
11
12
#include<stdio.h>
int main()
{
	int a,b,c;
	while(scanf("%d %d",&a,&b)!=EOF)
	{
		c=a+b;
		if(a==0&&b==0)break;
		printf("%d\n",c);
	}
    return 0;
}

1570794653446

1
2
解题思路：
本题涉及n组数据，而每组数据开头都是字符，scanf读取字符是会先读取换行，所以应当在读取每行数据之前，用getchar将回车吃掉，否知只能读取一半数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
int main()
{
	int n,y,i;
	char x;
	scanf("%d",&n);
	while(n--)
{
		getchar();
		scanf("%c%d",&x,&y);
		if(x>='a'&&x<='z')
		printf("%d\n",'a'-x-1+y);
		else if(x>='A'&&x<='Z')
		printf("%d\n",x-'A'+1+y);
}
return 0;
}

10.多组数据&选择结构

1570794772999

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
int main()
{
	int a,b,n,t;
	scanf("%d",&n);
	while(scanf("%d %d",&a,&b)!=EOF)C
	{
		if(a<b)
		{
			t=a;
			a=b;
			b=t;
		}
		printf("%d\n",a);
	}
    return 0;
}

1571041476764

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
int main()
{
	int year;
	int number,te;
	scanf("%d",&number);
	for(te=1;te<=number;te++)
	{
		scanf("%d",&year);
		if((year%4==0 && year%100!=0) || (year%400==0))
              printf("Yes\n");
		else
			printf("No\n");
     return 0;
}
}

1571139498278

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
53
54
55
56
#include <iostream>
using namespace std;
int main()
{
       int a;
       while(cin>>a)
       {if(a>=90&&a<=100) cout<<'A'<<'\n';
       else if(a>=80&&a<90) cout<<'B'<<'\n';
       else if(a>=70&&a<80) cout<<'C'<<'\n';
       else if(a>=60&&a<70) cout<<'D'<<'\n';
       else if(a>=0&&a<60) cout<<'E'<<'\n';
       else cout<<"Score is error!"<<'\n';}        //错误的成绩包括大于100和小于0的数
      return 0;
}





有问题 
#include<stdio.h>
int main()
{
	int t;
	while(scanf("%d",&t)!=EOF)
	{
		switch(t/10)
		{
			case 10:
		  	case 9:
		  	printf("A\n");
		  	break;
		  	case 8:
		  	printf("B\n");
		  	break;
		  	case 7:
		  	printf("C\n");
		  	break;
		  	case 6:
		  	printf("D\n");
		  	break;	
			case 5:
			case 4:
			case 3:
			case 2:
			case 1:
			case 0:
		  	printf("E\n");
		  	break;
		  	default:
		  	printf("Score is error!\n");
		  	break;
		}
	}
	return 0;
}

1571219605230

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
#include<stdio.h>
int main()
{
char a, b, c;
char z;
while (scanf("%c%c%c", &a, &b, &c) != getchar())
{
if (a > b)
{
z = a;
a = b;
b = z;
}
if (a > c)
{
    z = a;
    a = c;
    c = z;
}
if (b > c)
{
    z = b;
    b = c;
    c = z;
}
printf("%c %c %c\n", a, b, c);
}
return 0;
}

1571225773008

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
#include<math.h>
int main()
{
	int n,m;
	while(scanf("%d",&n)!=EOF)
{
	if(n==-1)
	break;
	else
	m=(int)(sqrt(n));
	if(m*m==n)
	printf("Yes\n");
	else
	printf("No\n");}
	return 0;
}

1571225899927

#include

#include
using namespace std;
class tr
{private:
int a,b,c,k,s,d;
double h;
public:
void iutput();
void chuli();
void output();
};
int main()
{ int n,i;
tr tr[1000];
cin>>n;
for(i=0;i<n;i++)
{ tr[i].iutput();
tr[i].chuli();
}
return 0;
}
void tr::iutput()
{
cin>>a>>b;
}
void tr::chuli()
{ s=a+b;
d=a-b;
k=ab;
if(a%b==0)
cout<<s<<’ ‘<<k<<’ ‘<<d<<’ ‘<<a/b<<endl;
else
cout<<s<<’ ‘<<k<<’ ‘<<d<<’ ‘<<setiosflags(ios::fixed)<<setprecision(2)<<a/(b1.00)<<endl;
}

坚持原创技术分享，您的支持将鼓励我继续创作！