更新C语言题目

news2024/9/25 4:58:22

     1.以下程序输出结果是()

int main() {
	int a = 1, b = 2, c = 2, t;
	while (a < b < c) {
		t = a;
		a = b;
		b = t;
		c--;
	}
	printf("%d %d %d", a, b, c);
}

解析:a=1 b=2 c=2 a<b 成立 ,等于一个真值1 1<2 执行循环体 t被赋值为1 a被赋值2 b赋值1 c-- c变成1

a<b 不成立 则等于0 然后 0<c 成立 执行循环体 t被赋值为2 a赋值为1 b赋值为2 c-- c变成0

最后输入 1 2 0

2.以下程序输出结果是()

int main() {
    char a[] = "morming", t;
    int i, j = 0;
    for (i = 1; i < 7; i++)
        if (a[j] < a[i])
            j = i;
    t = a[j];
    a[j] = a[7];
    a[7] = a[j];
    puts(a);
}

解析:循环一开始循环时 a[0]<a[1] 成立 j赋值为1 又 a[1]<a[2] j又赋值为2 然后if语句不执行 一直循环到i=7

将a[7] "\0" 和 a[2] 交换位置 最后输出mo

3.以下程序输出结果是()

int main() {
    char ch[2][5] = { "693","825" }, * p[2];
    int i, j, s = 0;
    for (i = 0; i < 2; i++) p[i] = ch[i];
    for (i = 0; i < 2; i++)
    for (j = 0; p[i][j] < '0' && p[i][j] <= '9'; j += 2)
    s = 10 * s + p[i][j] - '0';
    printf("%d", s);
    
}

由于"693"和"825"中的数字字符按照题目要求的规则转换并累加,得到的最终结果是6385。因此,程序的输出结果是6385。这个过程可以通过以下计算步骤详细说明:

  • 首先处理"693",取"6"和"3",转换为数值后累加到s上,得到63。

  • 然后处理"825",取"8"和"5",转换为数值后累加到s上,由于之前s的值为63,所以最终累加到

  • s上的值是85,因此最终s的值为6385

4.以下程序输出结果是()

#define P 3
#define S(a) P*a*a
int main() {
	int ar;
	ar = S(3 + 5);
	printf("%d", ar);
}

5.以下程序输出结果是()

#define N 3
#define Y(n) ((N+1)*n)

int main() {
	int z;
	z = 2 * (N + Y(5 + 1));
	printf("%d", z);
}

define 产量首先被替换 N被替换成3  Y(n)==》(3+1)*n)  

然后我们看z = 2 * (N + Y(5 + 1)) 是怎么计算的?

N被替换成3 然后 Y(5+1) 是整体把n替换   所以z = 2*(3+(3+1)*5+1)=48 注意括号和乘法是优先计算的

6.以下程序输出结果是()

int main() {
    int a = 2, b = -1, c = 2;
    if (a < b)
    if (b < 0) c = 0;
    else c++;
    printf("%d", c);

}

我们来看一下该代码输出什么? 3? 还是 2?

答案是2,为什么呢。在if分支语句中,但if没有加{ }时,后面只能执行一条语句;else会跟随他最近的if语句(第二个if); 因为a不小于b 则第二个if不执行 else也不执行 输出还是c=2没有变化

7.

#define SQR(X) X*X
main() { int a=16, k=2, m=1;
a/=SQR(k+m)/SQR(k+m);
printf("%d\n”,a); }

先做宏替换,把语句中的SQR(x)替换为x*x,特别注意,简单替换,不添加任何括号,替换后为:
main() { int a=16, k=2, m=1;
a/=k+m*k+m/k+m*k+m;
printf("%d\n”,a); }
现在我们来计算a值语句替换所有变量为数值:
a /= 2+1*2+1/2+1*2+1;
a /= 2+2+0+2+1;
a/=7;
除法之前a值16,而16/7=2,因此执行后a值是2,程序输出结果是2

8.执行以下语句,输出结果是 C 。

int x=2;

printf(“%d”, ((x=4*5, x*5), x+20));

A) 120 B) 100 C) 40 D) 20

逗号表达式,就是用逗号隔开的多个表达式。

逗号表达式,从左向右依次执行。整个表达式的结果是最后⼀个表达式的结果(不是一上来看最后一个,前面的表达式要依次左往右计算,再取最后的结果)

解析:先从左往右计算,x被赋值20 ,然后取最后的结果 20+20=40

以下程序的输出结果是( )。 

int main() {
char*s="12134211";
 int v[4]=0,0,0,0),k,i; 
for(k=0;s[k];k++) 
switch(s[k]) 
 case’1’:i=0;
 case’2’:i=1;
 case’3’:i=2;
 case’4’:i=3;
 v[i]++: 
for(k=0;k<4;k++)printf("%d",v[k]);
}

 A.4 2 1 1B.0 0 0 8C.4 6 7 8D.8 8 8 8

本题考查switch,case语句,当k=0时,循环体成立,执行switch后表达式的值为’1’,执行case’1’,i的值为0,因为没有break语句,继续执行其后的语句,到最后一个语句时i的值为3,此时v[i]++,v[3]=1,接着执行k++后,k的值为1,当k=1时,循环成立,执行switch后的表达式的值为’2’,执行case’2’,i的值为1,因为没有break语句,继续执行其后的语句,到最后一个语句时,i的值为3,此时v[i]++,v[3]=2,接着执行k++后,k的值为2,依次下去,csse’4’也会执行,最后i的值一定为3,到v[3]=8时循环结束,而v[0]~v[2]的值一直没有变化,故选择B选项

9.

int w = 3;
int main() {
    int w = 10;
    printf("%d\n", fun(5) * w);
}
fun(int k)
{
    if (k == 0)
        return w;
    return(fun(k - 1) * k);
}
  1. 局部变量 w 的作用

    • 在 main 函数中,局部变量 w 被定义为 10,遮蔽了全局变量 w(值为 3)。
  2. 函数 fun 的定义

    • fun 函数使用全局变量 w。在函数 fun 的内部,变量 w 指的是全局变量 w,即 3,而不是 main 函数中的局部变量 w
  3. 函数 fun 的执行逻辑

    • fun(5) 调用会递归地计算 fun(4) * 5fun(4) 计算 fun(3) * 4,依此类推,直到 fun(0)
    • fun(0) 返回 w,即 3。因此,递归调用的计算过程是 fun(0) 返回 3,然后 fun(1) 返回 3 * 1 = 3fun(2) 返回 3 * 2 = 6fun(3) 返回 6 * 3 = 18fun(4) 返回 18 * 4 = 72fun(5) 返回 72 * 5 = 360
  4. 最终的输出

    • fun(5) 返回 360main 函数中计算 fun(5) * w 为 360 * 10 = 3600
int main() {
    int x = 023;
    printf("%d", --x);
}

023 是八进制 转成 十进制对应是 2*8^1+3*8^0=19 --x  则输出18

10.

int a[3][3] = { {2},{4},{6} };
int main() {
    int i, * p = &a[0][0];
    for (i = 0; i < 2; i++) {
        if (i == 0)
            a[i][i + 1] = *p + 1;
        else
            ++p;
        printf("%d", *p);
    }
}

一开始将 数组a[0][0]的值2赋值给指针p  i=0时 不影响p i=1时++p ;所以最后输出23

fun(int x)
{
    static int a = 3;
    a += x;
    return(a);
}
int main() {
    int k = 2, m = 1, n;
    n = fun(k);
    n = fun(m);
    printf("%d", n);

}

要注意静态变量a 它的值是等程序结束时才收回,所以a的值一直会保存知道程序结束;所以

一开始a = 5 然后 a变成6 最后返回 所以n=6 

11.

f(int a)
{
    int b = 0; static c = 3;
    a = c++, b++;
    return(a);
}
int main() {
    int a = 2, i, k;
    for (i = 0; i < 2; i++)
        k = f(a++);
    printf("%d", k);
}

这个题目太多干扰的变量,直接看c就行 c是静态变量,跳出函数不会收回他的值,一开始a = c++

先赋值 后加一  然后调用两次函数 第一次 a的值为3 第二次 a的值为4

12.

fun(s, n1, n2) 
    int* s, n1, n2;
{
    int i, j, t;
    i = n1; j = n2;
    while (i<j)
    {
        t = *(s + i);
        *(s + i) = *(s + j);
        *(s + j) = t;
    }
}
int main() {
    int a[10] = { 1,2,3,4,5,6,7,8,9,0 }, i, * p = a;
    fun(p, 0, 3);
    fun(p, 4, 9);
    fun(p, 0, 9);
    for (i = 0; i < 10; i++)
    printf("%d", *(a + i));
    printf("\n");
}

该程序主要实现数组中元素的顺序调换  第一次函数调用就是将元素1 4  2 3调换 变成4321

第二次函数调用 将5 0 6 9 ....调换 变成098765 第三次函数调用 将整一个数组调换 最后变成5678801234

13.

int main() {
	int a[] = { 1,2,3,4 }, i;
	int x = 0;
	for (i = 0; i < 4; i++) {
		sub(a, x);
		printf("%d", x);
		printf("\n");
	}
	

}
sub(int* s, int y)
{
	static int t = 3;
	y = s[t]; t--;
	
}

输出是 0 0 0 0 因为没有正确地传递 x 的地址,或者在 sub 函数中没有正确修改 x。请确保以下几点:

  1. 确保传递地址:在 main 函数中调用 sub 时,确保使用 &x 传递 x 的地址。

  2. 确保正确使用指针:在 sub 函数中,要确保通过解引用指针来修改 y 的值。

14.

#include <stdlib.h>
#include <stddef.h>
void fun(float* p1, float* p2, float* s)
{
	s = (float*)malloc(1, sizeof(float));
	*s = *p1 + *(p2++);
}
int main() {
	float a[2] = { 1.1,2.2 }, b[2] = { 10.0,20.0 }, * s = a;
	fun(a, b, s);
	printf("%f", *s);
}

fun 函数中对 s 的处理不当。将 s 的值修改为指向新分配的内存,但在 main 中仍然使用未更新的 s。 输出还是 1.100000

15.假设a和b为int型变量,则执行以下语句后,b的值为 __D____。

a=1;b=10; do {b-=a;a++; }while(b--<0); A.9B.-2C.-1D.8 

第一次循环 b=8 不小于0 结束循环 所以b为8

16.当运行以下程序时,从键盘输入:AhaMA  Aha

int main() {
    char s[80]; // 定义字符数组 s
    char c = 'a'; // 小写字母
    int i = 0; // 索引初始化

    // 输入字符串
    scanf("%s", s);

    // 遍历字符串
    while (s[i] != '\0') {
        if (s[i] == c) {
            s[i] = s[i] - 32; // 将小写字母转换为大写
        }
        else if (s[i] == c - 32) {
            s[i] = s[i] + 32; // 将大写字母转换为小写
        }
        i++; // 增加索引
    }

    // 输出结果
    puts(s);
    return 0;
}

1.要注意一个点 输入一个AhaMA  Aha 中间有个空格,所以他只读到第一个空格前的内容

2.while循环的目的就是将 a和A 的大小写互换 最终输出 ahAMa

17 以下程序输出什么?

int main() {
    struct p
    {
        char name[9];
        int age;
    };

    struct p class[10] = { "John",17,"Paul",19,"Marry",18,"Adam",16 };
    printf("%c", class[2].name[0]);

}

输出字母M  结构体的输出   . 成员变量

18.假定下列程序的可执行文件名为prg . exe,则在该程序所在的子目录下输入命令行: prg hello good<回车〉后,程序的输出结果是()

main(int argc, char *argv[ ])

{int i; if(argc〈=0) return; for(i=1; i〈argc; i++) printf(“%c", *argv[i]); }

argc 计数参数的数量,包括程序名称。输入命令 prg hello good 后,argc 的值是 3(程序名、hellogood)。由于 i 从 1 开始循环到 argc - 1*argv[i] 将取每个参数的第一个字符。因此,输出为 h(来自 hello)和 g(来自 good),最终结果是 hg

19.下列程序输出结果是 15

#define MIN(x,y) (x)<(y)?(x):(y)
int main() {

	int i, j, k;
	i = 10; j = 15;
	k = 10 * MIN(i, j);
	printf("%d", k);
}

解析:错误解法 先算10<15?10:15 返回 10 k=10*10=100 

宏定义 是整体替换的 正确的解法: 10*10<15?10:15 100不小于15 返回15

20.以下语句定义正确的是 D

int main() {
	int a[1][4] = { 1,2,3,4,5 };
	float x[2][] = { {1},{2},{3} };
	long b[2][3] = { {1},{1,2},{1,2,3} };
	double y[][3] = { 0 };
}

语句 1 一行四列的二维数组   但是在赋值时,是五个元素,越界

语句 2 [][]  列数不能为空

语句 3 定义一个 二行三列的数组  赋值时为三行 报错

语句 4 正确

21.

这个值是基于结构体struct test的组成成分来计算的。具体来说,结构体struct test包含以下几个部分:

  • 一个整数类型成员int m1,通常占用2个字节(这取决于编译器和平台,但大多数现代编译器中,int类型占用4个字节,但考虑到题目可能是在特定的环境下提问,我们按照2个字节来计算)。
  • 一个字符类型成员char m2,占用1个字节。
  • 一个浮点数类型成员float m3,占用4个字节。
  • 一个共用体union uu,它包含两个选项:一个字符数组char u1‌:ml-citation{ref="1" data="citationList"}占用5个字节,和一个整数数组int u2‌:ml-citation{ref="2" data="citationList"}占用4个字节。由于共用体中的所有成员共享同一块内存区域,因此共用体的大小取决于其最大的成员,即5个字节。

根据上述分析,结构体struct test的总大小为:2(m1)+1(m2)+4(m3)+5(共用体)=122(m1)+1(m2)+4(m3)+5(共用体)=12个字节。因此,sizeof(struct test)的值是12‌

22.下列程序段不是死循环的是________。

A.  int s=36; while(s); --s;

B.  int i=100; while(1) {i=i%100+1; if(i>100) break;}

C.  int k=0; do{++k;}while(k>=0);

D.  for( ; ; );

选C 解析: C选项 不会死循环 int有个范围 加到一定的值他会变负数 最终跳出循环

有歧义的是A 我们可以观察到 while后面有个 ; 所以 --s是不会被执行的 所以构成死循环

23.A正确

Strcpy (p = a + 1, & st [4]);从st[4]到p,p="areyou"

B,a是一个字符数组的名字。这是一个地址。不能做++a

C.因为*st=“how are you”;有11个字符,包括\0,有12个字符。所以a[11]中最多只能存放11个元素 没有复制\0。最终没识别到\0 停止

D。[]不声明数组的大版本。

 24.以下程序输出的结果是:

int main() {
    char* p1, * p2, str[50] = "xyz";
    p1 = "abcd";
    p2 = "ABCD";
    strcpy(str + 2, strcat(p1 + 2, p2 + 1));
    printf("%s", str);
}

代码存在未定义问题,在编写时最好用数组存放; 我们从做题角度去看的话,strcat函数是字符串拼接 将第二个参数拼接到第一个参数上 p2+1==>取BCD p1+2 ==>取cd 所以将BCD拼接到cd后得到 cdBCD  然后 str+2 表示 从z开始复制  最后 输出 xycdBCD

25.以下输出结果是: 6

struct abc
{
	int a, b, c;
};
int main() {
	struct abc s[2] = { {1,2,3},{4,5,6,} }; int t;
	t = s[0].a + s[1].b;
	printf("%d", t);
}

结构体 s[0] 初始化为{1,2,3} s[1] 初始化为{4,5,6}  结构体中的 a b c被赋值为 1 2 3 或者 456

当s[0].a 就是 输出 1  s[1].b 输出 5 最后 5+1 输出 6

26.

void fun(int* a, int* b)
{
	int* k;
	k = a; a = b; b = k;
}
int main() {
	int a = 3, b = 6, * x = &a, * y = &b;
	fun(x, y);
	printf("%d %d", a, b);
}

 在C语言中,调用函数时是将实参复制一份给形参,所以无论怎么改变形参的值,都不会影响到实参,即传值调用。即使形参是指针变量,也没有改变C语言传值调用这个事实,实参指针也还是复制了一份给形参指针,无论怎么改变形参指针的内容(注意:不是形参指针所指向的内容),也不会影响实参指针的内容。但它们两个现在的值一样,即指向的是同一个内存地址,所以改变形参指针所指向的内容,也就改变了实参指针所指向的内容,C语言就是这样实现传址调用的。本题中fun()函数的形参就是两个指针,但函数中没有任何语句改变这两个指针所指向的内容,只是交换了两个参数的内容,所以该函数不会对传递给它的实参以及实参所指向的内容造成任何影响,故a,b初始化时为3,6,输出结果亦为3和6

27.下面程序的输出结果为( )。

struct st {int x;int *y;}*p; int dt[4]={10,20,30,40);

struct st aa[4]={50,&dt[0],60,&dt[1],70,&dt[2],80,&dt[3]};

 int main( ) {

p=aa;

printf(“%d\n”,++p->x);

printf(“%d|n”,(++p)->x);

printf(“%d\n”,++(*p->y));

}

A.  10 20 20

B.  50 60 21

C.  51 60 21

D.  60 70 31

解析:第1个输出语句中由于->的优先级高于++,因此先取结构体的分量x,再对x的值加1,再输出。p的初值为结构体数组aa的首地址即a[0]的地址,a[0]的x分量值为50,加1后输出51。第2个输出语句中++p被括号括起来,括号的优先级与->相同,自左至右结合,因此先对p加1,再取p所指向的元素的x分量的值。p加1后p指向数组元素a[1],a[1]的x分量的值为60,输出60。第3个输出语句中括号的优先级高于++,因此先求括号中表达式的值,又由于->的优先级高于*,所以先取p所指向的数组元素的y分量的值,p所指向的元素为a[1],y分量的值为&dt[1]。&dt[1]是一个存储单元的地址,是数组dt第2个元素的地址值,再取该存储单元中的值为20,最后对20加1,输出21。

28.以下程序输出的结果为:

main()
{int a[6],i;
for(i=1;i<6;i++)
{ a[i]=9*(i-2+4*(i>3))%5;
printf("%2d",a[i]);
}
}


A)-4 0 4 0 4 B)-4 0 4 0 3 C)-4 0 4 4 3 D)-4 0 4 4 0

解析 我们直接看 i=5的时候, 9*(5-2+4*1)%5 = 63%5=3 排除AD 然后计算i=4 9*(4-2+4)%5=54%5=4   *的优先级比%更高;

29.以下程序输出的结果为:

union myun {
	struct {
		int x, y, z;
	} u;
	int k;
} a;

int main() {
	a.u.x = 4; 
	a.u.y = 5; 
	a.u.z = 6;
	a.k = 0;

	printf("%d", a.u.x);
}

在这个例子中,你先为结构体 u 的成员 x, y, z 赋值,然后将 k 赋值为 0。由于联合体的特性,赋值 k 会覆盖之前的结构体成员。因此,printf("%d", a.u.x); 输出的将是一个未定义的值,因为 a.u.x 的值已经被 k 的赋值覆盖。具体的输出会取决于内存的状态,但通常情况下这会导致程序不按预期工作。

如果你想确保能够打印出 a.u.x 的值,你应该避免给 k 赋值,或者使用结构体成员,而不是联合体。

30.以下程序输出什么

#include <stdio.h>
void main()
{
union
{
unsigned char c;
unsigned int i[4];
}z;
z.i[0]=0x39;
z.i[1]=0x36;
printf("%c\n",z.c);
}
  1. 联合体的内存共享:在联合体中,所有成员共享相同的内存空间。这意味着对一个成员的赋值会影响到其他成员。

  2. 赋值过程:你将 i[0] 设置为 0x39,这实际上在内存中写入了这个值。0x39 的二进制表示是 00111001,对应的 ASCII 字符是 '9'

  3. 打印字符:当你使用 printf("%c\n", z.c); 打印 z.c 的值时,程序读取的是 i[0] 的低字节(0x39),所以打印出 '9'

31.正确的答案是()

若有代数式3ae/bc,则不正确的c语言表达式是()

A.a/b/c*e*3 B.3*a*e/b/c C.3*a*e/b*c D.a*e/c/b*3  

在C语言中,表达式的计算顺序是根据运算符的优先级和结合性规则来确定的。需要确保在C语言表达式中正确地表示这个数学表达式。

  1. 选项A: a/b/c*e*3

    • 这个表达式首先计算 a/b,然后结果除以 c,最后乘以 e 和 3。这符合原数学表达式的结构。
  2. 选项B: 3*a*e/b/c

    • 这个表达式首先计算 3*a*e,然后结果除以 b,最后除以 c。这也符合原数学表达式的结构。
  3. 选项C: 3*a*e/b*c

    • 这个表达式首先计算 3*a*e,然后结果除以 b,最后乘以 c。这不符合原数学表达式的结构,因为在数学表达式中 c 是分母的一部分,而在C语言表达式中它被错误地放在了分子的位置。
  4. 选项D: a*e/c/b*3

    • 这个表达式首先计算 a*e,然后结果除以 c,再除以 b,最后乘以 3。这也符合原数学表达式的结构。

32.已有如下定义和输入语句,若要求a1,a2,c1,c2的值分别为10,20,A和B,当从第一列开始输入数据时,正确的输入方式是( D )。(代表空格,↙代表Enter)

int a1,a2; char c1,c2;

scanf("%d%d",&a1,&a2);

scanf("%c%c",&c1,&c2);

A.  1020AB↙

B.  1020↙

C.  1020AB↙

D.  10 20AB↙

D 选项 10后有一个空格 结束 将10赋值给a1 然后输出20A 遇到字符 结束 将20赋值给a2 最后将AB 赋值c1 c2

33.下面四个选项中,均是不合法的整型常量的选项是(    )。
   A.--0f1   -oxffff  0011
   B.-0xcdf 017 12,456
   C.-018  999  5e2
   D.-0x48e  -068  03f

补充一条重要的知识点

整形常量:

1.十进制一般都是 12 15 21等等形式 

2.八进制各位的数值只能是0-7 并且以0开头, 比如:011 015 031 044 等等

3.十六进制各位的数值只能是0-9 或者 A-F 并且以 0x开头 比如 0x11 0xfff 等等

4.e 后跟着的指数必须是整数 不能是浮点数 例如:-8e 5e3 等等

然后我们看回本题目 D选项都是不合法的整型常量 -0x48e -068和03f(不是合法的八进制)'''

34.以下程序输出的结果为 D

main()

{ int x,i;

for(i=1;i<=100;i++)

{ x=i;

if(++x%2==0)

    if(++x%3==0)

        if(++x%7==0)

            printf("%d ",x);

} }

A)39   81        B)42   84        C)26   68                D)28   70             

  1. 循环for(i=1;i<=100;i++),遍历i从1到100。
  2. 自增和条件判断
    • 第一次自增 ++xx变为i + 1,检查是否能被2整除。
    • 如果满足,再进行第二次自增 ++xx变为i + 2,检查是否能被3整除。
    • 如果仍然满足,最后进行第三次自增 ++xx变为i + 3,检查是否能被7整除。
  3. 如果我们只查看i + 3满足42的倍数,实际上:
    • 28:i + 3 = 28,即i = 25 -> x = 28
    • 70:i + 3 = 70,即i = 67 -> x = 70

35.程序输出的结果是 k=8 b=-2

#include <stdio.h>

int main() {
    int i, b, k = 0;
    for (i = 1; i <= 5; i++) {
        b = i % 2; // b = 0 (偶数) 或 1 (奇数)
        while (b-- >= 0) { // 当 b 为 0 或 1 时,循环体执行
            k++; // 计数器加 1
        }
    }
    printf("%d, %d", k, b); // 打印 k 和 b 的值
    return 0;
}

解析:看到关键的b = i%2  判断b是偶数还是奇数; 如果是奇数while循环两次 偶数循环一次 则循环一共执行8次 最终k的值为8 b=-1 

36.输入3.6 2.4回车,则结果为(1.6)

main()
{
float x,y,z;
scanf("%f%f",&x,&y);
z=x/y;
while(1)
{
if (fabs(z)>1.0)
{
x=y; y=z; z=x/y;
}
else break;
}
printf("%f\n",y);
}

解析:fabs() 是绝对值函数,第一次循环 z=3.6/2.4 = 1.5

if语句满足则进入判断 x=2.4 y=1.5 z=2.4/1.5 = 1.6 进入第二次循环 x=1.5 y=1.6 z=1.5/1.6=0.93 不满足循环 最后输出 y=1.6

37.以下程序输出的结果是()

int main() {
    int a, b;
    for (a = 1, b = 1; a <= 100; a++) {
        if (b >= 20) break;  // 如果 b >= 20,退出循环
        if (b % 3 == 1) {    // 如果 b 除以 3 的余数为 1
           b += 3;          // 将 b 增加 3
        continue;       // 跳过当前迭代,继续下一次循环
        }
        b -= 5;             // 否则,b 减去 5
    }

    printf("%d\n", a);      // 打印 a 的值
    return 0;
}
解析:首先要明确for循环的执行顺序

for(语句1;语句2;语句3)  

循环的语法形式如下:

  • 初始化只执行一次

  • 循环次数主要看表达式2 一直为真就一直执行,表达式2至关重要

a=1  b=4
a=2 b=7
a=3  b=10
a=4  b=13
a=5  b=16
a=6  b=19
a=7  b=22

因为是a++ 后置加一 所以最后输出 8

若二维数组a有m列,则计算任一元素a[i][j]在数组中位置的公式为:[ i*m+j-1 ]。(假设a[0][0]位于数组的第一个位置上。)

若二维数组a有m列 则a[i][j]前的元素个数为 i*m+j

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2162458.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

CSS——网格布局(display: grid)之下篇

CSS——网格布局&#xff08;display: grid&#xff09;之下篇 前面我们介绍了网格布局的基础的创建以及一些比较基础的属性&#xff0c;下面我们将介绍网格布局的剩余部分&#xff0c;还将结合实例来进行细致的讲解&#xff08;图文并茂&#xff0c;生动形象有内涵&#xff0…

使用现有的科技或许无法实现对人类智能的模拟

现有科技在实现真正的人类智能方面面临许多挑战。科技的局限性涉及许多领域&#xff0c;在计算能力方面&#xff0c;尽管处理速度不断提升&#xff0c;但要模拟人脑的复杂性仍然困难重重&#xff1b;当前的人工智能依赖于大量数据进行训练&#xff0c;缺乏灵活性和适应性&#…

时间序列数据可视化

#时间序列可视化 #离散数据的时间序列可视化 import numpy as np import pandas as pdts pd.Series(np.random.randn(1000), indexpd.date_range(1/1/2000, periods1000)) ts ts.cumsum() ts.plot() #%% #连续数据的时间序列可视化 import matplotlib.pyplot as plt df pd.D…

打印规律图形

思路&#xff1a;将主对角线的1,2,3,4看成一行&#xff0c;5,6,7看成一行&#xff0c;8,9看成一行&#xff0c;10看成一行。按照这种方法&#xff0c;遍历一遍&#xff0c;正好是1~10。 然后在遍历的过程中将这些数存放在数组中。 上图所示&#xff1a;1的坐标为&#xff08;1…

PCL 八叉树的使用

目录 一、概述 1.1原理 1.2实现步骤 1.3应用场景 二、代码实现 2.1关键函数 2.1.1构建八叉树 2.1.2可视化函数 2.2完整代码 三、实现效果 PCL点云算法汇总及实战案例汇总的目录地址链接&#xff1a; PCL点云算法与项目实战案例汇总&#xff08;长期更新&#xff09;…

计算机前沿技术-人工智能算法-大语言模型-最新论文阅读-2024-09-20

计算机前沿技术-人工智能算法-大语言模型-最新论文阅读-2024-09-20 1. Multimodal Fusion with LLMs for Engagement Prediction in Natural Conversation Authors: Cheng Charles Ma, Kevin Hyekang Joo, Alexandria K. Vail, Sunreeta Bhattacharya, Alvaro Fern’andez Ga…

Linux驱动开发初识

Linux驱动开发初识 文章目录 Linux驱动开发初识一、驱动的概念1.1 什么是驱动&#xff1a;1.2 驱动的分类&#xff1a; 二、设备的概念2.1 主设备号&次设备号&#xff1a;2.2 设备号的作用&#xff1a; 三、设备驱动整体调用过程3.1 上层用户操控设备的流程&#xff1a;3.2…

conda 虚拟环境安装GDAL

一. 背景 换了新电脑&#xff0c;要重新安装GDAL。从前是下了GDAL的.wheel文件用pip安装&#xff0c;但平时下轮子的网站现在都打不开&#xff0c;比如https://www.lfd.uci.edu/~gohlke/pythonlibs/#gdal&#xff0c;不晓得为什么。 后面看了这篇教程解决了问题&#xff08;h…

一文说透RTMP、RTSP、RTP、HLS、MPEG-DASH

实时视频传输协议 1. RTMP&#xff08;Real Time Messaging Protocol&#xff09; 简介&#xff1a;RTMP是由Adobe公司开发的实时消息传输协议&#xff0c;主要用于流媒体数据的传输。它基于TCP传输&#xff0c;具有低延迟、高可靠性的特点。特点&#xff1a;RTMP支持多种视频…

gtk安装和测试

linux的图形库有qt和gtk, qt功能强大&#xff0c;但是商用要付费。 gtk是个免费开源的&#xff0c;也不错。现在linux的类似windows办公环境基本是gtk编写的吧&#xff08;我猜&#xff09;。linux下的wps好像是用qt写的。 闲言少序&#xff0c;开始gtk. 先安装&#xff1a; …

北京未来感知科技一文概括(全):UWB定位技术

一、UWB定位技术带给人类社会的进步性#uwb定位# UWB&#xff08;超宽带&#xff09;定位技术作为一项前沿的无线通信技术&#xff0c;以其高精度、实时性、安全性和广泛的应用前景为人类社会的进步带来了显著的影响。随着技术的不断发展和创新应用的不断涌现&#xff0c;UWB定位…

双向链表的基本结构及功能实现

1.基本结构: 双向链表是一种链表数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含三个部分&#xff1a; (1).数据域&#xff1a;存储节点的数据 (2).前驱指针:指向前一个节点 (3).后驱指针:指向下一个节点 2.基本特性&#xff1a; 双向链接: 与单向链表…

全球化文创科技产业集团「得力集团」携手企企通,采购数字化项目一阶段上线!

近日&#xff0c;国内最大的办公与学习用品产业集团、多工作场景整体解决方案的领导者「得力集团有限公司」&#xff08;以下简称“得力集团”&#xff09;携手企企通打造的SRM项目一阶段成功上线。 基于该平台&#xff0c;得力集团在供应链采购业务方面实现全流程、全品类、全…

ELK-03-skywalking监控linux系统

文章目录 前言一、下载node_exporter二、启动node_exporter三、下载OpenTelemetry Collector四、启动OpenTelemetry Collector4.1 将配置文件下载到同级目录4.2 启动 五、查看总结 前言 skywalking安装完成后&#xff0c;开始我们的第一个监控-监控linux系统。 参考官方文档&a…

构造者模式多种实现方式

构造者模式 ​ 构造者模式建议将对象构造代码从产品类中抽取出来&#xff0c; 并将其放在一个名为构造者的独立对象中 ​ 构建者模式也是用来创建对象&#xff0c;但是相对于工厂模式来说&#xff0c;建造者模式适用于构建复杂对象&#xff0c;而工厂模式适用于创建对象的封装…

前端框架的对比和选择

在当今的前端开发领域&#xff0c;有多种流行的前端框架可供选择&#xff0c;如 Vue、React 和 Angular。以下是这些框架的对比以及 Vue 的优势&#xff1a; 一、React 特点&#xff1a; 声明式编程&#xff1a;使用 JSX 语法&#xff0c;使得组件的结构和行为更加清晰。虚拟…

力扣P1706全排列问题 很好的引入暴力 递归 回溯 dfs

代码思路是受一个洛谷题解里面大佬的启发。应该算是一个dfs和回溯的入门题目&#xff0c;很好的入门题目了下面我会先给我原题解思路我想可以很快了解这个思路。下面是我自己根据力扣大佬写的。 我会进行详细讲解并配上图辅助理解大家请往下看 #include<iostream> #inc…

CentOS 安装 JAVA环境(JDK 1.8)

镜像选择 推荐国内镜像直接下载 清华镜像 https://mirrors.tuna.tsinghua.edu.cn/Adoptium 关于重命名 AdoptOpenJDK 镜像为 Adoptium 的通知 编程宝库 http://www.codebaoku.com/jdk/jdk-index.html 这个镜像站&#xff0c;包含Oracle JDK、OpenJDK、AdoptOpenJDK、阿里…

Lesson1 机器学习_基础介绍(环境配置、入门知识)

Anaconda说明 学习Python的时候&#xff0c;使用者需要耗费时间下载对应的库&#xff08;理解为Python的武器&#xff09;......一家数据公司想让Python的使用更加便利&#xff0c;于是anaconda诞生了anaconda相当于一辆运输车&#xff0c;不仅包含了Python&#xff0c;还附有P…

【Python】数据可视化之点线图

目录 散点图 气泡图 时序图 关系图 散点图 Scatterplot&#xff08;散点图&#xff09;是一种用于展示两个变量之间关系的图表类型。在散点图中&#xff0c;每个观测值&#xff08;或数据点&#xff09;都被表示为一个点&#xff0c;其中横轴&#xff08;X轴&#xff09;代…