坐牢第五天加第六天 20240709

作业

1、提示并输入一个字符串，统计该字符串中字母、数字、空格以及其他字符的个数

代码:

​
#include<stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char arr[100];
    int a,c,d,e=0;
    printf("请输入一个字符串:");
    gets(arr);
    for(int i=0;arr[i]!='\0';i++)
    {
        if(arr[i]>='A'&&arr[i]<='Z'||arr[i]>='a'&&arr[i]<='z')
        {
            a++;
        }
        else if(arr[i]>='0'&&arr[i]<='9')
        {
            c++;
        }else if(arr[i]=' ')
        {
            d++;
        }
        else
        {
            e++;
        }
    }
    printf("字母有:%d 数字有:%d 空格有:%d 其他字符有:%d\n",a,c,d,e);
    return 0;
}

​

运行结果：

2、提示并输入一个字符串，求出该字符串中所有数字的总和

代码：

#include<stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    char arr[100];
    int a,b=0;
    printf("请输入一个字符串:");
    gets(arr);
    for(int i=0;arr[i]!='\0';i++)
    {
        if(arr[i]>='0'&&arr[i]<='9')
        {
            a=arr[i]-48;
            b=b+a;
        }
    }
    printf("所有数字的总和:%d\n",b);
    return 0;
}

运行结果：

3、定义一个4*3的二维整形数组，完成对二维数组的输入、输出。并将该二维数组中每一行的最值放入到一个一维数组中，并对该一维数组进行升序排序后输出。

代码：

#include <stdio.h>
#define M 4
#define N 3
int main(int argc, char const *argv[])
{
    int arr[M][N]={0};
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            printf("请输入第%d行%d列的元素:",i+1,j+1);
            scanf("%d",&arr[i][j]);
        }
        printf("\n");
    }
    printf("数组元素分别是:\n");
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<N;j++)
        {
            printf("%d\t",arr[i][j]);
        }
        printf("\n");
    }
    int max=0;
    int brr[M]={0};
    for(int i=0; i<M; i++) 
    {
        max = arr[i][0];
        for(int j=0; j<N; j++)
        {
            if(max < arr[i][j])
            {
                max = arr[i][j];
            }
        }
         brr[i]=max;
    }
    for(int i=0;i<M;i++)
    {
      printf("每%d行的最值:%d\t",i+1,brr[i]);
    }
    printf("\n");

    for(int i=1;i<M;i++)
    {
        for(int j=0;j<M-i;j++)
        {                       
          if(brr[j]>brr[j+1])
          {
            int temp=brr[j];
            brr[j]=brr[j+1];
            brr[j+1]=temp;
          }
        }
    }
    printf("排序后的值为:");
    for(int i=0;i<M;i++)
    {
        printf("%d\t",brr[i]);
    }
    putchar(10);
   return 0;
}

运行结果：

4、提示并输入两个一维整形数组，求这两个数组的交集。

代码：

#include <stdio.h>
#define MAX 5
int main(int argc, char const *argv[])
{
    int arr[MAX];
    int brr[MAX];
    int crr[MAX];//存储交集的数组
    int k=0;//填充交集数组的变量
    //提示输入两个数组
    for(int i=0;i<MAX;i++)
    {
        printf("第一组的第%d个元素:",i+1);
        scanf("%d",&arr[i]);
    }
     for(int i=0;i<MAX;i++)
    {
        printf("第二组的第%d个元素:",i+1);
        scanf("%d",&brr[i]);
    }
   //求交集运算
    for(int i=0;i<MAX;i++)//外层循环空arr数组的的元素
    {   
        //arr[i] 
        for(int j=0;j<MAX;j++) //内层循环空brr中的元素
        {
            //判断是否为交集中的元素
            if(brr[j]==arr[i])
            {
                //将元素放入数组中
                crr[k]=arr[i];
                k++;
            }
        }
    }
    //输出交集数组中的元素
    printf("两个数组的交集为:");
    for(int i=0;i<k;i++)
    {
        printf("%d\t",crr[i]);
    }
    printf("\n");
    return 0;
}

运行结果：

5、完成注册和登录功能：使用两个一维字符数组存储账户和密码

注册：完成对账号和密码的输入

登录：将登录账号和密码跟注册的账号和密码进行匹配，如果相等，则登录成功，否则，登录失败

代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    int menu =0;
    char sign_usrName[20]="";
    char sign_pwd[20]="";
    char login_usrName[20]="";
    char login_pwd[20]="";
    while (1)
    {
        printf("\t\t=====XXX操作系统=====\n");
        printf("\t\t1.注册\n");
        printf("\t\t2.登录\n");
        printf("\t\t0.退出\n");
            printf("输入:");
            scanf("%d",&menu);
            getchar();
        switch (menu)
        {
        case 1:
            {
               while (1)
               {
                printf("注册账号:");
                gets(sign_usrName);
                printf("注册密码:");
                gets(sign_pwd);
                if(!(strlen(sign_usrName)>=6&&strlen(sign_pwd)>=6))
                {
                    printf("注册失败\n");
                    continue;
                }
                printf("注册成功\n");
                break;
               }
               
            }
            break;
        case 2:
            {
                printf("登录账号:");
                gets(login_usrName);
                printf("登录密码:");
                gets(login_pwd);
                if(strcmp(sign_usrName,login_usrName)==0&&strcmp(sign_pwd,login_pwd)==0)
                {
                    printf("登录成功\n");
                }
                else
                {
                    printf("登录失败\n");
                }
            }
            break;
        case 0:goto END;
           default:printf("输入错误\n");
        }
    }
    END:
    return 0;
}

运行结果：

二.笔记

1.数字概述

1.1引入目的

1.对于之前所学习的内容，都是对单个数据进行操作，只需要定义单个变量，然后对该变量进行处理即可。

2.但是，如果对于庞大的数据而言，需要定义很多变量来解决，为了批量处理数据，我们引入了数组。

3.所谓数组，就是多个变量的集合。

1.2数组的概念及定义

1 .定义：数组是连续存储多个相同数据类型的变量的集合，数组属于构造数据类型

2 .注意：a.连续存储，说明这多个变量的地址是连续的

b.相同数据类型，说明同一个数组中的每个变量的数据类型都是一样的

c.变量的集合：说明数组定义时不能为空

3.定义格式：数据类型 数组名[常量]；

1、数据类型：可以是基本数据类型，也可以是构造数据类型、指针类型或者空类型

2、数组名：标识符，要符合标识符的命名规则

a. 只能由字母、数字、下划线组成

b.不能以数字开头 3) 不能使用关键字

c. 严格区分大小写

e.做到见名知意

3、中括号：表示这是数组的标识，正在定义一个数组

4、常量：表示定义的数组长度，或者说是定义的变量的个数

a. 不能为0

b. 不能为小数

c. 不能空着

4.数组的定义：

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //定义一个长度为5的整形数组
    int arr[5];     //数组元素分别是：arr[0]--arr[4]
    //定义一个长度为10的字符数组
    char brr[10];
    //定义一个长度为100的数组，存储小数
    double crr[100];
    printf("arr[0] = %d, brr[0] = %c, crr[0] = %lf\n", arr[0], brr[0], crr[0]);
    return 0;
}

6.数组的初始化：

数组的初始化：所谓初始化，就是在给变量申请空间时，顺便给定初始值初始化时，用一对花括号将元素的值包裹起来，多个值之间使用逗号隔开

对于数组的初始化而言，有三种方：

a.全部初始化：数组的长度为多少，就初始化几个元素的值

int arr[5] = {520, 1415, 666, 999, 1234}; arr[0] arr[1] arr[2] arr[3] arr[4]

b.分初始化：初始化元素的个数，小于数组的长度，此时，默认从前面元素进行初始化，没有初始化的元素用0补齐 int arr[5] = {520, 1415, 666}; 0 0 arr[0] arr[1] arr[2] arr[3] arr[4]

c.特殊初始化：在定义数组并初始化时，可以不用给定数组的长度，数组的长度由初始化元素个数而定 int arr[] = {520, 1415, 666, 999, 1234}; arr[0] arr[1] arr[2] arr[3] arr[4]

1.3对数组元素的常规操作

1> 输入输出

所谓对数组进行输入输出，其实就是对任意一个元素进行重复性输入输出，重复性的动作我们使用循环解决

注意：C语言不允许对除字符数组外的其他数组整体进行输入输出，只能找到数组元素，对单个元素进行操作

2> 求和值、均值

所谓求和值，就是将所有任意值进行累加，需要定义一个变量存储总和，但是要求，在使用之前，必须清零

所谓均值，就是将数据总和除以总个数，均值不需要循环求

3> 求最值

套路：将数组中的第一个先设置成当前的最值，然后拿着当前的最值与数组中的任意一个元素进行比较，如果比较过程中，不满足条件，则更新最值，直到所有数据都跟最值比较一遍后，得到最值

4> 查找

存在性查找：当数组中出现要查找的数据时，立即结束本次查找

统计性查找：将数组全部元素进行遍历一遍，统计出要查找数据的个数

2.二维数组

2.1 引入目的

1> 当写程序时，需要同时定义多个相同类型的一维数组时，可以选择二维数组来完成

2> 所谓二维数组，就是多个一维数组的集合

3> 二维数组也是变量的集合，是一个有行有列的容器

2.2 二维数组的概述

1> 定义格式：数据类型 数组名[常量1][常量2]；

常量1：表示定义数组时数组的行数，也可以理解成一维数组的个数 常量2：表示定义数组时的列数，也可以理解成每个一维数组的长度

常量2：表示定义数组时的列数，也可以理解成每个一维数组的长度

2> 使用格式：

1.数组名[行标]：表示下标为"行号"的那个一维数组的数组名

2.数组名[行标][列标]：表示下标为 [行标][列标] 的一个变量

3.定义数组时，中括号中的数字表示定义二维数组的行数和列数，而使用数组元素时，中括号中的数字表示的是坐标

4.无论是行标还是列表，都是从0开始，到对应数据减1的位置

3> 二维数组初始化

1.按行初始化：定义数组时，每一个一维数组的值使用一个花括号括起来 int arr[3][4] = { {1,2,3,4}, {5,6,7,8}, {9,9,9,9} };

2.按行部分初始化：每个一维数组中，可以不填满，没有初始化的部分用0补齐 int arr[3][4] = { {1,2}, {8}}; //1,2,0,0 8,0,0,0 0 ,0, 0, 0

3.按数组排列初始化：数组存储数据时，默认是按顺序存储，第一行存储满了，存第二行 int arr[3][4] = { 1,2,3,4,5,6,7,8, 9}; //1,2,3,4 5,6,7,8, 9,0,0,0

4.特殊初始化：定义二维数组并初始化时，可以不指定第一维的大小，由初始化总个数除以列数向上取整，得到行数 int arr[][4] = { 1,2,3,4,5,6}; // 1,2,3,4 5,6,0,0 5、注意：定义二维数组时，无论任何时候，第二维都不能省略

2.2 二维数组的相关操作

1> 输入输出

对于二维数组而言，是有行有列的元素集合，需要使用双重循环来进行定位横标和纵标

在双重循环中，找到任意一个元素 arr[i][j] 来对其进行输入输出

2> 求和、均值、最值

1、整体求和就是将任意一个元素进行累加

2、求每一行的和：将每一行的数据进行累加，求出结果后，可以放入一个新数组

3、求整体最值：先将第一个当做最值，然后遍历所有的元素，进行比较，给定比较条件后，适当更新最值

4、求每一行的最值：在外层循环内，先将当前行的第一个当做最值，然后遍历当前行的所有数据，进行比较和更新

4> 转置

1、所谓转置，就是将二维数组行列互换

2、完成转置，需要使用一个新数组

3、转置核心代码：brr[j][i] = arr[i][j]

2.4练习

练习：使用二维数组存储杨辉三角

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

#include<myhead.h>
#define MAX 10             //杨辉三角的最大阶数

int main(int argc, const char *argv[])
{
    //定义一个二维数组
    int arr[MAX][MAX] = {0};

    //定义变量接受用户输入的阶数
    int N = 0;              

    //输入阶数
    printf("请输入杨辉三角的阶数：");
    while(1)
    {
        scanf("%d", &N);

        //对输入的数据进行判断
        if(N<1 || N>MAX)
        {
            printf("输入有误，请重新输入:");
            continue;
        }

        break;
    }

    //处理杨辉三角
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<=i; j++)
        {
            //对位置区域进行判断
            if(j==0 || i==j)
            {
                arr[i][j] = 1;     //第一列和对角线元素都为1
            }else
            {
                arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
            }
        }
    }

    //输出结果
    printf("%d阶杨辉三角如下：\n", N);
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<=i; j++)
        {
            printf("%d\t", arr[i][j]);
        }
        printf("\n");
    }
    

    return 0;
}

3.字符数组

1> 所谓字符数组，就是存放字符的数组

2> 但是，字符数组主要解决字符串的问题，这是字符数组引入的目的

3> 字符串：用双引号括起来的0个或多个字符称为字符串, 字符串默认有结束标识 '\0'

4> C语言中，没有专门用于处理字符串的变量，所有有关字符串的操作，都要基于字符数组来完成

5> 字符数组，也分为一维字符数组、二维字符数组

3.1 一维字符数组

1> 定义格式：char 数组名[常量];

2> 字符数组初始化

1、单字符处理字符数组

全部初始化：char arr[5] = {'h', 'e', 'l', 'l', 'o'};

部分初始化：char arr[5] = {'h', 'e', 'l'}; //没有初始化的部分用 0（'\0'） 补齐

特殊初始化：char arr[] = {'h', 'e', 'l', 'l', 'o'}; //此时字符数组的长度为 5

2、字符串的形式初始化

整体初始化：char arr[10] = {"hello"}; //或者 char arr[6] = "hello";

特殊字符串初始化： char arr[] = "ni hao"; //此时，数组的实际长度7 但是，字符串实际长度为6

3> 字符数组的输入输出

1、单字符的输入输出：跟整形数组一致，需要使用循环找到任意一个元素对其进行操作

2、字符串的输入输出：需要将字符数组看成一个整体，不需要使用循环完成

3、对于字符串的输入输出，有两组函数可供使用 格式化输入输出：printf、scanf

使用的格式控制符为：%s

专门针对于字符串的输入输出函数：puts、gets

int puts(const char *s);

功能：向终端上打印一个字符串，会将字符串上的结束标识 '\0' 置换成 '\n'输出

参数：要输出的字符串起始地址（字符数组的名字）

返回值：成功调用返回成功输出的字符个数，失败返回 EOF（-1）并置位错误码

char *gets(char *s);

功能：从终端上获取一个字符串，放入到s指向的数组容器中

参数：要存放字符的字符数组名

返回值：就是数组的起始地址

4> 由于对于字符数组的操作，都是直接使用的是数组名，而数组名又是第一个元素的地址，所以，针对于字符数组处理字符串的不同操作，需要使用不同的函数完成，例如字符串的拷贝、字符串比较、字符串求长度等等

1、求字符串实际长度函数 #include <string.h> size_t strlen(const char *s);

功能：求给定字符串的实际长度，不包含结束标志 '\0'

参数：要求的字符串的起始地址

返回值：就是字符串实际长度

2、字符串的赋值：对于字符串的初始化可以使用等号完成，但是对于字符串的赋值，不允许使用等号完成

#include <string.h> char *strcpy(char *dest, const char *src);

功能：将第二个字符串src中的内容连同结束标识'\0'一同拷贝进入第一个字符串dest中

参数1：要被赋值的字符数组名

参数2：要被拷贝的字符串起始地址

返回值：成功拷贝后 dest的起始地址

3、字符串的连接 #include <string.h> char *strcat(char *dest, const char *src);

功能：将第二个字符串连接到第一个字符串后面，并将结果拷贝放到第一个数组中

参数1：目标数组 参数2：要被连接的数组

返回值：成功连接后，目标数组的起始地址

4、字符串的比较：在C语言中，不允许使用关系运算符来比较两个字符串，只能使用相关函数完成

#include <string.h> int strcmp(const char *s1, const char *s2);

功能：比较给定的两个字符串的大小：逐个比较相同位置上的两个字符的ascii值，直到出现不相同的字符或者全部到'\0'结束

参数1：要比较的第一个字符串

参数2：要比较的第二个字符串

返回值：>0:表示第一个字符串大 =0：表示两个字符串相等 <0:表示第一个字符串小