数组练习

（1）3有以下程序

main（）

{

int p[8]={11,12,13,14,15,16,17,18}，i=0,j=0;

while（i++<7） if（p[i]%2） j+=p[i];

printf（"%d\n",j）;

}

13+15+17=45;

程序运行后的输出结果是_B____。

A）42 B）45 C）56 D）60

（2）3有以下程序

main（）

{

int p[8]={11,12,13,14,15,16,17,18}，i=1,j=1;

while（i++<7） if（p[i]%2） j+=p[i];

printf（"%d\n",j）;

}

13+15+17+1=46;

程序运行后的输出结果是__46___。

A）42 B）46 C）56 D）60

（3）3有以下程序

main（）

{

int p[8]={11,12,13,14,15,16,17,18}，i=0,j=1;

while（i++<7） if（p[i]%2） j+=p[i];

printf（"%d\n",j）;

}

程序运行后的输出结果是___46__。

A）42 B）46 C）56 D）60

（4）3有以下程序

main（）

{

int p[8]={11,12,13,14,15,16,17,18}，i=1,j=0;

while（i++<7） if（p[i]%2） j+=p[i];

printf（"%d\n",j）;

}

程序运行后的输出结果是__45___。

A）42 B）45 C）56 D）60

（5）以下叙述中错误的是__C___。

A）对于double类型数组，不可以直接用数组名对数组进行整体输入或输出

B）数组名代表的是数组所占存储区的首地址，其值不可改变

C）当程序执行中，数组元素的下标超出所定义的下标范围时，系统将给出“下标越界”的出错信息

D）可以通过赋初值的方式确定数组元素的个数

（6）3有以下程序

main（）

{ int p[7]={11,13,14,15,16,17,18},i=0,k=0;

while（i<7&&p[i]%2）{k=k+p[i];i++;}

printf（"%d\n",k）;

}

11+13 ,当执行了p[2]=14.不满足条件,就终止循环了

执行后输出结果是___24__。

A）58 B）56 C）45 D）24

（7）3有以下程序

main（）

{ int p[7]={11,13,14,15,16,17,18},i=1,k=1;

while（i<7&&p[i]%2）

{k=k+p[i];i++;}

printf（"%d\n",k）;

}

13 + 1

执行后输出结果是__14___。

A）58 B）56 C）45 D）14

（8）1假定int类型变量占用两个字节，其有定义：int x[10]={0,2,4};，则数组x在内存中所占字节数是__20___。

A）3 B）6 C）10 D）20

（9）1假定float类型变量占用四个字节，其有定义：float x[10]={0.5,2.5,2.4};，则数组x在内存中所占字节数是___40__。

A）3 B）6 C）10 D）40

（10）1假定int类型变量占用两个字节，其有定义：int x[5]={0,2,4};，则数组x在内存中所占字节数是____10_。

A）3 B）6 C）10 D）20

（13）1以下程序的输出结果是_____。

main（）

{ int i, a[10];

for（i=9;i>=0;i--） a[i]=10-i;

printf（“%d%d%d”,a[1],a[3],a[5]）;

}

A）258 B）741 C）852 D）975

（14）1以下程序的输出结果是_____。

main（）

{ int i, a[10];（16）2当调用函数时，实参是一个数组名，则向函数传送的是___B__。

A）数组的长度 B）数组的首地址

C）数组每一个元素的地址 D）数组每个元素中的值

（19）2若有以下调用语句,则不正确的fun函数的首部是_D___。

A）void fun（int m, int x[]）

B）void fun（int s, int h[41]）

C）void fun（int p, int *s）

D）void fun（int n, int a）

main（）

{ …

int a[50],n;

…

fun（n, &a[9]）;

…

}

（20）3以下程序的输出结果是B_____。

//顺序执行

main（）

{ int i,k,a[10],p[3]:

k=5;

for（i=0;i<10;i++） a[i]=i;

for（i=0;i<3;i++） p[i]=a[i*（i+1）];

for（i=0;i<3;i++） k+=p[i]*2;

printf（"%d\n",k）;

}

A）20 B）21 C）22 D）23

21.设变量定义为“int s[ ]="hello\nworld\n";”，则数组s中有___B___个元素。

　　A、12 B、13 C、14 D、15

22.设变量定义为“int a[4];”，则表达式_D_____不符合C语言语法。(为何)

　　A、*a B、a[0] C、a D、a++

（25）有以下程序

//编程

#include <stdio.h>

main()

{

int s[12]={1,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i;

for(i=0;i<12;i++)

c[s[i]]++;

for(i=1;i<5;i++)printf("%d",c[i]);

printf("\n");

}

程序的运行结果是（ C ）。

A）1 2 3 4 B）2 3 4 4

C）4 3 3 2 D）1 1 2 3

（26）若有定义语句：int m[]={5,4,3,2,1},i=4;，则下面对m数组元素的引用中错误的是

（ C）。

A）m[--i] B）m[2*2] C）m[m[0]] D）m[m[i]]

(27)以下能正确定义一维数组的选项是(C )

　　A)int a[5]={0,1,2,3,4,5};

　　B)char a[]={0,1,2,3,4,5};

　　C)char a={'A','B','C'};

　　D)int a[5]="0123";

1.有m个人围成一圈，开始报数，报道n，退出，问最后剩下的是几号。（从1号开始）

比如：

输入:5 3

输出：

4

输入: 6 2

输出:

5

2. 输入两个数，第一个数决定一个nXn的矩阵，第二个数决定从1开始赋值，赋值的上限

比如：

输入:5 18

输出：

1 2 3 4 5

16 17 18 0 6

15 0 0 0 7

14 0 0 0 8

13 12 11 10 9

输入: 4 12

输出:

1 2 3 4

12 0 0 5

11 0 0 6

10 9 8 7

4..输入10个数，找出出现次数最多的数（如果多个并列，则按数字出现顺序分别输出）

比如：

输入：1 2 2 3 4 5 6 7 8 9

输出：2

数据结构:定义一个整型数组 int count[10]存储每个元素的个数,开始时每个元素个数初始化为1

算法:

(1)利用双层循环,每一个元素都与后面一个元素比较,如果两者相同,则该元素次数+1,

(2)以上的算法中两个相同的元素的次数是一样的,优化如下,比较两个元素的时候,如果两者相等,则该元素次数+1,后面的元素次数设置为0,比较的时候再判断这个元素是否已经比较

伪代码:

定义数组保存每个元素次数

使用双层循环遍历数组

如果当前元素后后面元素相等,并且后面的元素次数不为0

当前元素次数+1,后面的元素次数设置为0

从保存每个元素次数的数组中查找最大的值

5.魔方阵是一个古老的智力问题，它要求在一个m*m的矩阵中填入1～m^2的数字（m为奇数），使得每一行、每一列、每条对角线的累加和都相等。请编程实现输入m，输出m*m的魔方阵出来。

比如：

输入：3

输出：

6 1 8

7 5 3

2 9 4

//(1)将1放在第一行中间一列；

//(2)从2开始直到n×n止各数依次按下列规则存放；每一个数存放的行比前一个数的行数减1，列数加1/减1（例如上面的三阶魔方阵，5在4的上一行后一列）；

//(3)如果上一个数的行数为1，则下一个数的行数为n(指最下一行);例如1在第一行，则2应放在最下一行，列数同样加1；

//(4)当上一个数的列数为n时，下一个数的列数应为1，行数减去1。例如2在第3行最后一列，则3应放在第二行第一列；

//(5)如果按上面规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。例如按上面的规定，4应该放在第1行第2列，但该位置已经被占据，所以4就放在3的下面；

1. 1.给定某个字符数组,统计数组中所有英文字符的个数,比如“123fdd”中有3个。
2. 2.给定某个字符数组,统计数组中所有英文字符和阿拉伯数字的个数,比如“123fdd”
   中有英文字符有 3 个,数字3个。
3. 3.给定某个拥有5个元素的字符数组,数组的成员都有阿拉伯字符构成,试着将该数
   组转换成一个整数,比如字符数组的内容是:{‘1’,’2’,’3’,’3’,’2’}则将被转换成12332。
4. 4.给定一个完全由英文字符构成的数组,将数组中的小写字母转换成大写字母,大写
   字母转换成小写字母并输出。例如“abcGGG”转化为“ABCggg”。
5. 5.给定一个完全由英文字符构成的数组,将数组中下标为偶数的字符都转换为大写(如
   果原来是大写则不变)。
6. 6.给一个完全由英文字符构成的字符数组加密,加密原则如下,除了字符‘Z’和‘z’
   之外,每个字符变成 ASCII 码值比它大 1 的字符,也就是‘A’变成‘B’。‘Z’或
   者‘z’转化为‘A’或者‘a’。
7. ###7.计算某个由英文、数字以及标点符号构成的数组的总宽度,其中英文字符的宽度为
   1cm,数字宽度为0.5cm、标点符号宽度为0.8cm。

1. 8.接上题,如果规定行的宽度为10cm,将某个字符长度超过50的字符串截断,恰好 使10cm宽的行能容纳。输出这个被截断的子数组。
2. 9.给定某个整型数组,计算该数组所有偶数的和。
3. 10.给某个整型数组赋值,赋值规律如下,下标能被3整除的都赋值为1,能被5整除
   的都赋值为 2,能被7整除的都赋值为3,能被3、5、7任意两个或者3个都能整除
   的数赋值为 8,其余都赋值为0.
4. 11.通过终端输入10个整数并将其保存在一个整型数组中,数字保存在数组中的顺序与
   下标正好相反,也就是第一个被输入的数放在数组最后一个元素中,最后一个输入
   的数字放到第一个元素中。
5. 12.通过终端输入10个整数,计算10个整数中所有能被3 整除的数的合。
6. 13.给定一个5个元素构成的整型数组,每个元素的值都在0-9之间,按照位置将其组
   成一个 5 位数并输出,例如 int a[5] = {1,2,2,3,7};则输出73221。
7. 14.给定2个大小一样的整型数组,将某个数组作为源数组,另一个作为目的数组,然
   后将源数组的内容拷贝到目的数组。
8. 16.给定一个整型数组,从第1个元素开始将相邻的两个元素分别相互交换。交换完后,
   第 1 个元素将变成最后一个元素,其余元素都前进一位。
9. a[5]={2,3,4,5,1}
10. 17.给定一个有10个整形数的元素,将前5个元素跟后 5 个元素做整体交换,比如
    {1,1,1,1,1,2,3,2,2,2}->{2,3,2,2,2,1,1,1,1,1}。
11. 18.判断一个整型数组是否是对称数组,例如{1,2,3,3,2,1}和{1,6,8,1,8,6,1}都是对称数组。
12. 19.给定两个大小一样的整型数组,交换这两个数组的内容。
13. 20.给定两个大小一样的整型数组,将两个数组中下标一样的元素两两相加,相加后的
    结果作为这两个数组对应下标的新值,也就是操作完毕后两个数组的内容完全相同。
14. 21.给定一个能容纳10个元素的整型数组,现有9个元素,现在第5个元素的位置插入
    一个数字 88,后面的数字顺序后移。
15. 22.给定一个10个元素的整型数组,现在将第2个元素删除,后面的数组顺序前移。
16. 23.给定一个有100个元素的数组,查询数组中是否有元素的值等于某个数n。
17. 24.给定一个整型数组,求该数组元素中最大值的下标。
18. 25.给定一个整型数组,求该数组中第二大的数的下标。
19. 26.给定一个整型数组,求该数组中数值小于10的元素的个数。
20. 27.给定一个整型数组,计算大于该数组平均值的元素的个数。
21. 28.给定一个整型数组,找到数组中的最小值,并将其放到数组的首元素中,原来首元
    素的内容放到最小值所在的元素中。
22. 29.给定一个整型数组,统计某个整数在数组中出现的次数。
23. 30.给定一个英文句子,单词之间用1个空格分开,求出第2个单词的偏移位置。例如
    “Professor du comes from Korea”的偏移位置是10。
24. 31.给定一个英文句子,单词之间用1个空格分开,求其中所有单词的数量。
25. 32.给定两个字符数组,将这两个拼接起来放在第一个数组中(假定第一个数组足够长),
    比如“abc”和“123”构成“abc123”。
26. 33.将一个字符数组循环右移2位。比如”12345”->”45123”,假定字符数组中字符的数量
    大于 2.
27. 34.给定一个整型数组,数组的长度为N(N>3),从数组中寻找一个连续的长度为3的
    子数组,要求该子数组的和最大。
28. 35.给定两个长度一样的整型数组,判断两个数组是否相同,相同的原则是数组中的每 一个相互对应的元素的“和值”相同,“和值”是指元素对应的整数所有位的合,例 如:a[0]的值是1112,b[0]的值是23,则这两个元素“相同”。
29. 36.给定两个字符数组,比较这两个字符数组的大小,比较的原则是字符数组中所有字 符的ASCII值相加后的和值,和值越大则字符数组越大。

37数组（求最大值及下标）定义一个整型数组，输入10个整数到数组中，并将数组中最大值及下标输出。

例如：

输入： 3 5 2 9 1 8 7 4 6 0

输出： 9 3

38.字符数组（正序输出）定义一个字符数组，输入10个字符到数组中，将字符数组内容逐个输出。

\

比如：

输入：A B C D E F G H I J

输出：A B C D E F G H I J

39.字符数组（逆序输出）定义一个字符数组，输入10个字符到数组中，将字符数组内容倒序输出。

\

比如：

输入：a b c d e f g h i j

输出：j i h g f e d c b a

40.有一个数组b[5] = {1,2,3,4,5};把这个数组拷贝到另外一个数组int a[5];中；

1.从键盘输入10个数存入数组，将这个数组逆序。（不是逆序输出）

2.从键盘输入5个整数，找出其中最大的数。

3.输入十个正整数,把这十个数按由小到大的顺序排列。

4.从键盘输入10个整数，检查整数3是否在这10个数中，若在的话它是第几个被输入的；

5输入一串小写字母（以"."为结束标志），统计出每个字母在该字符串中出现的次数(若某字母不出现，则不要输出)。

41.编写函数将一个n*n矩阵转置，例如：（****）

1 2 3 4 1 5 3 4

5 6 7 8 -> 2 6 2 7

3 2 5 9 3 7 5 2

4 7 2 3 4 8 9 3

*/

42.

//杨辉三角输入n打印一个n行的杨辉三角

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

1 6 15 20 15 6 1

###43.围圈报数

有n个人围成一圈，顺序排号。从第一个人开始报数（从1到m报数），凡报到m的人退出圈子，问最后留下的是原来第几号的哪位。（*****）

//1.计算某个由英文、数字以及标点符号构成的数组的总宽度,其中英文字符的宽度为1cm,数字宽度为 0.5cm、标点符号宽度为 0.8cm。

//2.接上题,如果规定行的宽度为 10cm,将某个字符长度超过 50 的字符串截断,恰好使 10cm宽的行能容纳。输出这个被截断的子数组。

#if 0

float jugechar(char ch)

{

if ((ch>='A'&& ch<='Z') || (ch>='a'&&ch<='z'))

{

return 1.0;

}

else if (ch>='0'&&ch<='9')

{

return 0.5;

}

else

{

return 0.8;

}

}

//"qianfeng"

int main(int argc,constchar * argv[])

{

char str[100];

float length=0.0;

int i=0;

/*scanf("%s",str);

int len= (int)strlen(str);

*/

while (scanf("%c",&str[i]),str[i]!='\n')

{

i++;

}

str[i]='\0';

int len = i+1;

for (i=0; i<len; i++) {

length+=jugechar(str[i]);

if (length>10) {

str[i]='\0';

break;

}

}

printf("%s\n",str);

return 0;

}

#endif

//3.输入十个数，任意相邻的两个数不同，输出所有的递增，递减序列

//比如：

//输入:1 5 9 8 12 21 3 0 -1 9

//输出：

//1 5 9

//9 8

//8 12 21

//21 3 0 -1

//-1 9

//

//输入: 3 9 8 -11 4 21 8 -3 0 2

//输出:

//3 9

//9 8 -11

//-11 4 21

//21 8 -3

//-3 0 2

#if 0

int main(int argc,constchar *argv[])

{

int arr[10];

for (int i=0; i<10; i++) {

scanf("%d", &arr[i]);

}

printf("%d ", arr[0]);

for (int i=1; i<9; i++) {

printf("%d ",arr[i]);

if ((arr[i]>arr[i-1] && arr[i]>arr[i+1])||(arr[i]<arr[i-1]&&arr[i]<arr[i+1]) ) {

printf("\n");

printf("%d ",arr[i]);

}

}

printf("%d\n",arr[9]);

return 0;

}

#endif

//41.编写函数将一个n*n矩阵转置，例如：（****）

//1 2 3 4 1 5 3 4

//5 6 7 8 -> 2 6 2 7

//3 2 5 9 3 7 5 2

//4 7 2 3 4 8 9 3

//int a[3][3]

//

#if 0

void reverse(int *a[],int n)

{

for (int i=0; i<n; i++) {

for (int j=i; j<n; j++) {

int temp = a[i][j];

a[i][j]=a[j][i];

a[j][i]=temp;

}

}

}

int main(int argc,constchar *argv[])

{

int a[3][3]={

{1,2,3},

{4,5,6},

{7,8,9}

};

int *p[3];

for (int i=0; i<3; i++) {

p[i]=a[i];

}

reverse(p, 3);

/*for (int i=0; i<3; i++) {

for (int j=i; j<3; j++) {

if (i!=j)

{

int temp = a[i][j];

a[i][j]=a[j][i];

a[j][i]=temp;

}

}

}*/

for (int i=0; i<3; i++) {

for (int j=0; j<3; j++) {

printf("%d ", a[i][j]);

}

printf("\n");

}

printf("\n");

return 0;

}

#endif

//1. 有m个人围成一圈，开始报数，报道n，退出，问最后剩下的是几号。（从1号开始）

//比如：

//输入:5 3

//输出：

//4

//

//输入: 6 2

//输出:

//5

#if 0

int main(int argc,constchar *argv[])

{

int a[20];

int m,n,cnt=0,k=0,i=0;

scanf("%d%d",&m,&n);

if (m<1 || m>20 || n<1) {

return -1;

}

for (int i=0; i<m; i++) {

a[i]=i+1;

}

while (cnt < m-1)

{

if (a[i]) {

k++;

}

if (k==n) {

cnt++;

a[i]=0;

k=0;

}

i++;

if (i==m) {

i=0;

}

}

i=0;

while (a[i]==0) {

i++;

}

printf("%d\n",a[i]);

}

#endif

//2. 输入两个数，第一个数决定一个nXn的矩阵，第二个数决定从1开始赋值，赋值的上限

//比如：

//输入:5 18

//输出：

//1 2 3 4 5

//16 17 18 0 6

//15 0 0 0 7

//14 0 0 0 8

//13 12 11 10 9

//

//输入: 4 12

//输出:

//1 2 3 4

//12 0 0 5

//11 0 0 6

//10 9 8 7

#if 0

int main(int argc,constchar *argv[])

{

int a[20][20]={};

int m,n;

int type=1;//1:从左往右赋值, 2:从上往下赋值 3:从右往左赋值 4:从下往上

int s1,s2,s3,s4,i;//控制边界

scanf("%d%d",&n,&m);

if (n<0 || n>20 || m>n*n) {

return -1;

}

s1=n-1;

s2=n-1;

s3=0;

s4=1;

int p=0,q=0;//控制二维数组下标

for (i=1; i<=m; i++) {

a[p][q]=i;

switch (type) {

case 1://从左往右赋值

q++;

if (q==s1) {

type=2;

s1--;

}

break;

case 2:

p++;

if (p==s2) {

type=3;

s2--;

}

break;

case 3:

q--;

if (q==s3) {

type=4;

s3++;

}

break;

case 4:

p--;

if (p==s4) {

type=1;

s4++;

}

break;

default:

break;

}

}

for (int i=0; i<n; i++) {

for (int j=0; j<n; j++) {

printf("%4d", a[i][j]);

}

printf("\n");

}

printf("\n");

return 0;

}

#endif

//1 2 3 4 5 3 3 2 1 2 a[10]

//2 1 1 1 1 1 1 1 0 1 count[10]

//4..输入10个数，找出出现次数最多的数（如果多个并列，则按数字出现顺序分别输出）

//比如：

//输入：1 2 2 3 4 5 6 7 8 9

//输出：2

//数据结构:定义一个整型数组 int count[10]存储每个元素的个数,开始时每个元素个数初始化为1

//

//算法:

//(1) 利用双层循环,每一个元素都与后面一个元素比较,如果两者相同,则该元素次数+1,

//(2) 以上的算法中两个相同的元素的次数是一样的,优化如下,比较两个元素的时候,如果两者相等,则该元素次数+1,后面的元素次数设置为0,比较的时候再判断这个元素是否已经比较

//

//伪代码:

//

//定义数组保存每个元素次数

//

//使用双层循环遍历数组

//如果当前元素后后面元素相等,并且后面的元素次数不为0

//当前元素次数+1,后面的元素次数设置为0

//

//从保存每个元素次数的数组中查找最大的值

#if 0

int main(int argc,constchar *argv[])

{

int a[10];

int cnt[10];

int max;

for (int i=0; i<10; i++) {

scanf("%d", &a[i]);

cnt[i]=1;

}

for (int i=0; i<10; i++) {

if (cnt[i]) {

for (int j=i+1; j<10; j++) {

if (a[j]==a[i]) {

cnt[i]++;

cnt[j]=0;

}

}

}

}

max = cnt[0];

for (int i=1; i<10; i++) {

if (cnt[i]>max) {

max = cnt[i];

}

}

for (int i=0; i<10; i++) {

if (max == cnt[i]) {

printf("%d ", a[i]);

}

}

printf("\n");

return 0;

}

#endif

//5.魔方阵是一个古老的智力问题，它要求在一个m*m的矩阵中填入1～m^2的数字（m为奇数），使得每一行、每一列、每条对角线的累加和都相等。请编程实现输入m，输出m*m的魔方阵出来。

//比如：

//输入：3

//输出：

//6 1 8

//7 5 3

//2 9 4

//(1)将1放在第一行中间一列；

//(2)从2开始直到n×n止各数依次按下列规则存放；每一个数存放的行比前一个数的行数减1，列数加1/减1（例如上面的三阶魔方阵，5在4的上一行后一列）；

//(3)如果上一个数的行数为1，则下一个数的行数为n(指最下一行);例如1在第一行，则2应放在最下一行，列数同样加1；

//(4)当上一个数的列数为n时，下一个数的列数应为1，行数减去1。例如2在第3行最后一列，则3应放在第二行第一列；

//(5)如果按上面规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。例如按上面的规定，4应该放在第1行第2列，但该位置已经被占据，所以4就放在3的下面；

int main(int argc,constchar *argv[])

{

int a[19][19]={};

int n;

int i,j,tempi,tempj;

int k=1;

scanf("%d",&n);

if (n<3||n%2==0||n>19)

{

return -1;

}

i=0;

j=n/2;

while (k<=n*n)

{

a[i][j]=k++;

tempi = i;

tempj = j;

i--;

j--;

if (tempi==0)

{

i=n-1;

}

if (tempj==0)

{

j=n-1;

}

if (a[i][j]) {

i=tempi+1;

j=tempj;

}

}

for (i=0; i<n; i++) {

for (j=0; j<n; j++) {

printf("%4d", a[i][j]);

}

printf("\n");

}

printf("\n");

return 0;

}

//数组的倒序操作

//int main(int argc, const char *argv[])

//{

// int score[5];

// for (int i=4; i>=0; i--) {

// scanf("%d",&score[i]);

// }

// for (int i=0; i<5; i++) {

// printf("%d ", score[i]);

// }

// printf("\n");

// return 0;

//}

//数组不能越界访问

//int main(int argc, const char *argv[])

//{

// int a=100, b=0;

// int score[5];

// for (int i=0; i<=5; i++) {

// scanf("%d",&score[i]);

// }

//

// //printf("%p %p",&score[4],&a);

// for (int i=0; i<10; i++) {

// printf("%d ",score[i]);

// }

// printf("a=%d b=%d\n",a,b);

//

// printf("\n");

// return 0;

//}

//数组初始化

//定义一个数组后,如果不初始化,那么数组的值是未定义的;

//完全初始化:把数组中的每个成员都给初值;

//int main(int argc, const char *argv[])

//{

// int a[10]={1,2,3,4,5,6,7,8,9,10};

// for (int i=0; i<10; i++) {

// printf("%d ", a[i]);

// }

// return 0;

//}

//部分初始化:只对数组部分元素赋初值

//int main(int argc,const char *argv[])

//{

// int a[10]={1,2,3};

// for (int i=0; i<10; i++) {

// printf("%d ",a[i]);

// }

// return 0;

//}

//数组初始化为0;

//int main(int argc,const char *argv[])

//{

// //int a[10]={};

//

// int a[10]={0};

// for (int i=0; i<10; i++) {

// printf("%d ", a[i]);

// }

// return 0;

//}

//求学生的平均成绩

//int main(int argc,const char *argv[])

//{

// int score[10]={};

// int sum=0;

// char ch;

// int i;

// for (i=0; i<10; i++) {

// scanf("%d%c", &score[i],&ch);

// sum+=score[i];

// if (ch=='\n') {

// break;

// }

// }

// printf("average = %d\n", i<10?sum/(i+1):(sum/i));

//

// return 0;

//}

//斐波那契数列

//输出斐波那契数列的前20项

// 1 1 2 3 5 8 13 21 34 55 89 ....

// a[n]=a[n-1]+a[n-2]

//int main(int argc,const char *argv[])

//{

// int a[20]={1,1};

// for (int i=2; i<20; i++) {

// a[i]=a[i-1]+a[i-2];

// }

//

// for (int i=0; i<20; i++) {

// printf("%d ", a[i]);

// }

// printf("\n");

//

// return 0;

//}

//输入10个数据,查找该数据中的最大数,并将其输出到屏幕上

//int main(int argc,const char *argv[])

//{

// int a[10]={};

// for (int i=0; i<10; i++) {

// scanf("%d", &a[i]);

// }

// int max=a[0];

// for (int i=1; i<10; i++) {

// if (a[i]>max) {

// max = a[i];

// }

// }

// printf("%d\n", max);

//

// return 0;

//}

//查找某个数值打印数值下标

//#include <stdio.h>

//int main(int argc,const char *argv[])

//{

// int a[10]={0};

// int i,val;

// int flag=0;

// for (i=0; i<10; i++) {

// scanf("%d",&a[i]);

// }

// printf("请输入要查找的数值: ");

// scanf("%d",&val);

// for (i=0; i<10; i++) {

// if (a[i]==val) {

// flag =1;

// printf("%d ",i);

// }

// }

// if (!flag) {

// printf("没有该数值");

// }

// printf("\n");

//

// return 0;

//}

//字符数组

//"qianfeng"

//

//char str[20]

//int main(int argc,const char *argv[])

//{

// int a[10]={};

// printf("%p\n",a);//数组名是一个地址常量

// printf("%p\n",&a[0]);

// printf("%p\n",&a);

//

// return 0;

//}

//int main(int argc,const char *argv[])

//{

// //char str[20]="hello world";

// //char str[10]={'h','e','l','l','o'};

// char str[11]="helloworld";

//

// printf("%s\n", str);

// return 0;

//}

//

//#include <stdio.h>

//int main(int argc,const char *argv[])

//{

// int i,num,a[6]={};//注意数组宽度为6

// for (i=0; i<5; i++) {

// scanf("%d",&a[i]);

// }

// scanf("%d",&num);

// printf("\n");

// for (i=4;i>=0;i--)

// {

// if (a[i] > num)

// {

// a[i+1]=a[i];//大于数值,的依次后移

//

// if(a[i==0]>num)//当a[0]大于num时,直接把num赋给a[0]

// {a[i]=num;}

// }

//

//

//

// else

// {

// a[i+1]=num;

// break;//num大于所有的数值,把[5]直接赋给num,跳出循环

// }

// }

//

//

//

// for(i=0;i<6;i++)

// {

// printf("%d\n",a[i]);

// }

// return 0;

//

//}

//

//输入一个大写字母，如F

//

//比如：

//

//输入:F

//

//输出：

//

//A

//

//ABA

//

//ABCBA

//

//ABCDCBA

//

//ABCDEDCBA

//

//ABCDEFEDCBA

//输入:C

//

//输出:

//

//A

//

//ABA

//

//ABCBA

//#include <stdio.h>

//int main(int argc,const char *argv[])

//{ char ch;

// int i,j;

// scanf("%c",&ch);

// for(i=0;i<ch-'A'+1;i++)

// {

// for(j=0;j<=i;j++){

// printf("%c",'A'+j);

// }

//

// for (j=i;j>0; j--) {

// printf("%c",j+'A'-1);

// }

//

// printf("\n");

// }

//

// return 0;

//}

//输入一个大写字母，如F，输出

//比如：

//输入：F

//输出：

//F

//EFE

//DEFED

//CDEFEDC

//BCDEFEDCB

//ABCDEFEDCBA

//

//输入：D

//输出:

//D

//CDC

//BCDCB

//ABCDCBA

//

//#include <stdio.h>

//int main(int argc,const char *argv[])

//{ char ch;

// int i,j;

// scanf("%c",&ch);

// for(i=0;i<ch-'A'+1;i++)

// {

// for(j=i;j>=0;j--){

// printf("%c",ch-j);

// }

//

// for (j=0;j<i; j++) {

// printf("%c",ch-j-1);

// }

//

// printf("\n");

// }

//

// return 0;

//}

//#include <stdio.h>//n的阶乘之和

//int main(int argc,const char *argv[])

//{

// int sum=0,i,n,temp=1;

// scanf("%d",&n);

// for(i=1;i<=n;i++)

// {

// temp*=i;

// sum+=temp;

// }

// printf("%d",sum);

// return 0;

//}

//使用嵌套循环产生下列图案：输入底边长n

//比如：

//输入：F

//输出：

//F

//FE

//FED

//FEDC

//FEDCB

//FEDCBA

//

//输入：C

//输出:

//C

//CB

//CBA

//#include <stdio.h>

//int main(int argc,const char *argv[])

//{ char ch;

// int i,j;

// scanf("%c",&ch);

// for(i=0;i<ch-'A'+1;i++)

// {

// for(j=0;j<=i;j++){

// printf("%c",ch-j);

// }

//

//

// printf("\n");

// }

//

// return 0;

//}

//省约数组长度,必须初始化

//int a[]={1,2,3};

//int main(int argc, const char * argv[])

//{

// int a[]={1,2,3,4};

// printf("%ld\n",sizeof(a));

//

// return 0;

//}

#define LEN10

//

//int main(int argc,const char *argv[])

//{

// int a[LEN]={};

// for (int i=0; i<LEN; i++) {

// scanf("%d",&a[i]);

// }

//

// for (int i=0; i<LEN; i++) {

// printf("%d ", a[i]);

// }

// return 0;

//}

//数组排序

//冒泡排序

//从小到大

//9 8 7 6 5 ===> 5 6 7 8 9

//第一次排序,交换4次

//8 9 7 6 5

//8 7 9 6 5

//8 7 6 9 5

//8 7 6 5 9

//第二次排序交换3次

//7 8 6 5 9

//7 6 8 5 9

//7 6 5 8 9

//第三次排序交换2次

//6 7 5 8 9

//6 5 7 8 9

//第四次排序交换1次

//5 6 7 8 9

#if0

voidsort_array(inta[],intlen)

{

for(inti=0; i<len-1; i++)

{

for(intj=0; j<len-i-1; j++)

{

if(a[j]>a[j+1])

{

inttemp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

}

}

intmain(intargc,constchar*argv[])

{

inta[LEN]={9,8,7,6,5};

for(inti=0; i<LEN; i++) {

scanf("%d",&a[i]);

}

sort_array(a,LEN);

for(inti=0; i<LEN; i++) {

printf("%d ",a[i]);

}

return0;

}

#endif

#if0

//选择排序

//9 8 7 6 5 ===> 5 6 7 8 9

//第一次

//5 8 7 6 9

//第二次

//5 6 7 8 9

//第三次

//5 6 7 8 9

//第四次

//5 6 7 8 9

//8 7 5 6 4

//4 7 5 6 8

//4 5 7 6 8

//4 5 6 7 8

//4 5 6 7 8

voidsort(inta[],intlen)

{

for(inti=0; i<len-1; i++)

{

intk=i;//保存最小值下标

for(intj=i+1; j<len; j++)//求最小值下标

{

if(a[k]>a[j])

{

k=j;

}

}

if(k!=i)

{

inttemp=a[i];

a[i]=a[k];

a[k]=temp;

}

}

}

intmain(intargc,constchar*argv[])

{

inta[LEN]={};

for(inti=0; i<LEN; i++) {

scanf("%d",&a[i]);

}

sort(a,LEN);

for(inti=0; i<LEN; i++) {

printf("%d ",a[i]);

}

printf("\n");

return0;

}

#endif

#if0

//插入法

//9 8 6 7 5 ==> 5 6 7 8 9

//int temp =8

//9 9 6 7 5

//8 9 6 7 5

//temp = 6;

//8 8 9 7 5

//6 8 9 7 5

//temp = 7;

//6 8 8 9 5

//6 7 8 9 5

//temp = 5;

//6 6 7 8 9

//5 6 7 8 9

voidarray_sort(inta[],intlen)

{

for(inti=0; i<len -1; i++) {

inttemp = a[i+1];

// int j=i;

// while (j>=0 && a[j]>temp) {

// a[j+1]=a[j];

// j--;

// }

intj=i;

for(; j>=0&& a[j]>temp; j--) {

a[j+1]=a[j];

}

a[j+1]=temp;

}

}

intmain(intargc,constchar*argv[])

{

inta[LEN]={};

for(inti=0; i<LEN; i++) {

scanf("%d",&a[i]);

}

array_sort(a,LEN);

for(inti=0; i<LEN; i++) {

printf("%d ", a[i]);

}

printf("\n");

return0;

}

#endif

//二维数组

//int a[10]

//int a[5][6];

//把二维数组看成由一维数组组成的数组

//a[i][j]

//int main(int argc,const char *argv[])

//{

// int a[3][2]={};

// for (int i=0; i<3; i++) {

// for (int j=0; j<2; j++) {

// scanf("%d",&a[i][j]);

// printf("%d ",a[i][j]);

// }

// }

//

// printf("\n");

// printf("%ld\n", sizeof(a));

// return 0;

//}

//int main(int argc,const char *argv[])

//{

// //int a[2][3]={1,2,3,4,5,6};

// int a[2][3]={{1,2,3},

// {4,5,6}};

//

// for (int i=0; i<2; i++) {

// for (int j=0; j<3;j++) {

// printf("%d ", a[i][j]);

// }

// }

//

// return 0;

//}

// 1

// 1 1

// 1 2 1

//1 3 3 1

//1 4 6 4 1

//1 5 10 10 5 1

//int main(int argc, const char *argv[])

//{

// int a[10][10]={};

//

// for (int i=0; i<10; i++) {

// for (int j=0; j<=i; j++)

// {

// if (j==i || j==0)

// {

// a[i][j]=1;

// }

// else

// {

// a[i][j]=a[i-1][j]+a[i-1][j-1];

// }

// printf("%4d", a[i][j]);

//

// }

// printf("\n");

// }

//

// return 0;

//}

intmain(intargc,constchar*argv[])

{

inta[10][10]={};

for(inti=0; i<10; i++)

{

for(intj=0; j<=i; j++)

{

if(j==i || j==0)

{

a[i][j]=1;

}

else

{

a[i][j]=a[i-1][j]+a[i-1][j-1];

}

}

}

for(inti=0; i<10; i++) {

printf("%*d",24-2*i, a[i][0]);

for(intj=1; j<=i; j++) {

printf("%4d", a[i][j]);

}

printf("\n");

}

return0;

}