unsigned char a[5] = { 12,36,96,128,182 };

练习与注意事项:

1.while循环练习题

  • 7的倍数

int a = 7;
    while (a <= 100) {
        if (a % 7 == 0) {
            printf("%d是7的倍数n",a);
        }
        a++;
    }
  • 个位为7的数

int b = 7;
    while (b <= 100) {
        if (b % 10 == 7) {
            printf("%d是个数为7的数n",b);
        }
        b++;
    }
  • 十位为7的数

int c = 0;
    while (c <= 100) {
        if (c / 10 == 7) {
            printf("%d是十为7的数n",c);
        }
        c++;
    }
  • 既不是7的倍数并且不包含7

int d = 0;
    while (d <= 100) {
        if (d % 7 != 0 && d % 10 != 7 && d / 10 != 7) {
            printf("%d既不是7的倍数并且不包含7n",d);
        }
        d++;
    }

2.判断一个数是几位数(两种方法)

  • 1️⃣

int n = 0;
    int sum = 0;
    printf("请输入任意一个数:");
    scanf("%d位",&n);
    while (n) {
        sum++;
        n /= 10;
    }
    printf("%dn",sum);
  • 2️⃣

int num = 0;
    printf("请输入一个数:");
    scanf("%d",&num);
    num = abs(num);
    int count = 1;
    int temp = num;
    while ((num /= 10) > 0) {
        count++;
    }
    //printf("%d位数n",count);
    printf("%d是%d位数n",temp,count);

3.回顾:判断质数

int num = 13;
    BOOL flag = YES;
    for (int i = 1; i <= 100; i++) {
        if (num % i == 0 && num != 1 && num != i) {
            flag = NO;
            break;
        }
    }
    if (flag) {
        printf("shi");
    } else {
        printf("bushi");
    }

4.数组

    形式1:
      int arr[5] = {1,2,3,4,5};
    形式2:(开辟5个元素大小的空间,后面元素不够的补0)
      int arr1[5] = {1,2,3};
    形式3:(如果声明一个数组没有赋初值,必须要声明数组的长度,否则会报错)
      int arr2[];
    形式4:(数组长度由后面的赋值决定)
      int arr3[] = {1,2,3,4,5};
      int a1 = arr1[3];
    //注意数组越界问题

5.数组的遍历

int numArr[] = {10, 20, 30, 40, 50};
    for (int i = 0; i < 5; i++) { //i<=length-1或i<length
        printf("%dn",numArr[i]);
    }

6.定义一个具有20个元素的整型数组,每个元素的取值范围是30-70之间,求数组元素的和

int arr[20] = {};
    int sum = 0;
    for (int i = 0; i < 20; i++) {
        arr[i] = arc4random() % (70 - 30 + 1) + 30;
        sum+=arr[i];

    }
    printf("%dn",sum);

7.复制一个数组,即两个数组容量一样,把其中一个数组中的元素复制到另外一个数组中

int numArr[20];
    int numArr2[20];
    for (int i = 0; i < 20; i++) {
        numArr2[i] = numArr[i];
    }
    for (int i = 0; i < 20; i++) {
        printf("%dn",numArr2[i]);

    }

8.对存储十个整型元素的数组随机赋值(20-30),计算最大值和所有元素和

int arr[10];
    int max = 0;
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        arr[i] = arc4random() % (30 - 20 + 1) + 20;
        max = max > arr[i] ? max : arr[i];
        sum += arr[i];

    }
    printf("max=%dn",max);

9.生成两个数组,每个数组都有10个元素,元素取值范围20-40之间,数组对应元素相加,放到另外一个数组中

int arr1[10];
    int arr2[10];
    int arr3[10];
    for (int i = 0; i < 10; i++) {
        arr1[i] = arc4random() % (40 - 20 + 1) + 20;
        arr2[i] = arr1[i];
        arr3[i] = arr1[i] + arr2[i];
        printf("%dn",arr3[i]);
    }

10.整型数组的长度20,随机数范围35-90,找到数组中最大的元素的值和它所对应的下标

int array[20];
    int max = 0;
    int maxIndex = 0;
    for (int i = 0; i < 20; i++) {
        array[i] = arc4random() % (90 - 35 + 1) + 35;
        //max = max > array[i] ? max : array[i];
        if (max < array[i]) {
            max = array[i];
            maxIndex = i;  //存i的值
        }
    }
printf("最大值为:%dn",max);
printf("最大值的下标为:%dn",maxIndex);

11.冒泡排序法(一)

//需要比length-1次
    int numbers[] = {6, 2, 8, 3, 9, 7};
    BOOL flag = YES; 
    for (int j = 0; j < 6 - 1 && flag == YES; j++) {
        flag = NO;
        for (int i = 0; i < 6 - 1 - j; i++) { //6-1不需要访问最后一个了
            if (numbers[i] > numbers[i + 1]) {
                int temp = numbers[i + 1];
                numbers[i + 1] = numbers[i];
                numbers[i] = temp;
                flag = YES;
            }
        }
    }

    //进行遍历
    for (int i = 0; i < 6; i++) {
        printf("%dn",numbers[i]);
    }

12.冒泡排序法(二)

    int n[] = {124,76,78,35,9,21,76,12};
    //sizeof查看所占空间大小
    int count = sizeof(n) / sizeof(n[0]);
    BOOL f = YES;
    for (int j = 0; j < count - 1 && f == YES; j++) {
        f = NO;
        for (int i = 0; i < count - 1 - j; i++) {
            if (n[i] > n[i + 1]) {
                int t = n[i + 1];
                n[i + 1] = n[i];
                n[i] = t;
                f = YES;
            }
        }
    }

    for (int i = 0; i < count; i++) {
        printf("%dn",n[i]);
    }

13.字符串&字符数组

    char str1[] = {'a','b','c'}; //字符数组
    char str2[] = "abc"; //字符串
    char str3[] = {'a','b','c',''}; //字符串
    printf("%sn",str3);

//strlen()计算字符串长度
    unsigned long len = strlen(str2);
    printf("字符串长度为:%lun",len);

//strcpy()字符串拷贝
    char str5[] = "haha";
    unsigned long len1 = strlen(str5);
    char str4[len1 + 1];
    strcpy(str4, str5);
    printf("拷贝结果是:%sn",str4);

//strcat()字符串拼接
    char str6[20] = "ni";
    //unsigned long len2 = strlen(str6);
    char str7[] = "sha";
    strcat(str6, str7);
    printf("字符串拼接后是:%sn",str6);

//strcmp()字符串比较
    char str8[] = "lala";
    char str9[] = "luelue";
    int result = strcmp(str8, str9);
    printf("较大的是:%dn",result);

14.对查找字符串的空格数:例如:“I love iOS”

char string[] = "I love iOS";
    int count = 0;
    int kongge = 0;
    while (string[count] != '') {
        if (' ' == string[count]) {
            kongge++;
        }
        count++;
    }
    printf("空格数:%dn",kongge);

C# 类型体系包含下列3种类型:

 a[]范围为0~256. 数组中数都有效。

知识点:

1.数组

1️⃣数组:
  由相同数据类型组成的构造类型,每个成员称为一个数组元素。
  最简单的数组是一维数组。
2️⃣定义:
  类型说明符 数组名[常量表达式] = {值1,值2...};
一维数组定义:
  数据类型 数组名称[元素个数];
  int arges = [10];
3️⃣数组初始化:
  数组元素的访问:数组名 + 下标
4️⃣数组下标:数组元素在数组中的序号。
5️⃣下标可以是常量,也可以是变量。
6️⃣访问数组中的元素下标可以为变量。
7️⃣访问数组中的所有元素叫遍历。
8️⃣系统不会检测数组元素的下标是否越界,编程时,必须保证数组下标不能越界。
9️⃣不能这样定义数组:
  int array[] = {}; 或者 int array[2] = {1, 2, 3};
🔟数组是一个整体,不能直接参加运算,只能对单个元素进行处理,通常用到数组的地方都会用到循环。

2.冒泡排序

1️⃣使用数组时,很多时候需要将数组中的元素按照一定条件进行排序。
2️⃣冒泡排序 是比较常见的排序算法。
3️⃣因为其原理跟水底气泡上升至水面很相似而得名。
4️⃣冒泡排序涉及到双循环,外层循环控制趟数,内层循环控制比较次数。

3.操作字符数组的函数:

1️⃣''结束标识的字符数组也称为字符串。
2️⃣系统提供了很多字符串处理函数:
    strlen()  计算字符串长度
    strcpy()  字符串拷贝
    strcat()  字符串拼接
    strcmp()  字符串比较
3️⃣字符串所占的空间 至少要比 字符串长度大1,因为字符串结尾默认有’’,占一个字节, 系统提供的字符串处理函数都是根据  ‘’  来判断字符串是否结束。
4️⃣在printf输出字符串时,占位符用%s。

3-1值类型————-简单值类型:数值类型、布尔类型、字符类型、自定义类型

char a[5] = { 12,36,96,128,182 };

作业:

1.随机输入一个年份,判断该年份是否是闰年?如果是闰年,则输出该年是闰年,否则输出该年不是闰年。
满足闰年的条件:

  • 能被400整除。(如2000年是闰年,1900年不是闰年)。
  • 能被4整除,但是不能被100整除。(如2004年就是闰年,2010年不是闰年).

int year = 0;
    printf("请输入一个年份:");
    scanf("%d",&year);
    if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
        printf("%d是闰年n",year);
    } else {
        printf("%d不是闰年n",year);
    }

2.已知abc+cba =
1333,其中a、b、c均为一位数,编程求出满足条件的a、b、c所有组合。

for (int a = 1; a < 10; a++) {
        for (int b = 0; b < 10; b++) {
            for (int c = 1; c < 10; c++) {
                if ((a * 100 + b * 10 + c * 1) + (c * 100 + b * 10 + a * 1 == 1333)) {
                    printf("%d,%d,%dn",a,b,c);
                }
            }
        }
    }

3.随机产生20个10~50的正整数存放到数组中,并求数组中的最大值,最小值,平均值及各个元素之和

    int num[20];
    int max = 0;
    int min = 0;
    int avr = 0;
    int sum = 0;
    for (int i = 0; i < 20 - 1; i++) {
        num[i] = arc4random() % (50 - 10 + 1) + 10;
        max = max > num[i] ? max : num[i];
        min = min < num[i] ? min : num[i];
        avr = num[i]/20;
        sum+=num[i];
    }
    printf("最大值为:%dn",max);
    printf("最小值为:%dn",min);
    printf("平均值为:%dn",avr);
    printf("元素和为:%dn",sum);

4.编写一个程序,输入两个包含5个元素的数组,先将两个数组升序排列,然后将这两个数组合并成一个升序数组

int arr1[] = {1, 5, 8, 14, 7};
    int arr2[] = {3, 6, 34, 29, 4};
    int arr3[11] = {};
    BOOL flag = YES;
    for (int j = 0; j < 5 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 5 - 1 - j; i++) {
            if (arr1[i] > arr1[i + 1]) {
                int temp = arr1[i + 1];
                arr1[i + 1] = arr1[i];
                arr1[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 5; i++) {
        printf("数组一:%dn",arr1[i]);
    }



    for (int j = 0; j < 5 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 5 - 1 - j; i++) {
            if (arr2[i] > arr2[i + 1]) {
                int temp = arr2[i + 1];
                arr2[i + 1] = arr2[i];
                arr2[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 5; i++) {
        printf("数组二:%dn",arr2[i]);
    }



    for (int i = 0; i < 5; i++) {
        arr3[i] = arr1[i];
        arr3[i] = arr2[i - 5];
    }
    for (int j = 0; j < 10 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 10 - 1 - j; i++) {
            if (arr3[i] > arr3[i + 1]) {
                int temp = arr3[i + 1];
                arr3[i + 1] = arr3[i];
                arr3[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 10; i++) {
        printf("数组三:%dn",arr3[i]);
    }

5.给定某年某月某日,输出其为这一年的第几天

    int dayArr[] = {31, 28, 31, 28, 31, 30, 31, 31, 29, 31, 30, 31}; //先确定每个月有多少天
    int year1 = 0;
    int month = 0;
    int day = 0;
    printf("请输入一个年份:");
        scanf("%d",&year);
        if ((year1 % 400 == 0) || (year1 % 4 == 0 && year1 % 100 != 0)) {
            printf("%d是闰年n",year1);
            dayArr[2] = 29;
        }
    for (int i = 0; i < month - 1; i++) {
        day += dayArr[i];
    }
    printf("第%dn天",day + month);

6.编写整型数组排序程序(冒泡排序-升序)

    int array[] = {2,56,97,23,17,7,45};
    BOOL f = YES;
    for (int j = 0; j < 7 - 1; j++) {
        f = NO;
        for (int i = 0; i < 7 - 1 - j; i++) {
            if (array[i] < array[i + 1]) {
                int temp = array[i + 1];
                array[i + 1] = array[i];
                array[i] = temp;
                f = YES;
            }
        }
    }

    for (int i = 0; i < 7; i++) {
        printf("%d",array[i]);
    }

7.找出下列整型数组中的最大和最小值及其所在位置的下标i
int a[] = {5, -9, 32, 77, 64, -24, 14, 0, 21, 45};

    int a[] = {5, -9, 32, 77, 64, -24, 14, 0, 21, 45};
    int max1 = 0;
    int min1 = 0;
    int maxIndex = 0;
    int minIndex = 0;
    for (int i = 0; i < 10 - 1; i++) {
        if (max1 < a[i]) {
            max1 = a[i];
            maxIndex = i;
        }

    }

    for (int i = 0; i < 10 - 1; i++) {
        if (min1 > a[i]) {
            min1 = a[i];
            minIndex = i;
        }
    }
    printf("最大值是:%dn,最小值是:%dn",max1,min1);
    printf("最大值所在位置的下标是:%dn,最小值所在的下标是:%dn",maxIndex,minIndex);

8.把 str1, str2, str3 合并到 result 数组中。
char result[50] = {0};
char str1[] = “Lanou “;
char str2[] = “23_class “;
char str3[] = ” is niu best!”;
结果:“Lanou 23_class is niu best!”

char result[50] = {0};
    char str1[] = "Lanou ";
    char str2[] = "23_class ";
    char str3[] = " is niu best!";
    strcat(str1, str2);
    strcat(str1, str3);
    strcat(result, str1);
    printf("%sn",result);

9.删除字符串中含有0-9的数字

char str[] = "a34sf5slvjxz2g";
  int count = 0;
  int index = 0;  //记录位置
  while (str[count] != '') {
      if ('0' <= str[count] && str[count] <= '9') {
          count++;
          continue; //往下继续遍历
      }
      str[index] = str[count];
      index++;
      count++;
  }
  str[index] = '';
  printf("%sn",str);

                 ————-复合值类型:

a[]范围为-128~127. 数组中128和182均无效。

                                                       
struct结构{数值类型、布尔类型、自定义类型}

                                                          enum枚举

3-2引用类型–          class类

                                   interface接口

                                   delegate委托

                             – – -array数组

                                 
 内置引用类型:(dynamic动态)、object对象、string字符串

3-3指针类型

C#的数据类型可以分为3类:数值类型,引用类型,指针类型。指针类型仅在不安全代码中使用。

值类型包括简单值类型和复合型类型。简单值类型可以再细分为整数类型、字符类型、实数类型和布尔类型;而复合类型则是简单类型的复合,包括结构(struct)类型和枚举(enum)类型。

值类型包括简单类型(如字符型,浮点型和整数型等),集合类型和结构型。引用类型包括类类型,接口类型,代表类型和数组类型。

值类型和引用类型的不同之处是值类型的变量值直接包含数据,而引用类型的变量把它们的引用存储在对象中。对于引用类型的变量,完全有可能让两个不同的变量引用同一个对象,这样一来,对其中一个变量的操作就会影响到被另一个变量引用的对象。对于值类型的变量而言,每一个变量有它们自己的数值,因此对其中一个变量的操作不可能影响到另外一个变量。

1 值类型

所有的值类型都隐含地声明了一个公共的无参数的构造函数,这个构造函数叫做默认构造函数。默认构造函数返回一个初始为零的值类型的实例,称之为默认值。

对于sbyte,byte,short,ushort,int,uint,long,ulong,默认值为0。

对于char,默认值是’x0000′

对于float,默认值是0。0F

对于double,默认值是0。0D

对于decimal,默认值是0。0M

对于bool,默认值是false

对于一个枚举类型,默认值是0

对于一个结构类型,默认值的设置就是把所有值类型的域都设置为它们各自的默认值,把所有的引用类型的域赋为空

1.1 简单类型

C#提供一套预定义的结构类型叫做简单类型。简单类型用保留字定义,这些保留字仅仅是在System名字空间里预定义的结构类型的化名。比如int是保留字,System。Int32是在System名字空间中预定义类型。一个简单类型和它化名的结构类型是完全一样的,也就是说写int和写System。Int32是一样的。简单类型主要有整型,浮点类型,小数类型,布尔类型,字符型

1.1.1 整型

C#中支持9种整型:sbyte,byte,short,ushort,int,uint,long,ulong和char。

Sbyte:代表有符号的8位整数,数值范围从-128 ~ 127

Byte:代表无符号的8位整数,数值范围从0~255

Short:代表有符号的16位整数,范围从-32768 ~ 32767

ushort:代表有符号的16位整数,范围从-32768 ~ 32767

Int:代表有符号的32位整数,范围从-2147483648 ~ 2147483648

uint:代表无符号的32位整数,范围从0 ~ 4294967295

Long:代表有符号的64位整数,范围从-9223372036854775808 ~
9223372036854775808

Ulong:代表无符号的64位整数,范围从0 ~ 18446744073709551615。

char:代表无符号的16位整数,数值范围从0~65535。

Char类型的可能值对应于统一字符编码标准(Unicode)的字符集。

Char类型与其他整数类型相比有以下两点不同之处:

a,没有其他类型到char类型的隐式转换。即使是对于sbyte,byte和ushort这样能完全使用char类型代表其值的类型,
sbyte,byte和ushort到char的隐式转换也不存在。

b,char类型的常量必须被写为字符形式,如果用整数形式,则必须带有类型转换前缀。比如(char)10赋值形式有三种:

char chsomechar=”A”;

char chsomechar=”x0065″; 十六进制

char chsomechar=”u0065 ; unicode表示法

字符型中有下列转义符:

1,’用来表示单引号

发表评论

电子邮件地址不会被公开。 必填项已用*标注