【C语言】程序阅读题-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C语言】程序阅读题。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

程序阅读题

输出以下程序的结果

#include <stdio.h>
int main()
{
    char ch;int k = 0;
    for(ch = 'A';ch < 'H';ch++,k++)
        if(k%2==0)
            printf("%c ",ch);
    printf("\n");
    return 0;
}

A C E G
从A开始到H结束，k从0开始自加，k为偶数时输出字符
  	ch A B C D E F G H	
  	k  0 1 2 3 4 5 6 7 

输出以下程序结果

#include <stdio.h>
int main()
{
    int k = 0;char c = 'A';
    do{
        switch (c++) {
            case 'A':k++;break;
            case 'B':k--;
            case 'C':k+=2;break;
            case 'D':k=k%2;break;
            case 'E':k=k*10;break;
            default:k=k/3;
        }
        k++;
    }while(c<'G');
    printf("k=%d\n",k);
    return 0;
}

k=8

  c='A',无条件执行一次do内循环体
  c++,是先取c的值进入switch，之后再自加
  k=1,c自加，C='B',k自加，k=2
  k=1,没有break，继续执行，k=3,c自加，c='C',k自加,k=4
  k=6,c自加，c='D',k自加,k=7
  k=1,c自加，c='E',k自加，k=2
  k=20,c自加，c='F',k自加,k=21
  k=7,c自加,c='G',k自加，k=8
  退出循环

输出程序结果

#include <stdio.h>
int main()
{
    int a[6] = {12,4,17,25,27,16};
    int b[6] = {27,13,4,25,26,16};
    int i,j;
    for(i=0;i<6;i++){
        for(j=0;j<6;j++)
            if(a[i] == b[j])
                break;
        if(j<6)
            printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}

4 25 27 16

  外层循环会取出a的每一个值
  内层循环会将a[i]与b的每一个值比较
  如果有相等的值会退出内层循环并输出
  程序的目的是找到两个数组相同的值

输出程序结果

#include <stdio.h>
int main()
{
    int a[8]={1,0,1,0,1,0,1,0},i;
    for(i=2;i<8;i++)
        a[i] += a[i-1]+ a[i-2];
    for(i=0;i<8;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}

1 0 2 2 5 7 13 20
从第三个开始，每个数加上前两个数的和
注意之前的求和会对后续的求和有影响
  1 0 1 0 1 0  1  0
  1 0 2 2 5 7 13 20

输入数据为2,4，输出程序的结果

#include <stdio.h>
int main()
{
    int s=1,t=1,a,n;
    scanf("%d%d",&a,&n);
    for(int i=1;i<n;i++)
    {
        t = t*10+1;
        s = s+t;
    }
    s*=a;
    printf("SUM=%d\n",s);
    return 0;
}

SUM=2468

  s=1,t=1,a=2,n=4
  i=1,t=11,s=12
  i=2,t=111,s=123
  i=3,t=1111,s=1234
  i=4,退出循环
  s=2468

6.输出结果

# include <stdio.h>
# include <stdlib.h> 
# define PR(x,y) printf("%s=\t%d\n",x,y)
int main()
{
    int x=03,y=02,z=01;
    char str[25];
    PR("x|y&z",x|y&z);
    PR("x^y&~z",x^y&~z);
    PR("x&y&z",x&y&z);
    x=1;y=-1;
    PR("! x|x",! x|x);
    PR("~x|x",~x|x);
    return 0;
}

  x|y&z=  3
  x^y&~z= 1
  x&y&z=  0
  ! x|x=  1
  ~x|x=   -1
这个题目巨TM坑，先做必要的知识储备
--------------------------------------------------
首先是输出格式，“%s=\t%d\n”，一个字符串后跟一个整数，注意这之间有一个\t;
\t是制表符，不是4个空格！！！
\t的空格数量并不是随机的，而是每8个字符串自动补齐。如果超过8个字符，就以最接近8的倍数补齐。
所以输出结果前的空格数并不相等。
--------------------------------------
然后是符号的优先级
！、~ > & > ^ > |
! 逻辑非
~ 按位取反
& 按位与运算
^ 按位异或，同0非1
| 按位或运算
------------------------------------------
x:0011,y:0010,z:0001
①x|y&z
先算y&z:0000
再算x|,0011,结果为3
②x^y&~z
先算~z,1110
再算y&，0010
再算x^,0001,结果为1
③x&y&z
先算x&y,0010
再算&z,0000,结果为0
------------------------------------------
x:0001
④! x|x
先算!x,0000
再算|x,0001,结果为1
⑤~x|x
先算~x,1110
再算|x,1111,结果为-1
负数在计算机中用补码表示，符号位不变，减一取反得到原码

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    int a[5] = {2,4,6,9,12},b[6] = {2,3,4,6,8,9};
    for(int i=0;i<5;i++)
        for(int j=0;j<6;j++)
            if(*(a+i)==*(b+j))
                printf("%d ",*(a+i));
        printf("\n");
    return 0;
}

2 4 6 9

  只是将数组的下标操作方式更换为了指针
  最终结果还是比较两个数组的元素，找到相同的并输出

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    char str1[] = "*******";
    for(int i=0;i<4;i++){
        printf("%s\n",str1);
        str1[i] = ' ';
        str1[strlen(str1)-1]='\0';
    }
    return 0;
}

  *******
   *****
    ***
   	 *

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    char a[5][8];
    for(int i=0;i<5;i++)
        for(int j=0;j<8;j++)
            if(i==0||i==4)
                a[i][j] = '-';
            else
                a[i][j] = ' ';
    for(int i=1;i<4;i++){
        a[i][0] = '|';
        a[i][5] = '|';
    }
    for(int i=0;i<5;i++)
        a[i][6] = '\0';
    for(int i=0;i<5;i++)
        printf("%s\n",a[i]);
    return 0;
}

  ------
  |    |
  |    |
  |    |
  ------

c语言程序阅读题,笔记,c语言,c++,程序阅读题,基础入门

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    char a[8],temp;int i,j;
    for(i=0;i<7;i++)
        a[i] = 'a'+i;
    for(i=0;i<3;i++){
        temp = a[0];
        for(j=1;j<7;j++)
            a[j-1] = a[j];
        a[6] = temp;a[7] = '\0';
        printf("%s\n",a);
    }
    return 0;
}

bcdefga
cdefgab
defgabc

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    int i,j,n;
    for(i=0;i<4;i++){
        for(j=1;j<=i;j++)
            printf(" ");
        n = 7-2*i;
        for(j=1;j<=n;j++)
            printf("%d",n);
        printf("\n");
    }
    return 0;
}

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 

int main()
{
    char a[8],temp;
    int j,k;
    for(j=0;j<7;j++)
        a[j] = 'a'+j;
    a[7] = '\0';
    for(j=0;j<3;j++){
        temp = a[6];
        for(k=6;k>0;k--)
            a[k] = a[k-1];
        a[0] = temp;
        printf("%s\n",a);
    }
    return 0;
}

gabcdef
fgabcde
efgabcd

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
void print(int begin,char pzf,int n);
int main()
{
    print(3,'*',1);print(2,'*',3);
    print(1,'*',5);print(2,'#',3);
    print(2,'#',3);
    return 0;
}
void print(int begin,char pzf,int n)
{
    char a[50];int i;
    for(i=0;i<begin;i++)
        a[i] = ' ';
    for(i=0;i<n;i++)
        a[begin+i] = pzf;
    a[begin+i] = '\0';
    printf("%s\n",a);
}

关键是看懂print函数。
begin代表的是前面给多少个空格
n则是将pzf复制的次数

结果为
   *
  ***
 *****
  ###
  ###

输入为5 -7 3，输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
int a,b,c,find(int , int ,int );
int main()
{
    scanf("%d%d%d",&a,&b,&c);
    printf("%d\n%d,%d,%d\n",find(a,b,c),a,b,c);
    return 0;
}
int find(int a,int b,int c)
{
    int u,s,t;
    u = ((u=(a>b)?a:b)>c)?u:c;
    t = ((t=(a<b)?a:b)<c)?t:c;
    s = a+b+c-u-t;
    a = u;b = s; c = t; 
    return s;
}

3
5,-7,3

(a>b)?a:b是指如果a>b成立，那么取a，否则取b
那么u的取值就是先比较了a,b再比较c
u为取a,b,c最大值，t为a,b,c的最小值，s为中间值，最后返回s；
在find函数中重新int了a,b,c那么函数中a,b,c为局部变量，影响不到全局变量，最终输出的a,b,c值不变

15.输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
void fun1(int n,int a[][3])
{
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++){
            printf("%d / %d\n",a[i][j],a[i][i]);
            a[i][j] = a[i][j]/a[i][i];}
}
int main()
{
    int a[3][3] = {{6,4,2},{8,6,4},{9,6,3}};
    fun1(3, a);
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    return 0;
}

1 4 2
1 1 4
3 2 1

  fun1的意思很明确，每一行元素除以主对角线的元素。
  但是主对角线元素也会变，导致后面除以的数也可能发生变动。

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
int fun3(int m)
{
    int i;
    if(m==3 || m==2)    return 1;
    if(m<2 || m%2==0)   return 0;
    for(i=3;i<m;i+=2)
        if(m%i==0)
            return 0;
    return 1;
}
int main()
{
    int n;
    for(n=1;n<10;n++)
        if(fun3(n)==1)
            printf("%d ",n);
    return 0;
}

2 3 5 7

  再fun3中，0，1因为小于2，返回值为0；
  2,3直接返回1；
  大于3时，偶数直接返回0，判断是否是3,5,7,9....的倍数，不是返回1；
  可以认为这是一个判断是否是素数的函数

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
void sub(int *a,int *b,int *c,int m,int n)
{
    int i,j;
    for(i=0;i<m;i++)    *(c+i) = *(a+i);
    for(j=0;j<n;j++,i++)    *(c+i) = *(b+j);
}
int main()
{
    int i,x[5]={1,5,3,8,4},y[3]={9,-4,6},z[8];
    sub(x,y,z,5,3); 
    for(i=0;i<8;i++)    printf("%d ",z[i]);
    printf("\n");
    return 0;
}

1 5 3 8 4 9 -4 6

  int *a，是一个整数指针，用这种写法来代表传入整数数组
  sub的意思很明确，将a数组的前m个数以及c数组的前n个数赋值给c数组。

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
void sort(char *a[],int n)
{
    int i,j,l; char *temp;
    for(i=0;i<n-1;i++){
        l = i;
        for(j=i+1;j<n;j++)
            if(strcmp(a[j],a[l])<0) l =j;
        if(l!=i){
            temp = a[i];a[i]=a[l];a[l]=temp;   
        }
    }
}
int main()
{
    char *name[4];int k;
    char ch[4][15] = {"morning","afternoon","night","evening"};
    for(k=0;k<4;k++)    name[k]=ch[k];
    sort(name,4);
    for(k=0;k<4;k++)
        printf("%s\n",name[k]);
    return 0;
}

afternoon
evening
morning
night

  strcmp(str1,str2)，会将两个str逐个字符进行大小比较
  str1小于str2，返回值为-1
  str1等于str2，返回值为0
  str1小于str2，返回值为1
  
  再来看sort函数
  双层的for循环是将字符串和后面的字符串进行比较
  用l记录最小的字符串的下标，再利用三角交换将当前字符串与最小的字符串进行交换
  外层循环每往后移，就会选出一个最小的放到前面
  应用的就是选择排序

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
void pline(char *a,char c,int l,int n)
{
    int i;
    for(i=1;i<l;i++){
        *a = ' ';
        a++;
    }
    for(i=1;i<=n;i++,*a=c,a++);
    *a = '\0';
}
int main()
{
    char a[80];
    int i;void (*pf) (char*,char,int,int);
    pf = pline;
    for(i=1;i<5;i++){
        (*pf)(a,'$',5-i,2*i-1);
        puts(a);
    }
    return 0;
}

     $
    $$$
   $$$$$
  $$$$$$$
先看pline函数，传入数组a、字符c，l 和n
第一个for循环用来在a中写入l-1个空格
第二个for循环用来在a中写入n个字符c
在main函数中，重新将pline函数给了*pf
在for循环中看 l 和 n 的变化
i=1: (4,1)
i=2: (3,3)
i=3: (2,5)
i=4: (1,7)

输出结果

# include <stdio.h>
# include <stdlib.h> 
# include <string.h> 
int binary(int x,int a[],int n)
{
    int low=0,high=n-1,mid;
    while(low<=high){
        mid=(low+high)/2;
        if(x>a[mid])   high = mid-1 ;
        else if (x<a[mid])     low=mid+1 ;
        else    return mid;
    }
    return -1;
}     
int main()
{
    static int a[]= {4,0,2,3,1};
    int i,t,j;
    for(i=1;i<5;i++){
        t = a[i];j=i-1;
        while(j>0 && t>a[j]){
            a[j+1] = a[j];
            j--;
        }
        a[j+1]=t;
    }   
    printf("%d \n",binary(3, a, 5));
    return 0;
}

  main函数中的for嵌套while循环实现了从大到小的插入排序
  binary函数则是实现了二分查找，最终返回查找元素的下标

输出结果

# include <stdio.h>
# include <math.h> 
int main()
{
    double f(double,int);
    printf("%lf\n",f(2.0,14));
    return 0;
}
double f(double x,int n)
{
    double t;
    if(n==1)    t = x;
    else{
        if(n/2*2==n)    t=x*f(x,n/2);
        else t=x*pow(f(x,n/2),2.0);
    }
    return t;
}

256.000000

  一个简单的递归，注意不要绕糊涂了
    f(2.0,14)
  = 2.0 * f(2.0,7)
  = 2.0 * 2.0 * f(2.0,3)^2
  = 2.0 * 2.0 * [2.0 * f(2.0,1)^2]^2
  = 2 * 2 * [2 * 2^2]^2
  = 256

输出结果

# include <stdio.h>
# include <math.h> 
double t(double a,double (*f)(double) )
{
    return (*f)(a*a);
}
double f(double x)
{
    return 2.0*x;
}
double g(double x)
{
    return 2.0+x;
}
int main()
{
    double x = 4.0;
    double u = t(x,f);
    double v = t(x,g);
    printf("u=%5.3f v=%5.3f\n",u,v);
}

u=32.000 v=18.000

  t函数的第二个参数用来传递一个函数
  %5.3f指小数位保留三位，整体如果不足5位，在最前面补空格

输出结果

# include <stdio.h>
# include <math.h> 
int main()
{
     struct s1{char c[4],*s;};
     struct s1 s1 = {"abc","def"};
     struct s2{char *cp;struct s1 ss1;};
     struct s2 s2 = {"ghi",{"jkl","mno"}};
     printf("%c,%c\n",s1.c[0],*s1.s);
     printf("%s,%s\n",s1.c,s1.s);
     printf("%s,%s\n",s2.cp,s2.ss1.s);
     printf("%s,%s\n",++s2.cp,++s2.ss1.s);
}

a,d
abc,def
ghi,mno
hi,no
简单的结构体的考察

输出结果

# include <stdio.h>
struct s1 {char *s;int i;struct s1 *slp;};

int main()
{
    struct s1 a[] = { {"abcd",1,a+1}, {"efgh",2,a+2}, {"ijkl",3,a} };
    int i;
    for(i=0;i<2;i++){
        printf("%d\n",--a[i].i);
        printf("%c\n",++a[i].s[3]) ;
    }
}

题目有问题
++a[i].s[3]运行不起来

输出结果

#include <stdio.h>
int main()
{
    FILE *fp;int i;
    char s1[80],s[]="abcdefghijklmnop";
    fp = fopen("alf.dat","wb+");i=sizeof(s);
    fwrite(s,i,1,fp);rewind(fp);fread(s1,i,1,fp);
    printf("all=%s\n",s1);fseek(fp,0,0);
    printf("seek1 ch=%c\n",fgetc(fp));
    fseek(fp,10,1);
    printf("seek2 ch=%c\n",fgetc(fp));
    fseek(fp,1,1);
    printf("seek3 ch=%c\n",fgetc(fp));
    fclose(fp);
    return 0;
}

all=abcdefghijklmnop
seek1 ch=a
seek2 ch=l
seek3 ch=n

  函数原型：
  int fseek(FILE *stream, long offset, int fromwhere);
  offset 偏移量参数 , 可以为正数 , 也可以为负数 ;
  fromwhere 参数就是 起始位置 , 有三种选择
  	-文件头 SEEK_SET 0
  	-当前位置 SEEK_CUR 1
  	-文件尾 SEEK_END 2
  -------------------------
  size_t fread( void *buffer, size_t size, size_t count, FILE *stream );
  *buffer 参数 : 将文件中的二进制数据读取到该缓冲区中 ;
  size 参数 : 每个元素的大小（以字节为单位）
  count 参数 : 读取元素的个数 ;
  size_t 返回值 : 实际从文件中读取的元素个数 
  ---------------------------
  size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
  *ptr : 指针指向要写出数据的内存首地址 ;
  size : 要写出元素的字节大小 
  nmemb : 要写出元素的个数 
  size_t 返回值：返回的是实际写出到文件的 基本单元个数 
  ----------------------------
  rewind()函数：将指针重新指向文件的开头
  -----------------------------
  fgetc()函数：读取文件的下一个字符，并将文件指针+1

输出结果

#include <stdio.h>
int main()
{
    struct T1{char c[4],*s;};
    struct T1 s1 ={"abc","def"};
    struct T2 { char *cp;struct T1 ss1;};
    struct T2 s2 = {"ghi",{"jkl","mno"}};
    printf("%c,%c\n",s1.c[0],*s1.s);
    printf("%s,%s\n",s1.c,s1.s);
    printf("%s,%s\n",s2.cp,s2.ss1.s);
    printf("%s,%s\n",++s2.cp,++s2.ss1.s);
    return 0;
}

a,d
abc,def
ghi,mno
hi,no
  最后的++，是指针的后移

输出结果

# include <stdio.h>
#include <string.h>
#include <malloc.h>
int main()
{
    struct info{ int data;struct info *pn;};
    struct info *base,*p;
    base = NULL;
    for(int i=0;i<10;i++){
        p = (struct info *)malloc(sizeof(struct info));
        p->data = i+1;
        p->pn = base;
        base = p;
    }
    p = base;
    while (p!=NULL) {
        printf("%2d",p->data);
        p = p->pn;
    }
    printf("\n");
}

10 9 8 7 6 5 4 3 2 1
每次新的节点都会插在第一个位置，没有头节点时的头插法。

输出结果

# include <stdio.h>
#include <string.h>
#include <malloc.h>
void del_bk(char *p)
{
    char *p1=p;
    while(*p1 != '\0')
        if(*p1 ==' ' &&  *(p1+1)==' ')
            strcpy(p1,(p1+1));
        else
            p1++;
}
int main()
{
    char aa[] = "aa bb   cccc   ddd  efg   h";
    printf("%s\n",aa);
    del_bk(aa);
    printf("%s\n",aa);
}

  aa bb   cccc   ddd  efg   h
  aa bb cccc ddd efg h
在del_bk函数中，当遇到两个连续的空格的时候，第二个空格开始全部前移
导致有空格的地方只会出现一个空格

输出结果

# include <stdio.h>
#include <string.h>
#include <malloc.h>

int main()
{
    int m[] = {1,2,3,4,5,6,7,8,9},i,j,k;
    for(i=0;i<4;i++){
        k=m[i];m[i]=m[8-i];m[8-i] = k;
        for(j=0;j<9;j++)
            printf("%d ",m[j]);
        putchar('\n');
    }
}

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

输出结果


int main()
{
    int x[4][4] = {{1,2,3,4},{3,4,5,6},{5,6,7,8},{7,8,9,10}};
    int i,j;
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
            *(*(x+i)+j) /= *(*(x+i)+i);
    for(i=0;i<4;i++){
        for(j=0;j<4;j++)
            printf("%3d",*(*(x+i)+j));
        putchar('\n');
    }
}

1 2 3 4
0 1 5 6
0 0 1 8
0 0 0 1
最后两层循环也暗示了*(*(x+i)+j)将输出整个数组，那么上一层循环无非就是将整个数组元素除以相应行的对角线元素。

输出结果

int main()
{
    char line[] = "123456789";
    int i,k=strlen(line);
    for(i=0;i<4;i++){
        line[k-i] = '\0';
        puts(line+i);
    }
}

123456789
2345678
34567
456

输出结果

int main()
{
    char a[5][20] = {"abd","def","123","456","#$%"};
    int i,j;
    for(i=0;i<4;i++){
        j=0;
        while(a[i][j])  j++;
        strcat(*(a+i)+j,*(a+i+1));
    }
    for(i=0;i<4;i++)    puts(*(a+i));
}

abddef
def123
123456
456#$%

  strcat函数又被称为是字符串追加/连接函数
  追加的字符串src和目标字符串dest中都必须要带有字符’\0’
  并且追加字符串src必须以‘\0’结
  否则追加过程无法顺利实现。

输出结果

#define S x=y=z
#define P3(x,y,z) printf("x=%d\ty=%d\tz=%d\n",x,y,z);
int main()
{
    int x,y,z;
    S = 1;++x||++y||++z;P3(x, y, z);
    S = 1;++x&&++y||++z;P3(x, y, z);
    S = 1;++x&&++y&&++z;P3(x, y, z);
    S =-1;++x||++y&&++z;P3(x, y, z);
    S =-1;++x||++y||++z;P3(x, y, z);
    S =-1;++x&&++y&&++z;P3(x, y, z);
}

  x=2     y=1     z=1
  x=2     y=2     z=1
  x=2     y=2     z=2
  x=0     y=0     z=-1
  x=0     y=0     z=0
  x=0     y=-1    z=-1
||运算只要有一个为1，&&运算只要有一个为0就为0；
||运算第一个为真，后面的运算就会被跳过
&&运算第一个为假，后面的运算就会被跳过。

输出结果

#define P3(x,y,z) printf("x=%d\ty=%d\tz=%d\n",x,y,z);
int f(int m,int n)
{
    if(m%n == 0) return 0;
    else return f(n,m%n);
}
int main()
{
    printf("%d\n",f(840,48));
}

0

输出结果

int f1(int,int),f11(int);
void f2(int);
int main()
{
    int i,j;
    for(i=0;i<5;i++){
        f2((5-i)*3);
        for (j=0; j<=i; j++) 
            printf("%3d",f1(i,j));
        putchar('\n');
    }
}
int f1(int m,int n)
{
    return f11(m)/f11(n)/f11(m-n);
}
int f11(int k)
{
    if(k<=1)    return 1;
    return k*f11(k-1);
}
void f2(int n)
{
    for(int i=1;i<=n;i++)
        putchar(' ');
}

                   1
                1  1
             1  2  1
          1  3  3  1
       1  4  6  4  1

f11显然是一个求阶乘的函数

输出结果

void prn(int a,int b,int c,int max,int min)
{
    max = (max=a>b?a:b)>c?max:c;
    min = (min=a<b?a:b)<c?min:c;
    printf("max=%d   min=%d\n",max,min);
}
int main()
{
    int x,y;
    x = y = 0;
    prn(19,23,-4,x,y);
    printf("max=%d   min=%d\n",x,y);
}

max=23 min=-4
max=0 min=0

  prn中的写法之前已经介绍了，
  其作用是输出a,b,c中的最大最小值
  但max和min只是形参，对x,y的值并不会改变

输入35dffE，输出结果

int main()
{
    char a,b,x;int i;
    while(!isupper(x=getchar()));
    for(a='A';a<=x;a++){
        for(b='A';b<'A'+x-a;b++)
            putchar(' ');
        for(i=1;i<=2*(a-'A')+1;i++)
            putchar(a);
        putchar('\n');
    }
}

      A
     BBB
    CCCCC
   DDDDDDD
  EEEEEEEEE

输入a the asdftheth e there. 输出结果

int main()
{
    char x; int n = 0, k = 0;
    while ((x=getchar())!='.') {
        switch (x) {
            case 't':k++;break;
            case 'h':if(k==1)   k++;break;
            case 'e':if(k==2)   k++;break;
            default:k=0;
        }
        if(k==3)    n++;
    }
    printf("%d\n",n);
}

  要想n++，k必须等于3
  the只出现一次的时候k才会被加到3

输入 69和72，输出结果

int main()
{
    unsigned k,n;
    scanf("%u",&n);
    k = n%10*10 + n/10;
    printf("n=%d   k=%d\n",n,k);
}

n=69 k=96
n=72 k=27

输出结果

int main()
{
    int x = 40,y = 4,z = 4;
    x=y==z;
    printf("%d   %d   %d\n",x,y,z);
    x=x==(y=z);
    printf("%d   %d   %d\n",x,y,z);
}

1 4 4
0 4 4
先看y==z为1，赋值给x
先算括号（y=z），括号内的4，x == 4为0，赋值给x

输出结果

int main()
{
    int x,y,z;
    x = y =2; z = 3;
    y = x++-1;
    printf("%d\t%d\t%d\t",x,y,z);
    y=--z+1;
    printf("%d\t%d\t%d\n",x,y,z);
    x=y=z=0;
    printf("%d\t%d\t%d\t",x,y,z);
    --x&&++y&&++z;
    printf("%d\t%d\t%d\n",x,y,z);
}

  3       1       3       3       3       2
  0       0       0       -1      1       1
x++是先等运算结束再自加，而++x优先级更高，先自加再运算
最后的逻辑运算也是自加自减运算完成之后再进行

输入3 4 5 ，输出结果

int main()
{
    float a1,a2,a3,s,d;
    scanf("%f%f%f",&a1,&a2,&a3);
    s = (a1+a2+a3) / 2;
    s = sqrt(s * (s-a1) * (s-a2) * (s-a3));
    printf("%.2f%%%.2f%%%.2f  %-10.3f\n",a1,a2,a3,s);
}

  3.00%4.00%5.00  6.000   
指定数据宽度和小数位数用%m.nf 。m表示输出数据的宽度，即占m列，n表示小数点后保留n位小数。
出的数据向左对齐，用%-m.nf
输出百分号用%%，而不是用 \%

输出结果

int main()
{
    static int a[5] = {1,3,5,7,9};
    static int *num[5]={&a[2],&a[1],&a[0],&a[3],&a[4]};
    int **p,i;
    p = num;
    for(i=0;i<5;i++){
        printf("%d\t",**p);
        p++;
    }
}

  5       3       1       7       9
p是一个指向的指针，要访问数据就得用**p

输出结果

int f(char c,char *s){
    int m,n,h;
    for(n=0,h=strlen(s);n<=h;){
        m = (n+h) / 2;
        if(c<s[m])      h=m-1;
        else if (c>s[m])    n=m+1;
        else    return m;
    }
    return -1;
}
int main()
{
    printf("%d\n",f('g',"abdgkmxy"));
    printf("%d\n",f('T',"BGMAXYZOTE"));
}

3
-1

  f实现的是用for循环实现的一个字符串的二分查找
  第一个字符串有序返回了下标
  第二个字符串无序，查找失败

输出结果

int inv(int *x,int n){
    int *p,t,*i,*j,m=(n-1)/2;
    i=x;j=x+n-1;p=x+m;
    for(;i<=p;i++,j++){
        t=*i;*i=*j;*j=t;
    }
    return 0;
}
int main()
{
    int i,a[]={1,3,5,7,9,11,13,15};
    inv(a, 5);
    for(i=1;i<=5;i++)   
        printf("%d  ",*(a+i));
}

  11  13  7  1  3

输出结果

int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int main()
{
    int s,k;
    for(s=0,k=0;k<3;k++)    s+=a[k][k];
    printf("%d--",s);
    for(s=0,k=0;k<3;k++)    s+=a[k][3-k];
    printf("%d--",s);
    for(s=0,k=0;k<4;k++)    s+=*(a[1]+k);
    printf("%d\n",s);
}

18–21–26
最后一个实现的是a的第一行的求和

输出结果

int x,y,z;
void p(int *x,int y){
    ++*x;y--;z=*x+y;
    printf("%d,%d,%d--",*x,y,z);
}
int main()
{
    x=2;y=3;z=4;
    p(&x,y);
    printf("%d,%d,%d--",x,y,z);
    p(&y,x);
    printf("%d,%d,%d\n",x,y,z);
}

  3,2,5--3,3,5--4,2,6--3,4,6
注意全局变量和指针的传递

输出结果

int main()
{
    int m=18,s=0;
    do{
        switch (m%7) {
            case 2:m/=2;s+=2;break;
            case 3:m/=3;s+=3;break;
            case 5:m/=5;s+=5;break;
            default:m--;s--;
        }
        printf("%d\n",s);
    }while(m);
}

-1
2
7
6

输出结果

void div(int *n,int *k)
{
    if(*n % *k == 0){
        printf("%d,%d\n",*n,*k);
        *n/=*k;
    }
    else    (*k)++;
}
int main()
{
    int a[5] = {-5,0,60,45,34},i=0,j=2;
    while (a[i]<=0) i++;
    while(a[i]!=1)  div(a+i,&j);

}

60,2
30,2
15,3
5,5

输出结果

int main()
{
    int s[8],i;char ch='B'-1;
    printf("%c %d\n",ch,ch);
    for(i=7;i>=0;i--){
        s[i]=ch&1;
        ch = ch >>1;
    }
    for(i=0;i<8;i++)    printf("%d ",s[i]);
    printf("\n");
}

  A 65
  0 1 0 0 0 0 0 1
和1进行与运算，可以判断最后一位是0还是1
然后不断向后移动一位，再进行与运算
实现了逐位判断是0还是1，可以快速得到数的二进制

输出结果

int main()
{
    char c,a[]="Office";int i;
    for(i=0;i<strlen(a)/2;i++){
        c = *a;
        strcpy(a, a+1);
        a[strlen(a)]=c;
        a[strlen(a)+1]='\0';
        puts(a);
    }
}

ffcceO
fceeOf
ceOOff

输出结果

int main()
{
    float a[4][3]={ {3,2,5},{-3,2,1},{4,3,2},{5,1,3}};
    int i,j;float v;
    for(i=0;i<4;i++){
        v=a[i][0];
        for(j=1;j<3;j++)    v+=a[i][j];
        v/=3;
        for(j=0;j<3;j++)    a[i][j]-=v;
    }
    for(i=0;i<4;i++){
        for(j=0;j<3;j++)
            printf("%6.1f,",a[i][j]);
        printf("\b \n"); 
    }
}

    -0.3,  -1.3,   1.7 
    -3.0,   2.0,   1.0 
     1.0,   0.0,  -1.0 
     2.0,  -2.0,   0.0 
结尾的\b是把光标前移一位，目的是消除末尾的逗号

输出结果

int main()
{
    struct node{ int x; struct node *next;} *p1,*p2=NULL;
    int a[5] = {7,6,-5,28,1},i,j,s;
    for(i=0;i<5;i++){
        s=0;
        for(j=1;j<=a[i]/2;j++)
            if(a[i]%j==0)
                s+=j;
        if(a[i]!=s){
            p1 = (struct node*)malloc(sizeof(struct node));
            p1->x = a[i];
            p1->next = p2;
            p2 = p1;
        }
    }
    while(p1!=NULL){
        printf("%d\n",p1->x);
        p1 = p1->next;
    }
}

1
-5
7
该程序是求出数的所有正数因子，若求和不等于原数，则记录在链表中。

输出结果

int main()
{
    union{char c;int i;}t;
    t.c='A';t.i=1;
    printf("%d,%d",t.c,t.i);
}

1,1

  联合体内部的数据共享同一段内存
  意思就是说联合体内部的字符和整形首地址是一样的
  联合体的字节数为所占字节最大的变量的字节数

t.i的修改覆盖了t.c的修改

输出结果

int main()
{
    static char a[] = "program",*ptr;
    for(ptr=a;ptr<a+7;ptr+=2)
        putchar(*ptr);
}

porm

输出结果

int main()
{
    static char a[] = "language",b[]="program";
    char *ptr1,*ptr2=b;
    ptr1=a;
    for(int k=0;k<7;k++){
        if(*(ptr1+k)==*(ptr2+k))
            printf("%c",*(ptr1+k));
    }
}

ga

输出结果

int main()
{
    static int a[2][3]={ {1,2,3},{4,5,6} };
    int m,*ptr;
    ptr = &a[0][0];
    m = (*ptr)*(*(ptr+2))*(*(ptr+4));
    printf("%d\n",m);
}

  1*3*5

输出结果

void ptrv(int *x)
{
    printf("%d\n",++*x);
}
int main()
{
    int z = 25;
    ptrv(&z);
}

26

输出结果

int main()
{
    static char a[] = "language";
    char *ptr = a;
    while (*ptr) {
        printf("%c",*ptr-32);
        ptr++;
    }
}

LANGUAGE
ASCII码中大小写之间刚好相差32

输出结果

int f(int x,int y)
{
    return y-x;
}

int main()
{
    int a=5,b=6,c=2;
    int f(),(*g)() =f;
    c=(*g)(a,b);
    printf("%d\n",c);
}

1
出现的是函数的指针

输出结果

char b[] = "program";
char *a = "PROGRAM";
int main()
{
    int i=0;
    printf("%c%s\n",*a,b+1);
    while (putchar(*(a+i))) i++;
    printf("\ni=%d\n",i);
    while (--i) {
        putchar(*(b+i));
        printf("\n%s\n",&b[3]);
    }
}

Program
PROGRAM
i=7
m
gram
a
gram
r
gram
g
gram
o
gram
r
gram

输出结果

int main()
{
    static int x[] = {1,2,3};
    int s,i,*p;
    s = 1; p = x;
    for(i=0;i<3;i++)
        s*=*(p+i);
    printf("%d\n",s);
}

6

输出结果

int main()
{
    char a[] = "fprogram",b[] = "fortran";
    char *p,*q;
    p = a; q = b;
    while (*p&&*q) {
        if(*p==*q)
            printf("the two string are same:%c\n",*q);
        p++;q++;
    }
}

the two string are same:f
the two string are same:r

输出结果

int main()
{
    int a=2,*p,**pp;
    pp = &p;p=&a;
    a++;
    printf("%d,%d,%d\n",a,*p,**pp);
}

3,3,3

输出结果

void fun(char *w,int m)
{
    char s,*p1,*p2;
    p1 = w; p2 = w+m-1;
    while (p1<p2) {
        s = *p1++;
        *p1 = *p2--;
        *p2 = s;
    }
}
int main()
{
    static char a[] = "ABCDEFG";
    fun(a, strlen(a));
    puts(a);
}

AGAAGAG

输出结果

int try(int n)
{
    if(n>0)
        return (n*try(n-2));
    else
        return  1;;
}

int main()
{
    int x;x = try(5);
    printf("%d\n",x);
}

15

输出结果

int fib(int n)
{
    if(n>2)
        return fib(n-1)+fib(n-2);
    else
        return 2;
}

int main()
{
    printf("%d\n",fib(6));
}

16

输出结果

void bin(int x)
{
    if(x/2>0)
        bin(x/2);
    printf("%d",x%2);
}
int main()
{
    bin(12);
}

1100

输出结果

void fun(int n,int *s)
{
    int f1,f2;
    if(n==1||n==2)
        *s=1;
    else{
        fun(n-1, &f1);
        fun(n-2, &f2);
        *s = f1+f2;
    }       
}
int main()
{
    int x;
    fun(6,&x);
    printf("%d\n",x);
}

8

输出结果

void incr()
{
    int x=0;
    x = x+1;
    printf("%d",x);
}
int main()
{
    incr();
    incr();
    incr();
}

111

阅读程序

long fib(int g)
{
    switch (g) {
        case 0:return 0;
        case 1:
        case 2: return 1;
    }
    return fib(g-1)+fib(g-2);
}
int main()
{
    long k;
    k = fib(7);
    printf("k=%ld\n",k);
}

程序的功能是________
运行结果__________

程序递归实现斐波拉契数列，k为0时返回0，为1，2时返回1，大于2时为前两个fib的和
结果为 k=13

阅读程序

int sub(int n)
{
    int a;
    if(n==1)    return 1;
    a=n+sub(n-1);
    return a;
}
int main()
{
    int i=5;
    printf("%d\n",sub(i));
}

sub实现了1至n的累加求和
运行结果为 15

阅读程序

void fun(int a[])
{
    int i,j,k;
    for(i=0;i<4;i++)
        for(j=0;j<4-i;j++)
            if(a[j]>a[j+1]){
                k = a[j];
                a[j]=a[j+1];
                a[j+1]=k;
            }
}

函数的算法是

冒泡排序，数组最终由小到大排列

若A[4]={7，6，5，9}，执行后A[4]={____}

5,6,7,9

阅读程序

void fun(int a[])
{
    int i,j,k,p;
    for(i=0;i<4;i++){
        p=i;
        for(j=i;j<4;j++)
            if(a[j]>a[p])
                p=j;
        k=a[i];
        a[i]=a[p];
        a[p]=k;
    }
}

函数算法是

选择排序，最终结果由大到小

若A[4]={7，6，5，9}，执行后A[4]={____}

9，7，6，5

输出结果

int main()
{
    char a[]="123456789",*p;
    int i=0;p=a;
    while (*p) {
        if(i%2==0) *p='*';
        p++;
        i++;
    }
    puts(a);
}

  *2*4*6*8*

阅读程序

int s(char *s )
{
    char *p=s;
    while(*p)   p++;
    return p-s;
}

int main()
{
    char *ss = "abcdefg\0";
    int j;
    j = s(ss);
    printf("%d\n",j);
}

函数功能

求字符串的长度

运行结果

阅读程序

void fun(char *a,char b)
{
    while (*(a++)!='\0') ;
    while(*(a-1)<b) {
        *a=*(a-1);
        a--;
    }
    *(a--)=b;
    
}

int main()
{
    char s[]="97531",c;
    c=getchar();
    fun(s,c);
    puts(s);
}

输入6时，运行结果为

976531

阅读程序

void fun(char *s1,char *s2)
{
    int j;
    char *s = s1;
    for(;*s2!='\0';s2++){
        for(j=0,s1=s;*s1!='\0';s1++)
            if(*s1!=*s2){
                s[j]=*s1;j++;
            }
        s[j]='\0';
    }
}
int main()
{
    char a1[80],a2[80];
    fgets(a1, 80, stdin);
    fgets(a2, 80, stdin);
    fun(a1,a2);
    puts(a1);
}

输入ASDFGHJ<回车>
AFH<回车>时的运行结果

SDGGJ

输入 right? 时输出结果

int main()
{
    char c;
    while( (c=getchar()) != '?' )
        putchar(++c);
}

sjhiu

输入chian#,输出结果

int main()
{
    int v1=0,v2=0;
    char ch;
    while ((ch=getchar())!='#') {
        switch (ch) {
            case 'a':
            case 'h':
            default: v1++;
            case 'o':v2++;
        }
    }
    printf("%d,%d\n",v1,v2);
}

5,5
没有break语句，都会执行一遍

输出结果

int main()
{
    int i,j;
    for(i=0;i<4;i++){
        for(j=0;j<6;j++){
            if(i==0||j==0||i==3||j==5)
                printf("*");
            else
                printf(" ");
        }
        printf("\n");
    }
}

******
*    *
*    *
******

输出结果

int main()
{
    int i,j;
    for(i=4;i>=1;i--){
        for(j=1;j<5;j++)
            printf("#");
        for(j=1;j<=4-i;j++)
            printf("*");
        printf("\n");
    }
}

####
####*
####**
####***

输入 asdASD 输出结果

int main()
{
    char s[80],c='a';
    int j=0;
    scanf("%s",s);
    while (s[j]!='\0') {
        if(s[j]==c)
            s[j]-=32;
        else if(s[j]==c-32)
            s[j]+=32;
        j++;
    }
    puts(s);
}

AsdaSD

阅读程序

int main()
{
    int j,s=0;
    int a[10]={};
    for(j=0;j<10;j++){
        if(a[j]>0)
            s+=a[j];
    } 
    printf("s=%d\n",s);
}

程序功能

将数组a内大于0的数求和

若a[10]={10,1,-20,-203,-21,2,-2-2,11,21}，结果为

s=45

阅读程序

int main()
{
    int j,s=0;
    int a[10]={10,1,-20,-203,-21,2,-2-2,11,21}；
    for(j=0;j<10;j++){
        if(a[j]<0)
            s+=a[j];
    } 
    printf("s=%d\n",s);
}

程序功能

将数组a内小于0的数求和

若a[10]={10,1,-20,-203,-21,2,-2-2,11,21}，结果为

s=-248

阅读程序

int main()
{
    int x;
    scanf("%d",&x);
    if(x--<5)
        printf("%d\n",x);
    else
        printf("%d\n",x++);
}

4

输出结果

struct HAR{
    int x,y;struct HAR *p;
} h[2];
int main()
{
    h[0].x=1;h[0].y=2;
    h[1].x=3;h[1].y=4;
    h[0].p = &h[1];h[1].p=&h[0];
    printf("%d %d \n",(h[0].p)->x,(h[1].p)->y);
}

3 2

输出结果

int main()
{
    int a,b;
    for(a=1,b=1;a<=100;a++){
        if(b>=10)
            break;
        if(b%3==1){
            b+=3;break;
        }   
    }
    printf("a=%d\n",a);
}

1
执行一次直接break了

输出结果

int main()
{
   int i=10,j=0;
   do{
       j = j+i;i--;
   }while(i>2);
    printf("%d\n",j);
}

  (3+10)*8/2

输入 1298 输出结果

int main()
{
    int n1,n2;
    scanf("%d",&n2);
    while(n2!=0){
        n1 = n2 % 10;
        n2 = n2 / 10;
        printf("%d",n1);
    }
}

8921

输出最后一个值

int ff(int n)
{
    static int f = 1;
    f *= n;
    return f ;
}

int main()
{
    int i;
    for(i=1;i<=5;i++)
        printf("%d\n",ff(i));
}

120

  f变量是静态变量
  f的不会被重置为1，每改写一次就会是新的值

输出结果

int main()
{
    int x=10,y=20,t=0;
    if(x==y) t=x;x=y;y=t;
    printf("%d,%d\n",x,y);
}

20,0

  故意不打括号还写在一行
  很低级的骗术，误导if是三角交换

输出结果

int main()
{
    int x=15;
    while (x>10&&x<50) {
        x++;
        if(x/3){
            x++;break;
        }
        else continue;
    }
    printf("%d\n",x);
}

17

输入 Y?N 输出结果

int main()
{
    char c;
    while( (c=getchar())!='?')
        putchar(--c);
}

X

输出结果

void fun(int x,int y)
{
    x+=y;y=x-y;x-=y;
    printf("%d,%d,",x,y);
}

int main()
{
    int x=2,y=3;
    fun(x, y);
    printf("%d,%d\n",x,y);
}

3,2,2,3

  fun函数也就是我们常说的
  不申请新的空间交换两个变量的值

输出结果

#define N 10
#define s(x) x*x
#define f(x) (x*x)
int main()
{
    int i1,i2;
    i1=1000 / s(N);
    i2=1000 / f(N);
    printf("%d %d\n",i1,i2); 
}

1000 10

  宏定义其实是在预编译时将字符进行替换
  实际运行的是
   i1=1000 / 10 * 10;
   i2=1000 / (10 * 10);

输出结果

void swap(int *a,int *b)
{
    int *t;
    t = a; a = b; b = t;
}
int main()
{
    int x=3,y=5,*p=&x,*q=&y;
    swap(p,q);
    printf("%d %d\n",*p,*q);
}

3 5

a和b的指向确实变了，但是p和q的指向并不受影响

输出结果

typedef union student{
    char name[10];
    long sno; char sex;
    float score[4];
}STU;
int main()
{
    STU a[5];
    printf("%lu\n",sizeof(a));
}

80
STU是union结构，所有变量共享最大变量的内存，STU所占字节为16
a由5个STU构成，一共80个字节

64位编译器

char ：1个字节
char*(即指针变量): 8个字节
short int : 2个字节
int：  4个字节
unsigned int : 4个字节
float:  4个字节
double:   8个字节
long:   8个字节
long long:  8个字节
unsigned long:  8个字节

32位编译器

char ：1个字节
char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
short int : 2个字节
int：  4个字节
unsigned int : 4个字节
float:  4个字节
double:   8个字节
long:   4个字节
long long:  8个字节
unsigned long:  4个字节

输出结果

int main()
{
    int s,i;
    for(s=0,i=1;i<3;i++,s+=i);
    printf("%d\n",s);
}

5

输出结果

int main()
{
    char *p="abcdefgh",*r;
    long *q; q=(long *)p; 
    r = (char*)q;r++;
    printf("%s\n",r);
}

bcdefgh
应该是想考强制转化类型吧

输出结果

int main()
{
    char s[] = "abcdef";s[3]= '\0';
    printf("%s\n",s);
}

abc

输出结果

void sub(int *a,int n,int k)
{
    if(k<=n)
        sub(a, n/2, 2*k);
    *a += k;
}
int main()
{
    int x=0;sub(&x,8,1);
    printf("%d\n",x);
}

7

下列程序的功能是从键盘输入一个年份数据判断此年份是否为闰年。(注满足下面两个条件中的一个即为闰年一、400的倍数二、4的倍数但不是100的倍数)。

int main()
{
    int x,i;
    scanf("%d",&x);
    if(x%400==0)    i=1;
    else if(________)
        i=1;
    else 
        _________;
    if(i==1)
        printf("该年为闰年\n");
    if(i==0)
        printf("该年为平年\n");
}

x%4==0&&x%100!=0
i=0;

以下程序求1—10的奇数和。

int main()
{
    int x,s;
    s=0;
    for(x=1;x<=10;_____)
        _______;
    printf("奇数和为:%d\n",s);
}

x++
s+=(x%2!=0)?x:0

在5个数中找出最大的元素及位置。

#define size 5
int main()
{
    int a[size] = {4,6,3,9,23};
    int max,p,i;
    _____;
    p=0;
    for(i=1;i<size;i++)
        if(a[i]>max){
            max = a[i];
            _____;
        }
}

max = a[0]  从for循环的i=1可以看出少了个元素
p = i

以下程序用″比较计数″法对结构数组a按字段num进行降序排列。″比较计数″法的基本思想是: 通过另一字段con记录a中小于某一特定关键字的元素的个数。待算法结束, a[i].con就是a[i].num在a中的排序位置。本程序先读入N个整型数据存入数组a中, 然后根据以上办法排序。

#define N 8
struct c{
    int num;
    int con;
}a[16];
int main()
{
    int i,j;
    for(i=0;i<N;i++){
        scanf("%d",______);
        a[i].con = 0;
    }
    for(i=N-1;i>=1;i--){
        for(j=i-1;j>=0;j--){
            if(a[i].num<a[j].num)
            _______;
            else
                a[i].con++;
        }
    }
    for(i=0;i<N;i++)
        printf("%d,%d\n",a[i].num,a[i].con);
}

&a[i].num
a[j].con++

以下函数是对N个数用直接插入排序法进行由小到大排序。

#define N 10
void insertsort(int R[N+1])
{
    int i,j;
    for(i=2;i<=N;i++){
        R[0] = R[i];  //设置监视哨
        j = i-1;
        while (_____) {
            R[j+1] = R[j];
            _____;
        }
        R[j+1] = R[0];
    }
}

R[0]<R[j]
j--
可以发现传入的数组第一个位置是不能放置元素的

下面程序的功能是:输出100以内能被3整除且个位数为6的所有整数。

int main()
{
    int i,j;
    for(i=0;______;i++){
        j = i * 10 +6;
        if(______)    continue;
        printf("%d",j);
    }
}

i<10
j%3 != 0
很明显它不是直接将100个数算一遍，
而是先构造可能满足的数再验证

以下程序为先输入10个数据到数组a中再输入x然后在a数组中查找与x值相同的元素的所在位置。

int main()
{
    int a[11],x,i;
    printf("Enter 10 integers:\n");
    for(i=1;______;i++)   scanf("%d",a+i);
    printf("Enter x:");scanf("%d",&x);
    *a = x;i = 10;
    while (x!=*(a+i)) 
        ________;
    if(i>0) printf("%5d's position is: %4d\n",x,i);
    else    printf("%d Not benn found!\n",x);
}

i<=10
i--

用函数求x的绝对值

int abs(int a)
{
    int b;
    if(a>=0)
        b=a;
    else  _______;
    return b;
}
int main()
{
    int x,y;
    scanf("%d",&x);
    _______;
    printf("y=%d\n",y);
}

b=-a
y=abs(x)

本程序实现输入10个整数存入数组x中然后计算各元素的和并将和存入S中。

int main()
{
    int x[10],i,s;
    for(i=0;i<10;i++)
        scanf("%d",&x[i]);
    s=______;
    for(i=1;i<10;i++)
    __________;
    printf("%d",s);
}

s=a[0]
s+=a[i]

根据以下函数关系对输入的每个x值计算出相应的y值请在程序的横线上填空。

int main()
{
    int x,c,m;
    float y;
    scanf("%d",&x);
    if(x<0) c=-1;
    else c=________;
    switch (c) {
        case -1:y=0;break;
        case 0:y=x;break;
        case 1:y=10;break;
        case 2:
        case 3:_______;break;
        default:y=-2;
    }
    if(y!=-2)   printf("y=%f\n",y);
    else    printf("error!\n");
}

c=x/10
y=-0.5*x+20

输入两个正整数a和b,若a≥b时,求其积c并显示若a<b时,求其商c并显示.

int main()
{
    int a,b,c;
    scanf("%d,%d",&a,&b);
    if(___________){
        c=a*b;
        printf("%d*%d=%d\n",a,b,c);
    }
    else if(____________){
        c=b/a;
        printf("%d/%d=%d\n",a,b,c);
    }
    else 
        printf("输入的数据不全为正整数！");
}

a>=b
a<b

输入三位正整数,分解为各个位数之和,例如423分解为4+2+3.

int main()
{
    int n,c,c1,c2,c3;
    printf("Enter n=");
    scanf("%d",&n);
    c=0;c1=0;c2=0;c3=0;
    c1=_______;
    c2=(n-c1*100);
    c3=______;
    c = c1+c2+c3;
    printf("s=%d\n",c);
}

c1=n/100
c3=n-c1*100-c2*10;

mystrlen函数的功能是计算str所指字符串的长度,并作为函数值返回。请填空。

int mystrlen(char *str)
{
    int i;
    for(i=0;______!='\0';i++);
    return _______;
}

*(str+i)!='\0'  或者str[i]!='\0'
return i

以下程序的功能是:通过指针操作,找出三个整数中的最小值并输出。

int main()
{
    int *a,*b,*c,num,x,y,z;
    a=&x;b=&y;c=&z;
    printf("输入3个整数：");
    scanf("%d%d%d",a,b,c);
    printf("%d,%d,%d\n",*a,*b,*c);
    num=*a;
    if(*a>*b)   _______;
    if(num>*c)  _______;
    printf("输出最小整数:%d\n",num);
}

num=*b
num=*c

以下check函数的功能是对value中的值进行四舍五入计算,若计算后的值与ponse的值相等,则显示”WELL DONE!!”,否则显示计算后的值.请填空.

void check(int ponse,float value)
{
    int val;
    val = _______;
    printf("计算后的值:%d",val);
    if(_______)
        printf("\nWELL DONE!!\n");
    else  
        printf("\nSorry the correct answer is %d\n",val);
}

(int)((value*10 + 5)/10)
val == ponse

从键盘上输入一行字符(不多于40个以回车换行符作为输入结束标记),将其中的大写字母改为小写字母其它字符不变然后逆向输出。

int main()
{
    char a[40];int n=0;
    do{
        scanf("%c",&a[n]);
        if(______)    a[n]+=32;
        n++;
    }while(_____!='\n');
    n-=2;
    while (n>=0) {
        printf("%c",a[n--]);
    }
}

a[n]>='A'&& a[n]<='Z'
a[n-1]!='\n'

连续向数组输入成绩,并显示数组元素的值。当输入负数时停止接收数据。

int main()
{
    int n=0;
    int c[100];
    do{
        printf("enter num:\n");
        _______;
        printf("%d",c[n]);
        n++;
    }while(________);
}

scanf("%d",&c[n])
c[n-1]>0

下面程序的功能是在三个字符串中找出最小的字符串。

int main()
{
    char s[20],str[3][20];
    int i;
    for(i=0;i<3;i++)    scanf("%s",str[i]);
    strcpy(s,________ );
    if(strcmp(str[2], s)<0) strcpy(s, str[2]);
    printf("%s\n",_______);
}

strcpy(s, strcmp(str[0],str[1])<0?str[0]:str[1])
printf("%s\n",s)

以下函数的功能是删除字符串s中的所有数字字符。

void dele(char *s)
{
    int n=0,i;
    for(i=0;s[i];i++)
        if(_____)    
            s[n++]=s[i];
    s[n]=___;
}

s[i]<'0'||s[i]>'9'
s[n]='\0'

计算n!的值

int main()
{
    int i,s,n;
    printf("enter n:");
    scanf("%d",&n);
    ______;
    for(i=1;i<=n;i++)
        ______;
    printf("s=%d",s);
}

s=1
s*=i

c语言程序阅读题,笔记,c语言,c++,程序阅读题,基础入门文章来源地址https://www.toymoban.com/news/detail-797969.html

到了这里，关于【C语言】程序阅读题的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

【C语言】程序阅读题

程序阅读题

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2