Day06：C语言学习作业

编写一个程序。输出以下形式的前五行杨辉三角图案 

//初始化数组内容都为0；
int a[5][9] = {0};
//初始化 第一行 和 第一列 的1，避免计算时越界
a[0][4] = 1;
a[4][0] = 1;
//外层循环为遍历行，从第二行开始遍历，如果从第一行开始遍历会越界访问
for (int i = 1; i < 5; ++i) {
    //内层循环同上
    for (int j = 1; j < 9; ++j) {
        //直接计算和
        a[i][j] = a[i - 1][j - 1] + a[i - 1][j + 1];
    }
}
//将得出的数组转换位为字符，美观一点，哈哈哈！！
//遍历数组并输出
for (int i = 0; i < 5; ++i) {
    for (int j = 0; j < 9; ++j) {
        //如果数值为零输出‘ ’空字符，如果为数字，输出字符数字
        if(a[i][j] == 0){
            printf("%c",' ');
        } else{
            printf("%c",a[i][j] + '0');
        }
    }
    printf("\n");
}

 结果：

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

编写一个程序。请用 C、JAVA、C# 任一种语言，对数组 {3, 2, 10, 1, 23, 15, 82} 进行由小到大的排序。(要求使用冒泡排序 和 简单选择排序实现)

这里有三种写法（多的还没弄明白），分别是一个冒泡和两个选择排序

两种选择排序有各自的优点：

第一个写法更简单，但是最坏情况下，需要交换值得次数非常多。

第二种写法比较复杂，但是只需要简单得更改旗子得位置就可以，外层循环的次数就是交换值得次数

第一种：冒泡排序

规定顺序为从小到大排序：有两种不同方向的 “冒泡” ，从小泡往大泡冒 和 从大泡往小泡冒
主要区别：外层循环方向 和 内层循环的判断条件，这里时从大泡往小泡冒（先把大的排列好） 

//初始化数组
int a[] = {3,2,10,1,23,15,82};
//用sizeof计算数组长度
int len = sizeof(a) / sizeof(int);

//冒泡排序：
//如果规定顺序为从小到大排序：有两种不同方向的 “冒泡” ，从小泡往大泡冒 和 从大泡往小泡冒
//主要区别在 外层循环方向 和 内层循环的判断条件，这里时从大泡往小泡冒（先把大的排列好）

//创建交换容器
int t;
//外层循环遍历数组，一次循环确定一次最大值
for (int i = len - 1; i >= 0; --i) {
    //内层循环遍历i之前的值，因为里面时比较 遍历到的值 和 其下一个值，所以j-1，避免重复对比
    for (int j = 0; j < i - 1; ++j) {
        //当 遍历到的值 比 其下一个值 大，将其调换
        if(a[j] > a[j+1]){
            //交换值
            t = a[j];
            a[j] = a[j + 1];
            a[j + 1] = t;
        }
    }
}

//遍历并输出数组
printf("Sort:\n");
for (int i = 0; i < len; ++i) {
    printf("%d ",a[i]);
}
printf("\n");

第二种：简单选择排序（一）

固定对比位置：反复对比当前 （规定的位置 和 遍历到的位置）的值，比规定位置小情况，交换俩个的值，然后挪动规定位置，再进行对比

//简单选择排续,第一种
// 固定对比位置：反复对比当前 （规定的位置 和 遍历到的位置）的值，比规定位置小情况，交换俩个的值，然后挪动规定位置，再进行对比

//初始化数组
int a[] = {3,2,10,1,23,15,82};
//通过sizeof获取数组长度
int len = sizeof(a) / sizeof(int);

//创建交换容器
int t;
//外层循环规定 “规定位置”
for (int i = 0; i < len; ++i) {
    //内层循环遍历 “规定位置” 后的值
    for (int j = i + 1; j < len; ++j) {
        //当遍历到的值比 “规定位置” 的值小就交换，
        if(a[i] > a[j]){
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
}

//打印数组内容
printf("Sort:\n");
for (int i = 0; i < len; ++i) {
    printf("%d ",a[i]);
}
printf("\n");

第三种：简单选择排序（二）

插旗帜：对当前遍历的最小值插旗子，将 （插旗子的位置 与 规定位置的位置） 对比，如果位置变了再交换值

//简单选择排序，第二种
//插旗帜：对当前遍历的最小值插旗子，将 （插旗子的位置 与 规定位置的位置） 对比，如果位置变了再交换值
int a[] = {3,2,10,1,23,15,82};
int len = sizeof(a) / sizeof(int);

//定义交换容器
int t;
//外层循环规定 “规定位置”
for (int i = 0; i < len; ++i) {
    //对“规定位置”插旗子
    int flag = i;
    //遍历规定位置后的值，将 （“规定位置” 与 插旗子位置）的值 对比，
    //循环的结果：旗子会插到 比规定位置小的值 里面的最小值 的地方
    for (int j = i + 1; j < len; ++j) {
        //如果遍历的值比规定位置的值小，将旗子的位置插过去
        if(a[j] < a[flag]){
            flag = j;
        }
    }
    //将for中得到的 旗子的位置 与 规定位置 的位置对比，如果不一样，交换值
    if(flag != i){
        t = a[i];
        a[i] = a[flag];
        a[flag] = t;
    }
}

//遍历数组并输出
printf("Sort:\n");
for (int i = 0; i < len; ++i) {
    printf("%d ",a[i]);
}
printf("\n");

编写一个程序。假设你有一只刚出生的母兔，母兔第3年开始生小兔，以后每年生一只。如果生出的都是母兔，请代码实现：输入你拥有该母兔后的第几年，输出该年你拥有的兔子数。(思路提示：1  1  2  3  5   8   13   21)

//创建并从键盘键入需要输出第几年得兔子总数
int year;
printf("Enter year:\n");
scanf("%d",&year);

//设置第一年和第二年的兔子数值为1
if(year == 1 || year == 2){
    printf("This year (%d) have 1 rabbit!\n",year);
    return 0;
}

//初始化去年和前年得兔子
int before_last = 1;
int last = 1;

//创建兔子总数容器
int sum = 0;

//设置断点，由第三年开始计算兔子数
for (int i = 3; i < year + 1; ++i) {
    //今年的兔子数是去年和前年得兔子数加起来的和
    sum = before_last + last;
    //记录的去年和前年的兔子数量往后延一年
    before_last = last;
    last = sum;
}

//输出兔子数
printf("This year (%d) have %d rabbit!\n",year,sum);

编写一个程序。输入两个n行m列的矩阵A和B，输出他们的和A+B

//创建行和列容器，并从键盘上键入行值和列值
int rows,columns;
printf("Enter rows and columns:\n");
scanf("%d %d",&rows,&columns);

//根据键入的行值和列值创建a数组，并键入值
int a[rows][columns];
printf("Enter a[%d][%d] row:\n",rows , columns);
for (int i = 0; i < rows; ++i) {
    printf("%d row:\n",i + 1);
    for (int j = 0; j < columns; ++j) {
        scanf("%d",&a[i][j]);
    }
}

//偷个懒反正也不输出 a数组 和 b数组 的值，干脆直接在 数组a 中计算
//创建中间值
int temp;

//记录每次的中间值并与对应的数组中的值相加
printf("Enter b[%d][%d] row:\n",rows , columns);
for (int i = 0; i < rows; ++i) {
    printf("%d row:\n",i + 1);
    for (int j = 0; j < columns; ++j) {
        scanf("%d",&temp);
        a[i][j] += temp;
    }
}

//输出数组a
printf("Result is : \n");
for (int i = 0; i < rows; ++i) {
    for (int j = 0; j < columns; ++j) {
        printf("%d ",a[i][j]);
    }
    printf("\n");
}

编写一个程序。一个长度为10的数组中重复数据，现要求相同数据只保留一份，其他的用0来代替，然后从大到小输出（int a[ ]={3, 2, 10, 1, 23, 15, 82,1,2,78};） 

//创建数组，并通过键盘键入值
int a[10];
printf("Enter 10 numbers:\n");
for (int i = 0; i < 10; ++i) {
    scanf("%d",&a[i]);
}

//创建交换容器
int temp = 0;

//以简单选择排序的思路遍历数组
//外层循环确定 规定位置
for (int i = 0; i < 10; ++i) {
    //内层循环遍历 规定位置 后面的值
    for (int j = i + 1; j < 10; ++j) {
        //当 规定位置的值 和 遍历到的值 相等的时候，将遍历到的位置赋值为0
        if(a[i] == a[j]){
            a[j] = 0;
        }
        //当 规定位置的值 比 遍历到的值 小的时候，将其位置互换
        if(a[i] < a[j]){
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }
}

//输出数组值
for (int i = 0; i < 10; ++i) {
    printf("%d ",a[i]);
}

【选做题】编写一个程序。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值的那两个整数，并输出它们的数组下标。输入: nums = [3,2,4]，target = 6 输出:[1,2]。

//创建测试数组，后续可以添加scanf来手动输入数组
int nums[9] = {1,2,3,4,5,6,7,8,9};

//创建目标值容器并通过键盘键入
int target;
printf("Enter target:\n");
scanf("%d",&target);

//创建旗子并初始化
int flag = 0;

//以选择排序的思维遍历数组，外层规定位置，内层遍历数组
for (int i = 0; i < 9; ++i) {
    for (int j = i + 1; j < 9; ++j) {
        //当规定位置的值 加上 遍历到的值 结果为目标值时输出
        if(nums[i] + nums[j] == target){
            printf("nums[%d](%d) + nums[%d](%d) = %d\n",i,nums[i],j,nums[j],target);
            flag++;
        }
    }
}

//当旗子值等于0时，也就是没有值相加等于目标值
if(flag == 0)
    printf("Can not combine target(%d)\n",target);