2025-02-06

This commit is contained in:
2025-02-06 22:43:19 +08:00
parent 9480e81242
commit af0d9cdab6
82 changed files with 12564 additions and 0 deletions
+5
View File
@@ -0,0 +1,5 @@
#include <stdio.h>
int main(){
return 0;
}
+24
View File
@@ -0,0 +1,24 @@
#include <stdio.h>
/*
定义结构体类型
*/
typedef struct Node{
int data;
struct Node * pNext;
}Node, *pNode;
int main(){
Node node;
pNode p;
p = &node;
node.data = 10;
node.pNext = NULL;
printf("%d\n", p->data);
return 0;
}
@@ -0,0 +1,254 @@
#include <stdio.h>
// 交换两个整数的值
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 冒泡排序
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
for (int j = 0; j < n-i-1; j++) {
if (arr[j] > arr[j+1]) {
swap(&arr[j], &arr[j+1]);
}
}
}
}
// 选择排序
void selectionSort(int arr[], int n) {
int i, j, min_idx;
for (i = 0; i < n-1; i++) {
min_idx = i;
for (j = i+1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
swap(&arr[min_idx], &arr[i]);
}
}
// 插入排序
void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i-1;
while (j >= 0 && arr[j] > key) {
arr[j+1] = arr[j];
j = j-1;
}
arr[j+1] = key;
}
}
// 归并排序
void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++) {
L[i] = arr[l + i];
}
for (j = 0; j < n2; j++) {
R[j] = arr[m + 1 + j];
}
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
// 快速排序
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; j++) {
if (arr[j] < pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 希尔排序
void shellSort(int arr[], int n) {
for (int gap = n/2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
// 计数排序
void countSort(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int count[max+1];
for (int i = 0; i <= max; i++) {
count[i] = 0;
}
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
int index = 0;
for (int i = 0; i <= max; i++) {
while (count[i] > 0) {
arr[index++] = i;
count[i]--;
}
}
}
// 基数排序
void countingSortForRadix(int arr[], int n, int exp) {
int output[n];
int count[10] = {0};
for (int i = 0; i < n; i++) {
count[(arr[i] / exp) % 10]++;
}
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
void radixSort(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
for (int exp = 1; max / exp > 0; exp *= 10) {
countingSortForRadix(arr, n, exp);
}
}
// 堆排序
void heapify(int arr[], int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(&arr[i], &arr[largest]);
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
for (int i = n - 1; i >= 0; i--) {
swap(&arr[0], &arr[i]);
heapify(arr, i, 0);
}
}
// 打印数组
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
// 测试排序函数
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr)/sizeof(arr[0]);
printf("Original array: \n");
printArray(arr, n);
bubbleSort(arr, n);
printf("Sorted array using Bubble Sort: \n");
printArray(arr, n);
// 你可以在这里测试其他排序函数
return 0;
}
@@ -0,0 +1,879 @@
## 一、顺序结构
1. 将华氏温度转换为摄氏温度和绝对温度的公式分别为:
c= (f-32) (摄氏温度)
k=273.16+c (绝对温度)
请编程序:当给出f 时,求其相应摄氏温度和绝对温度。
测试数据:① f=34
② f=100
2. 写一个程序把极坐标(r,θ) (θ之单位为度)转换为直角坐标( X,Y)。转换公式是:
x=r.cosθ
y=r.sinθ
测试数据:① r=10 θ=45°
② r=20 θ=90°
3. 写一个程序,按如下格式输出数据。
name number math english computer
zhanghua 9901 80.50 87.0 80
lina 9902 70.00 80.0 90
wanggang 9903 87.00 76.0 78
4. 输入3 个双精度实数,分别求出它们的和、平均值、平方和以及平方和的开方,并输
出所求出各个值。
5. 输入一个3 位整数,求出该数每个位上的数字之和。如123,每个位上的数字和就是
1+2+3=6。
## 二、分支结构
1. 输入一个字符,判断它如果是小写字母输出其对应大写字母;如果是大写字母输出其
对应小写字母;如果是数字输出数字本身;如果是空格,输出“space”;如果不是
上述情况,输出“other”。
2. 有三个数a、b、c,由键盘输入,输出其中最大的数。
3. 输入一个数,判断它能否被 3 或者被 5 整除, 如至少能被这两个数中的一个整除则将
此数打印出来,否则不打印,编出程序。
4. 读入1 到7 之间的某个数,输出表示一星期中相应的某一天的单词:Monday、 Tuesday
等等,用switch 语句做。
5. 给出一百分制成绩,要求输出成绩等级‘A’,‘B’,‘C’,‘D’,‘E’,90 分以上为
A,8089 分为‘B,7079 分为‘C’,60~69 分为‘D’,60 分以下为‘E’。
6. 有一函数,请编程序计算y 的值(x 的值由键盘输入)。
<img src="https://yp.smallkun.cn/markdown/image-20241130003549906.png!compress" alt="image-20241130003549906" style="zoom:50%;" />
## 三、循环结构
1 计算n 的阶乘
2. 求 1 到 100 之间的奇数之和、偶数之积。
3. 输入一行字符,统计其中的英文字母、数字、空格和其他字符个数。
4. 用循环语句编写求下列表达式值的程序。
<img src="https://yp.smallkun.cn/markdown/image-20241130003536421.png!compress" alt="image-20241130003536421" style="zoom:50%;" />
5.求1!+2!+3!+...+20!
6.求下列分数序列的前20项之和。
<img src="https://yp.smallkun.cn/markdown/image-20241130003647576.png!compress" alt="image-20241130003647576" style="zoom:50%;" />
7. 任意十个数,打印出它们中的最大数、最小数。
测试数据:① 1,-12,20,30,-5,-23,33,125,200,-100
② 0,10,3,1,5,6,-10,90,9,-4
③ 12,13,14,15,10,-10,-11,-12,-9,9
8 判断一个数是否是素数
9 打印1-100 之间所有素数
10. 求1-100 之间所有非素数的和
11. 输入两个正整数 m 和 n,求其最大公约数和最小公倍数
提示:
求 m,n的最大公约数:首先将 m除以 n(m>n)得余数 R,再用余数 R 去除原来的除数,得新的余数,重复此过程直到余数为 0 时停止,此时的除数就是m 和 n的最大公约数。
求 m和 n的最小公倍数: m和 n的积除以 m和 n 的最大公约数。
测试数据: m12 n24
m100 n300
12. 打印出所有的“水仙花数”,所谓“水仙花数”是指一个三位数, 其各位数字立方
和等于该数本身。例如 153 是一个水仙花数,因为 1531\*1\*1+5\*5\*5+3\*3\*3(要求分别用一重循环和三重循环实现)。
13. 一个数恰好等于它的平方数的右端,这个数称为同构数。如 5 的平方是25, 5 是25 中的右端的数, 5 就是同构数。找出1~1000 之间的全部同构数。
14. 3025 这个数具有一种独特的性质:将它平分为两段,即30 和25,使之相加后求平方,即(30+25),恰好等于3025 本身。请求出具有这样性质的全部四位数。
15. 两位数13 和62 具有很有趣的性质:把它们个位数字和十位数字对调,其乘积不变,即13*62=31*26。 编程序求共有多少对这种性质的两位数(个位与十位相同的不在此列,如11、22,重复出现的不在此列,如 13*62 与62*13)。
16. 一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如,6 的因子为1、2、3,而6=1+2+3,因此6 是“完数”。编程序找出1000 之内的所有完数,并按下面格式输出其因子:
6 its factors are 1,2,3
17. 有一个四位正整数,组成这个四位数的四个数字各不相同,如果把它们的首尾互换,第二位与第三位互换,组成一个新的四位数。原四位数为新四位数的4 倍,请找出一个这样的四位数。
18. 给出一个不多于4 位的正整数,要求:① 求出它是几位数 ② 分别打印出每一位数字 ③ 按逆序打印出各位数字。
19. 在一个程序中计算出给定误差小于0.1,0.01,0.001,0.0001,0.00001 时,下式的值:
![image-20241130004016370](https://yp.smallkun.cn/markdown/image-20241130004016370.png!compress)
提示:本题中误差指前 n+1项之积与前 n项积之差。
20. 用泰勒展开式求sinx 的近似值
![image-20241130004040849](https://yp.smallkun.cn/markdown/image-20241130004040849.png!compress)
测试数据:① x0.3 n8
② x0.5 n20
21. 验证歌德巴赫猜想。一个充分大的偶数(大于或等于6)可以分解为两个素数之和。试编程序,将 6 至50 之间全部偶数表示为两个素数之和。
22. 用牛顿迭代法求方程在 1.5 附近的根(精度为<img src="https://yp.smallkun.cn/markdown/image-20241130004125210.png!compress" alt="image-20241130004125210" style="zoom: 40%;" />)。
![image-20241130004157841](https://yp.smallkun.cn/markdown/image-20241130004157841.png!compress)
23. 两个乒乓球队进行比赛,各出三人,甲队为A、B、C 三人,乙队为X、Y 、Z 三人,已知抽签决定比赛名单。有人向队员打听比赛的名单, A 说他不和 X 比,C 说他不和X、Z 比,请编程序找出三对赛手的名单。
## 四、数组
1. 有一个正整数数组,包含N 个元素,要求编程求出其中的素数之和以及所有素数的平均值。
2. 有一个数组,内放10 个整数。要求找出最小的数和它的下标,然后把它和数组中最前面的元素对换位置。
3. 有 N 个数已按由小到大的顺序排好,要求输入一个数, 把它插入到原有序列中,而且仍然保持有序。
4. 输入N 个数到数组中,输出所有大于N 个数平均值的数。
5. 输入N 个数到数组中,选出其中最大的数和最小的数,并分别将它们与最前面和最后面的数互换。
6. 用选择法对10 个整数由大到小排序。
7. 用筛选法求 2 到 100 之间的素数。方法如下:首先 2 是素数,凡 2 的倍数都不是素数,于是把这些数从数表中筛去, 2 以后没有被筛去的第一个数是 3, 然后把 3的倍数都从数表中筛去, 3 以后没被筛去的第一个数是 5,然后把 5 的倍数都从数表中筛去。如此下去,直到遇到某数 K(≤ N),其后没有数可筛选为止, 这时保留下的未被筛去的数就是 2 到 N 的素数。
8. 求一个 3×3 矩阵两条对角线上元素之和(每个元素只加一次)。
9 打印如下形式的杨辉三角形
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
输出前10行,从 0行开始,分别用一维数组和二维数组实现。
10.有一个二维数组整型数组中,每一行都有一个最大值,编程求出这些最大值以及它们的和。
11.把一个二维实型数组a 按照第0 列的元素进行排序(由小到大排序,用起泡法)。例如:如果a[i][0]大于a[i+1][0],则i 行与i+1 行中所有元素都要进行对换。
12.编程序将一个字符串的前 N 个子字符送到一个字符型数组中去, 然后再加上一个'\0'(不允许使用strcpy(str1,str2,n)函数)。
13.将字符数组 A 中下标为双号(0,2,4,6,8...) 的元素值传给另一个字符数组 B,然后将 B 数组的元素按逆序输出。
14.有一行字符,统计其中的单词个数(单词之间以空格分隔),并将每一个单词的第一个字母改为大写。
15.有 N 个国家名,要求按字母先后顺序排列(用起泡排序法)后输出。
16.有17 个人围成一圈(编号为0~16),从第 0 号的人开始从 1 报数, 凡报到 3 的倍数的人离开圈子,然后再数下去,直到最后只剩下一个人为止。 问此人原来的位置是多少号?
17.编程产生如下形式的方阵。
1 2 2 2 2 2 1
3 1 2 2 2 1 4
3 3 1 2 1 4 4
3 3 3 1 4 4 4
3 3 1 5 1 4 4
3 1 5 5 5 1 4
1 5 5 5 5 5 1
要求:不允许使用键盘输入语句和静态赋值语句,尽量少用循环。
18.打印所有不超过 n( n<256)的其平方具有对称性的数(也称回文数)。
19.求N 个数中的最大值,最大值出现的次数,然后求出次大值(次大值一定存在)。
20.找出 M×N 数组中所有不相邻元素,并求出它们的和(相邻的数:前一个是偶数,后一个是素数)。
21.已知 100 个自然数 1~100,我们取 1, 2, 3, 4 时, 我们可将其排成一圈使每两个数之和都是素数,即→1→2→3→4→,问 1~100 内连续取 n 个数,即 1~ n(≤ 100)能满足上述要求的最大的 n 是多少?
22.打印魔方阵。所谓魔方阵是指这样的方阵,它的每一行、每一列和对角线之和均相等。
例如:三阶魔方阵为
8 1 6
3 5 7
4 9 2
要求打印由 1到N\* N的自然数构成的魔方阵。
提示:魔方阵中各数的排列规律如下:
⑴ 将“1”放在第一行中间一列;
⑵ 从“2”开始直到n×n为止各数依次按下列规则存放:每一个数存放的行比前一个数的行数减1,列数加1;
⑶ 如果上一个数的行数为1,则下一个数的行数为 n(指最下一行);
⑷ 当一个数的列数为 n,下一个数的列数应为1,行数减1;
⑸ 如果按上面规则确定的位置已有数,或上一个数是第 1行第 n列时, 则把下一个数放在上一个数的下面。
23.统计一个单位职工的年龄,要求把相同年龄最多的那个年龄找出来(可能有几个这样的年龄),并统计出现的次数。
24.n×n 的拉丁方阵的每行、每列均为自然数的一个全排列, 每行(列)上均无重复数。
如 n=5 时, 5×5 的一种拉丁方阵可以为:
1 5 2 4 3
2 3 4 5 1
4 1 5 3 2
5 2 3 1 4
3 4 1 2 5
该数组的第一行 1,5,2,4,3 用程序自动生成,但产生的第一行不一定非得是 1,5,2,4,3,第一行填写完毕后,即以第一行作为全方阵索引, 即若第一行中的第 i 列的元素值为 j ,则 j在各行中的列号即为从第一行中元素值为 i的那一列开始读出的 n个自然数(到行末则从行头接着读),例如第一行第2列的元素值为5, 则从元素值为2的那一列(第3列)开始读出2,4,3,1,5,这就是元素5在各行中的列标号。
测试数据:① n5 ② n8
## 五、函数
1.编写一函数判断某数是否素数。
2.编写一函数求三个整数的最大值。
3.打印出3 到1100 之间的全部素数(判素数由函数实现)。
4.写一函数,使给定的一个二维数组(3×3)转置,即行列互换。
5.写一函数,将两个字符串连接,即编写一strcat 函数。
6.写一函数,求一字符串长度,即编写一strlen 函数。
7.写一函数将字符数组s1 中的全部字符复制到字符数组s2 中,不用strcpy 函数。
8.写一函数判断某数是否“水仙花数”,所谓“水仙花数”是指一个三位数, 其各位数字立方和等于该数本身。
9.在主函数内任意输入一个5×6 矩阵,编写一函数求出每一行的和放到一个一维数组中,输出此矩阵及其每一行的和。
10.写一主函数输入一数组,写一子函数实现对该数组的冒泡排序并输出。
11.任意输入20 个正整数,找出其中的素数,并将这些素数按由小到大排序。要求:判断一
个数是否为素数用函数实现;排序用函数实现。
12.编写计算m 的n 次方的递归函数。
13.编一个程序,读入具有5 个元素的整型数组,然后调用一个函数,递归计算这些元素的积。
14.编一个程序,读入具有5 个元素的实型数组,然后调用一个函数,递归地找出其中的最大元素,并指出它位置。
## 六、指针
1、 输入三个整数,按由小到大的顺序输出。
```c
#include <stdio.h>
//定义一个函数 传入两个整型指针 交换 两个指针所指向的值
void swap(int *x, int *y){
int temp;
temp = *x;
*x = *y;
*y = temp;
}
int main(void){
int a, b, c;
printf("请输入三个数字(以空格间隔):");
scanf("%d %d %d", &a, &b, &c);
//由小到大 升序
if(a > b){//b为 a、b两个变量中 最大值
swap(&a, &b);
}
if(b > c){//c 为 a、b、c中最大值
swap(&b, &c);
}
if(a > b){//b为 a、b两个变量中 最大值
swap(&a, &b);
}
printf("%d %d %d\n", a, b, c);
return 0;
}
```
2、 输入10 个整数,将其中最小的数与第一个数对换,把最大的数与最后一个数对换。写三个函数:①输入10 个数;②进行处理;③输出10 个数。
```c
#include <stdio.h>
void swap(int *x, int *y){
int temp;
temp = *x;
*x = *y;
*y = temp;
}
//输入数组元素
void input(int *arr, int n){
int i;
for(i=0;i<n;i++){
scanf("%d", arr+i);
}
}
//处理数组元素 最大值和最后一个元素交换,最小值和最前一个元素交换
void process(int *arr, int n){
int *max, *min;//max 最大值的地址 min最小值的地址
int i;
max = min = arr;
//通过遍历数组的所有元素 求出最大值和最小值的地址
for(i = 1;i < n;i++){
if(*(arr+i) > *max){
max = arr+i;
}
if(*(arr+i) < *min){
min = arr+i;
}
}
//如果最大值的地址为数组的首地址 则最小值和首地址交换后 最大值地址为最小值地址
if(max == arr){
max = min;
}
swap(min, arr);//最小值和数组首元素交换
swap(max, arr+9);//最大值和数组最后一个元素交换
}
//输出数组元素
void output(int *arr, int n){
int i;
for(i=0;i<n;i++){
printf("%d ", *(arr+i));
}
printf("\n");
}
int main(void){
int num[10];
input(num, 10);
process(num, 10);
output(num, 10);
return 0;
}
```
3、 有n 个整数,使前面各数顺序向后移m 个位置,最后m 个数变成最前面m 个数,写一函数实现以上功能,在主函数中输入n 个整数和输出调整后的n 个数。
```c
#include <stdio.h>
#include <stdlib.h>
void move(int *arr, int n){
int i, temp;
temp = *(arr+n-1);
//1 2 3 4 5
// 1 2 3 4
for(i=n-1;i>0;i--){
arr[i] = arr[i-1];
}
arr[0] = temp;
}
void output(int *arr, int n){
int i;
for(i=0;i<n;i++){
printf("%d ", *(arr+i));
}
printf("\n");
}
int main(void){
int n, i, m;
int *num;
printf("请输入您需要输入的元素个数:");
scanf("%d", &n);
/*
1 2 3 4 5 n=5 m = 2
4 5 1 2 3
*/
num = (int *)malloc(sizeof(int)*n);//动态内存分配数组容量
printf("请输入%d个数字:", n);
for(i=0;i<n;i++){
scanf("%d", num+i);//遍历输入数组每一个元素
}
printf("移动前:");
output(num, n);
printf("请输入您需要移动的个数:");
scanf("%d", &m);
for(i = 0;i < m;i++){
move(num, n);
}
printf("移动后:");
output(num, n);
return 0;
}
```
4、 写一函数,求一个字符串的长度。在main 函数中输入字符串,并输出其长度。
```c
#include <stdio.h>
int getStrLen(char *str){
int n=0;
while(*str != '\0'){
str++;
n++;
}
return n;
}
int main(void){
char str[100];
gets(str);
printf("len=%d\n", getStrLen(str));
return 0;
}
```
5、 写一函数,将一个3×3 的矩阵转置。
```c
#include <stdio.h>
void revse(int (*num)[3]){
int *start, *end;
int temp;
start = *num;//第一个数组的首个元素地址
end = *(num+2)+2;//第三个数组的最后一个元素地址
while(start < end){
temp = *start;
*start = *end;
*end = temp;
start++;
end--;
}
}
int main(void){
int num[3][3];
int i, j;
for(i=0;i<3;i++){
for(j=0;j<3;j++){
scanf("%d", *(num+i)+j);
}
}
printf("\n");
revse(num);
for(i=0;i<3;i++){
for(j=0;j<3;j++){
printf("%d ", *(*(num+i)+j));
}
printf("\n");
}
return 0;
}
```
6、 在主函数中输入10 个等长的字符串。用另一函数对它们排序。然后在主函数输出这10 个已排好序的字符串。
```c
#include <stdio.h>
#include <string.h>
/*
strcmp(字符串1, 字符串2); 比较两个字符串的大小 大于返回1 小于返回-1 等于返回0
strcpy(字符串1, 字符串2); 复制两个字符串 字符串2->字符串1
*/
void sort(char (*strs)[100]){
int i, j;
char temp[100];
for(i=0;i<10-1;i++){
for(j=0;j<10-i-1;j++){
if(strcmp(strs[j],strs[j+1]) > 0){
strcpy(temp ,strs[j]);
strcpy(strs[j], strs[j+1]);
strcpy(strs[j+1], temp);
}
}
}
}
int main(void){
char strs[10][100];
int i;
for(i=0;i<10;i++){
gets(*(strs+i));
}
sort(strs);
printf("\n");
for(i=0;i<10;i++){
puts(*(strs + i));
}
return 0;
}
```
7、 编一程序,打入月份号,输出该月的英文月名。例如,输入"3",则输出"March",要求用指针数组处理。
1: January, 2: February, 3: March, 4: April, 5: May, 6: June, 7: July, 8: August, 9: September, 10: October, 11: November, 12: December
```c
#include <stdio.h>
#include <stdlib.h>
int main(void){
//存着地址的数组 存储字符串的首地址的数组
char *month[12] = {"January", "February", "March", "April",
"May", "June", "July", "August", "September", "October",
"November", "December"};
int num;
printf("请输入月份数字形式:");
scanf("%d", &num);
printf("%s\n", *(month+num-1));
return 0;
}
```
8、 写一函数完成查找串s2 在串s1 中第一次出现的位置。
```c
#include <stdio.h>
#include <string.h>
int instr(char *dest, char *substr){
int i=0, j;
while(*(dest+i) != '\0'){
j=0;//对子串匹配从首个开始
while(*(substr+j)!='\0' && *(dest+i) == *(substr+j)){
i++;
j++;
}//暴力查找主串中和子串相等的字符 到子串结尾或遇到不相同元素时退出循环
if(j==0){//当前主串中没有和子串首元素相同的元素时 主串下标后移
i++;
}
//匹配到子串结尾标记时代表找到首个子串
if(*(substr+j) == '\0'){
return i-strlen(substr)+1;
}
}
return -1;//没有找到子串
}
int main(void){
char str[100];
char substr[100];
gets(str);
gets(substr);
printf("%d\n", instr(str, substr));
return 0;
}
```
9、 写一函数完成将无符号十进制整数转换成十六进制字符表示并存于字符串数组中。
```c
#include <stdio.h>
void decimalToHex(int dec, char *hex){
int i, j, temp, count=0;
//i, j, temp 用来数组倒置
//count 用来统计元素的个数
while(dec){
//模除十进制数字得余数后判断是否为数字 如果为 使用'0'加上该数之后存储为字符
if(dec%16 < 10){
*(hex+count++) = dec%16 + 48;
}else{
//得到A~F时,使用大写字符ASCALL值将其转换为字符
*(hex+count++) = dec%16-10 + 65;
}
dec /= 16;
}
//数组元素的倒置
i = 0;
j = count - 1;
while(i < j){
temp = *(hex + i);
*(hex + i) = *(hex + j);
*(hex + j) = temp;
i++;
j--;
}
*(hex+count) = '\0';//标记结束符
}
int main(void){
int dec;//用来存储需要转换的十进制数字
char hex[1000];//用来存储转换后的数字的
printf("请输入一个数字:");
scanf("%d", &dec);
decimalToHex(dec, hex);
puts(hex);
return 0;
}
```
10、 用指向指针的指针的方法对N 个整数排序并输出。要求排序单独写成一个函数。N 个整数和N 在主程序中输入,最后在主函数中输出。
```c
#include <stdio.h>
void sort(int (*arr)[10]){
int i, j, temp;
for(i=0;i<10-1;i++){
for(j=0;j<10-1-i;j++){
if((*arr)[j]> (*arr)[j+1]){
temp = (*arr)[j];
(*arr)[j] = (*arr)[j+1];
(*arr)[j+1] = temp;
}
}
}
}
int main(){
//指针->数组 int (*变量名)[数组的元素个数]
//数组指针 指向数组的指针
int num[10];
int i;
printf("请输入10个整数:");
for(i = 0;i<10;i++){
scanf("%d", num+i);
}
sort(&num);
for(i = 0;i<10;i++){
printf("%d ", num[i]);
}
printf("\n");
return 0;
}
```
## 七、结构体与共用体
1.定义一个结构体其中包括: 职工号、职工名、性别、年龄、工资、地址。按结构体类型定义一个结构体数组, 从键盘输入每个结构体元素所需的数据,然后逐个输出这些元素的数据(可设数组只有三个元素)。
2.有一批图书,每本书有:书名(name),作者(author) , 编号(num),出版日期(date)四个数据,希望输入后按书名的字母顺序将各书的记录排列好,供以后查询。今输入一本书的书名,如果查询到库中有此书,打印出此书的书名,作者,编号和出版日期。如果查不到此书,则打印出“无此书”。
3.13 个人围成一圈,从第一个人开始顺序报号1、2、3。 凡报到“3”者退出圈子。找出最后留在圈子里的人原来的序号。
4.编写一个程序,输入n 个(少于10 个)学生的姓名、性别、 成绩、出生年月日及入学年月日,输出成绩在80 分以上的学生的姓名、性别、成绩、出生和入学的年份。
5.将上题改为“输出成绩在80 分以上的18 岁以下的女生的姓名、成绩、出生和入学的年份”,试编写程序实现之。
6.有10 个学生,每个学生的数据包括学号、姓名、三门课的成绩,从键盘输入10 个学生数据,要求打印出三门课总平均成绩,以及最高分的学生的数据(包括学号、 姓名、三门课成绩、平均分数)。
7.设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序打印出链表中第1,3,5,7...结点。
8.设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将大于平均成绩的各个结点打印出来。
9.设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将成绩最高的结点作为链表的第一个结点,成绩最低的结点作为尾结点。
10.建立一个链表,每个结点包括:学号、姓名、性别、年龄。输入一个年龄,如果链表中的结点所包含的年龄等于此年龄,则将此结点删去。
## 八、文件
1.将10 个整数写入数据文件f3.dat 中,再读出f3.dat 中的数据并求其和。
2.一个以%5d 格式存放20 个整数的文件f4.dat,顺序号定为0~19。输入某一顺序号之后,读出相应的数据并显示在屏幕上。
3.将10 名职工的数据从键盘输入, 然后送入磁盘文件worker1. rec 中保存。设职工数据包括:职工号、职工名、性别、年龄、工资,再从磁盘调入这些数据,依次打印出来(用 fread 和fwrite 函数)。
4.将存放在worker1.rec 中的职工数据按工资高低排序,将排好序的各记录存放在worker2.rec 中(用 fread 和fwrite 函数)。
5.用scanf 函数从键盘读入 5 个学生数据(包括:学生名、学号、三门课程的分数),然后求出平均分数。用 fprintf 函数输出所有信息到磁盘文件stud.rec 中,再用fscanf 函数从 stud.rec 中读入这些数据并在显示屏上显示出来。
6.在文件 worker2.rec 中插入一个新职工的数据,并使插入后仍保持原来的顺序(按工资高低顺序插入到原有文件中),然后写入worker3.rec 中。
7.删除worker2.rec 中某个序号的职工记录,再存入原文件中(用fread 和fwrite 函数)。
8.有两个磁盘文件,各自存放已排好序的若干个字符(如a1. dat 中放"abort" a2.dat中放 "boy")要求将两个文件合并,合并后仍保持有序,存放在a3.dat 文件中。
提示:可先将两个文件中的字符存入一个字符型数组中,而后对数组重新排序,再将该数组写入a3.dat文件中。
如果不引入一个中间数组进行重新排序,该如何编程?
## 附加题
1.编程序求 5X+2Y+Z=50 的所有非负整数解。
2.有一长度不大于40 的字符串,已知其中包含两个字符“A”,求处于这两个字符“A”中间的字符个数,并把这些字符依次打印出来。
3.把25 个字母A、B 、C、··· 、X、Y 按如下要求打印出来:从最中间的字母M开始打印,然后一左一右依次打印出其它字母,即M,L,N,K,O,...。要求:初始化时按字母表顺序赋值。
4.编一个程序,把一批非零整数中的偶数、奇数的平均值分别计算出来。用零作为终止标记。
5.某单位排队形,开始排成3 路纵队,末尾多出了2 人。后改成5 路纵队,末尾又多出了3 人,最后改成7 路纵队,正好没有余数。编程序求出该单位至少有多少人。
6.将一个6×6 数组的第一行、第六行、主对角线和副对角线上的元素都存入1,其余的元素都存入-1。请编程序实现。
要求:1)不许对数组初始化。
2)尽量少用循环。
7.个位数是6,且能被3 整除的五位数共有多少个。
8.求100 至200 之间能同时被6 和8 整除的数,把这些数打印出来,并且打印这些数的和。
9.雨淋湿了一道算术题,9 个数字现在只能认清4 个(第一个数字虽模糊不清但肯定不是1):
<img src="https://yp.smallkun.cn/markdown/image-20241130010005134.png!compress" alt="image-20241130010005134" style="zoom:50%;" />
请编程序找出那些看不清的数字。
10.编程序计算下述函数在X=-7,-1,0,7 时的值。
11.判断一个给定的5×5 方阵是否以第3 列为轴线对称?
12.编写一个函数JOIN,让它实现字符串连接运算功能。
13.编写函数IND,让它判断一个字符串是否为另一个字符串的子串的功能,若是则返回第一次出现的起始位置,否则返回0。
14.编写一个函数,由参数传来一个字符串,分别求出此字符串中字母、数字和其它字符(不包括空格)的个数,输入和输出均由主函数实现。
15.已知某年不是闰年,给定该年某一天的月份和日期,求这一天是该年的第几天。
16.找规律,编程序打印6×6 的矩阵:
1 2 3 5 8 13
1 4 9 17 30 51
1 6 19 45 92 173
. . .
17.有人说在400,401,402,...499 这些数中4 这个数字共出现112 次,请编程序判定这种说法是否正确。若正确请打印出'YES',否则打印出'NO'及4 的出现次数。
18.设有8×8 的二维数组a,其中每个元素取值如下:
当 i=j 时 a[i\][j\]=M M 是你的学号)
当 i<j 时 a[i\][j\]=ij
当 i>j 时 a[i\][j\]=i×j
编程序求所有的数组元素之和。
19.找3 个数字,填在下面式子中,使等式成立。
<img src="https://yp.smallkun.cn/markdown/image-20241130010139383.png!compress!compress" alt="image-20241130010139383" style="zoom:50%;" />
① 若答案有多个,则打印一组即可;
② 若无满足条件的数字,则显示'NO DIGITALS'。
20.某航空公司规定:在旅游旺季7─9 月份,若订票超过20 张,优惠票价的15%,20 张以下,优惠5%;在旅游淡季1─5 月、10 月、11 月份订票超过20 张,优惠30%,20 张以下,优惠20%;其余月份不优惠。请编程序能根据月份和旅客订票张数决定优惠率。
21.请编程序按如下格式打印一个直角三角形的九九乘法表:
1 2 3 4 5 6 7 8 9
4 6 8 10 12 14 16 18
9 12 15 18 21 24 27
16 20 24 28 32 36
25 30 35 40 45
36 42 48 54
49 56 63
64 72
81
22.有一批实数,用零作终止标记。请编程序找出这批数中的最大值及最小值,并输出该最大值数是这批数中的第几个数(若最大值数多次出现,只打印出第一个的位置)。
23.有10 个两位整数,把这些数作以下变化,如果它是素数,则把它乘以2,若它是偶数则除以2,其余的数减1,请将变化后的10 个数按从小到大的次序打印出来。
24.已知有N 个无规律的正整数,请编程序求出其中的素数并打印出能被5 整除的数之积。
25.把一个偶数位的数从当中分开成为两个数,这两个数的和的平方等于原数。如(8+1)2=81,(20+252=2025。求10 至9999 之间满足这样条件的数是哪些? 共有多少个?
26.已知有9 个数,请求出这些数中的最大值、最小值及平均值,以及有多少个数等于平均值?
27.求二维数组中每行元素的平均值,不许引入其它的数组。
28.编程序计算函数
<img src="https://yp.smallkun.cn/markdown/image-20241130010348202.png!compress" alt="image-20241130010348202" style="zoom:50%;" />
的值。要求先将X 的各项系数先输入到数组B 中,然后再用循环结构求P(X)的值。
29.猜号码∶由随机函数产生一个1 至1000 之间的整数,让人猜之。计算机仅回答人猜的数大、小还是相等,当人猜对时,由计算机打印出人一共猜了几次。
30.编程序将一个正整数写成其它两个正整数的平方和,若不能成立时输出“NO”。
例如
![image-20241130010437816](https://yp.smallkun.cn/markdown/image-20241130010437816.png!compress)
31.将一个一维数组中的偶数依次交换。例如有8 个元素, 若其中第1、4、5 三元素是偶数时应按下图交换。
<img src="https://yp.smallkun.cn/markdown/image-20241130010458976.png!compress" alt="image-20241130010458976" style="zoom:50%;" />
32.编程序将一个6×6 的二维数组左下三角部分全赋值为-1,右上三角全赋值为1,主对角线(行,列下标相同)上的元素送入2。把数组中的值按列对齐方式输出。
要求: 不允许使用scanf 函数。
33.用随机函数求出10 组三位正整数,每组十个数,调用一函数打印出每组数,并编一函数求出每组中的最大数。
34.已知有三个数组A,B,C,A 为5 行5 列的二维数组,B、C 为只有5 个元素的一维数组,键盘输入数据的顺序如下:
23,45,6,1,-3,4,5,233,456,0,3,56,78,-56,5,6,77,8,89,9,3,6,8,9,90
请编写程序,求出A 的各行之和放至数组B 的相应元素中,求出数组A 的各列之和放至数组C 的相应元素之中。程序的输出部分要按下边形式显示:
![image-20241130010557737](https://yp.smallkun.cn/markdown/image-20241130010557737.png!compress)
35.假设a-1 和a+1 是大于10 的素数,验证<img src="https://yp.smallkun.cn/markdown/image-20241130010624492.png!compress" alt="image-20241130010624492" style="zoom:67%;" /> 可被120 整除。编程序输入a 的值,判a-1 和a+1 是否为素数。若不是输出“NOTPRIME!”;若都是素数,再验证<img src="https://yp.smallkun.cn/markdown/image-20241130010624492.png!compress!compress" alt="image-20241130010624492" style="zoom:67%;" />是否可被120 整除。
36.有n 个整数,编程序将前面的各个数依次向后移动k 个位置,最后k 个数移到最前边的k 个位置(见下图,其中n=8,k=3)。
<img src="https://yp.smallkun.cn/markdown/image-20241130010716416.png!compress!compress" alt="image-20241130010716416" style="zoom:50%;" />
思考: 程序中不许引入其它数组。
37.将一个数M 分解为质因数(M≠0)。
38.将一个整数(最多是10 位数)从低位到高位打印出来,如该数是12345 时,输出应是54321(只占一行)。
39.写一个函数比较两个字符串,如果s1=s2,则返回值0;如果s1>s2,则返回值1;如果s1<s2 则返回-1。
40.求n!的末尾有多少个零。可以通过检查n!含有多少个10 的因数来求它末尾零的个数。因为10=2×5,在n!中含有2 的因数显然多于含有5 的因数。一种求n!中5 的因数的个数的算法如下:
1)输入正整数n;
2)0=>k, n=>m;
3)若m<5,转第5 步,否则执行第4 步;
4)m/5(取整)=>m, k+m=>k, 转第3 步;
5)输出kn!末尾零的个数)。
41.分别输入N 和M 个数到数组A 和数组B 中。把只在其中一个数组中出现的那些数送入到数组C 中,并指出它们在A 或B 数组中的位置。
42.用记录来描述一个学生的成绩情况,内容包括:姓名、学号、数学成绩和PASCAL成绩。要求对一个小组的10 个学生的成绩进行统计处理:
1)计算学生的总平均分,并按平均分高低排出名次,打印出姓名。
2)打印出90 分以上和不及格者的名字。
要求用子程序来完成。
43.已知M1 是3×5 的矩阵, M2 是5×2 的矩阵, 编程序求出M1 与M2 之积。
44.百马百瓦问题。有100 匹马,100 块瓦,大马驮3 块,小马驮2 块,两个马驹驮1块。问大马、小马、马驹各多少?
要求:① 不许用for 循环; ② 循环次数尽量少。
45.找规律填写N×N 方阵。如N=8 时, 其方阵为:
<img src="https://yp.smallkun.cn/markdown/image-20241130011036567.png!compress" alt="image-20241130011036567" style="zoom:50%;" />
46.插入排序。许多玩牌的人是以这样的方式来对他们手中的牌进行排序的:设手中原有3张牌已排好序,抓1 张新牌,若这张新牌的次序在原来的第2 张牌之后,第3 张牌之前,那么就把这张新牌放在第3 张牌的位置上,原来的第3 张改为第4 张, 然后再抓新牌。按着这个算法,编写一个排序程序。
注:开始一张牌也没有,从第一张牌开始抓起。
47.求N 阶方阵(即N×N 数组)中各条反斜线上的元素之和。如4×4 数组共有7 条反斜线:
![image-20241130011108944](https://yp.smallkun.cn/markdown/image-20241130011108944.png!compress)
48.自然数N 一般写成如下形式:
![image-20241130011124712](https://yp.smallkun.cn/markdown/image-20241130011124712.png!compress!compress)
如果<img src="https://yp.smallkun.cn/markdown/image-20241130011207358.png!compress" alt="image-20241130011207358" style="zoom:50%;" />>di (i=k-1,k-2,...,1),则称N 是严格降序数;如果<img src="https://yp.smallkun.cn/markdown/image-20241130011207358.png!compress!compress" alt="image-20241130011207358" style="zoom:50%;" /><di (i=k-1,k-2,...,1),则称N 是严格升序数;如果<img src="https://yp.smallkun.cn/markdown/image-20241130011232509.png!compress" alt="image-20241130011232509" style="zoom:50%;" />=di (i=k-1,k-2,...,1),则称N 是等序数;此外,则称N是无序数。例如, 4321 是严格降序数,1234 是严格升序数,2222 是等序数,1243 是无序数。从键盘上输入一个大于9 的整数N,判它属于上述哪一类。
49.用简单迭代法解方程 <img src="https://yp.smallkun.cn/markdown/image-20241130011311960.png!compress" alt="image-20241130011311960" style="zoom:50%;" />它有两个根(如图),其迭代公式为:
![image-20241130011327616](https://yp.smallkun.cn/markdown/image-20241130011327616.png!compress!compress)
注:本程序中选取初值<img src="https://yp.smallkun.cn/markdown/image-20241130011341115.png!compress" alt="image-20241130011341115" style="zoom:50%;" /> 不同时,要分别使用公式1 或公式2 迭代,得原方程<0 或>0
的解。(公式由来略)
50.洗扑克牌。将54 张牌分别编号为1,2,…,54 号,并放在数组M 中。洗牌方法如下:产生[1,54]区间内的一个随机数K,将M[1]与M[K]交换;然后产生[2,54]之间的随机整数K,让M[2]与M[K]交换;…,直到剩下最后一张牌为止。请编写实现上述洗牌的程序。
51.有N 张牌,计算机和你轮流取牌,每次只能取 1─2 张,谁最后取完谁胜利。编写完成此功能的程序。
要求:
1)让计算机先取。
2)你取的张数由键盘输入。
3)计算机第一次取牌时由键盘输入来确定是取1 还是取2,以后它再取牌时由程序
判断来决定取几张牌。
52.已知A 是有30 个元素的整型数组,编写一个对A[I1]到A[I2](I1≤I2)之间的元素排序的函数(从大到小排序)。请调用上述函数先将A[5]至A[20]之间的元素排序,然后将A中的所有元素值输出。再调用上述函数对A[15]至A[30]之间的元素排序,最后再将A 中30 个元素值输出。
要求:1) 输入输出均由主函数实现。
2)输出时每10 个元素占1 行。
53.编程序求3 至39 之间满足下列条件的各组素数:每组有3 个素数,第2 个比第一个大2,第3 个比第2 个大4。例如 5,7,11 就是满足条件的一组。
要求:1) 不许使用数组。
2)打印满足条件的各组素数。
3)求出满足条件的素数共有多少组。
54.已知N 是正整数, 它可拆写成三个正整数N1、N2和N3 之和的形式N=N1+N2+N3。请编程序打印出满足上式的全部组合,并当N1、N2 和N3 中至少有两个是素数时打印“YES”否则打印“NO”。
<img src="https://yp.smallkun.cn/markdown/image-20241130011603125.png!compress" alt="image-20241130011603125" style="zoom:50%;" />
55.编写程序,按照 1,2, ... , 28 的顺序填一个7×7 数组的左上角,程序的输出结果为:
![image-20241130011618828](https://yp.smallkun.cn/markdown/image-20241130011618828.png!compress)
56.二维数组排序。设有4×5 的数组M,通过排序使M[1\][1\]≤M[1\][2\]≤...≤M[1\][5\]≤M[2\][1\]≤M[2\][2\]≤...≤M[2\][5\]≤...≤M[4\][1\]≤M[4\][2\]≤...≤M[4\][5\]。排序时不允许引入其它数组。
57.编写将一个十进制数M 转化成N 进制数(2≤N≤16)的程序。提示:转化成N 进制数的各位数可以分别放在数组的各个元素中。
注意:进制N 超过10 时, 用A 表示10,B 表示11,…,F 表示15。
58.在主函数中输入10 个不等长的字符串,用另一函数对它们排序。然后在主函数中输出这10 个已排好序的字符串,用指针数组完成。
59.建立一个链表,每个结点包括:学号、姓名、性别、年龄。输入一个年龄,如果链表中的结点所包含的年龄等于此年龄,将此结点删除,输出最后的链表。
60.有两个链表a和b。设结点中包含学号、姓名。从a链表中删除与b链表中有相同学号的那些结点。
@@ -0,0 +1,254 @@
1.输入一小写字母,分别以字符形式与数值形式输出与该小写字母相应的大写字母
```sql
//
#include<stdio.h>
int main(void)
{
char c;
scanf("%c",&c);
if(c>='a'&&c<='z')
printf("%c\n",c-32);
else
printf("%c\n",c+32);
return 0;
}
```
2.输入一个华氏温度,要求输出摄氏温度。公式为c=5/9*(f-32)
3.写一个程序,输入实数X,输出Y,计算
<img src="https://yp.smallkun.cn/markdown/image-20250116004443767.png!compress" alt="image-20250116004443767" style="zoom:33%;" />
4.编写程序:读入三个整数a,b,c,然后交换它们中的数,使a存放b的值,b存放c的值,c存放a的值。
5.编写程序:输入9时23分并把它化为分钟后输出。(从零点整开始计算)。
6.要将“Chiina”翻译成密码,密码规律是:用原来的字母后面第4个字母代替原来的字母。例如,字母“ A”后面的4个字母是“E”,用“E”代替“A”。因此,“Chian”应译成“Glmre”。用赋初值的方法 是c1,c2,c3,c4,c5五个变量的值分别为‘C’、‘h’、‘i’、‘n’、‘a’,经过运算,使c1、c2、 c3、c4、c5分别为‘G’、‘l’、‘m’、‘r’、‘e’,并输出
7.编写程序,用getchar函数读入两个字符c1,c2,然后分别用putchar函数和prinf函数输出这两个字符以 及它们的ASCII值。
8.设圆半径r=1.5,圆柱高h=3,求圆周长,圆面积,圆球表面积,圆球体积,圆柱体积
9.编写程序,输入两个整数 ,计算并输出它们的和、差、积、除(精确除)、整除及模的结果。
10.编一程序,对于一个给定的一个百分制成绩,输出相应的五分制成绩。设:90分以上为ˊAˊ,80~89 分为ˊBˊ,70~79分为ˊCˊ,60~69分为ˊDˊ,60分以下为ˊEˊ。
11.输入3个整数,要求按由小到大的顺序输出
12.输入4个数,输出其中的最大数和最小数。
13.有以函数y=x(x<1);2x-1(1<=x<10);3x-11(x>=10).写一程序,输入x,输出y.
14.给定一个不多于5的正整数,要求:(1)求它是几位数;(2)分别打印出每一位数字(3)按逆序打 印出各位数字.
15.编写程序,要求输入整数a和b.若a2+b2大于100,则输出a2+b2百位以上的数字,否则输出两数之和。
16.根据输入的三角形的三边判断是否能组成三角形,若可以则输出它的面积和三角形的类型
17.判断输入的正整数是否既是5又是7的整倍数。若是,则输出yes,否则输出no
18.输入4个整数,求4个数中的偶数之和.
19.输入4个整数,求4个数中的奇数之和
20.假设奖金税率如下(a代表奖金,r代表税率)a<500 r=0%;500<=a<1000 r=5%;1000<=a<2000 r=8%;2000<=a<3000 r=10%;3000<=a r=15%编写程序用if语句实现:对输入的一个资金数,求税率和应交税款以及实际奖金数(扣除奖金税后)。
21.输入一个字符,如果是大写字母,转换为小写,如果不是不转换。最后输出。
22.键盘上输入三角形三边a,b,c 的值,计算三角形面积,并输出三角形的三边a,b,c及面积area的值。三 角形面积的公式:s=(a+b+c)/2 area=sqrt[s(s-a)(s-b)(s-c)].
23.编写一个程序,根据用户输入的一个字母判定它是星期几。要求用switch语句实现程序控制,当第一个字母相同时,如:T(t)uesday 和T(t)hursday故需要进一步输入U或u或H或h确认。
24.编写一个程序:输入某年某月,判断这一月有多少天?
25.从键盘上输入字母或0~9的数字,编写程序对其进行分类。字母可分为大写字母和小写字母,数字可分 为奇数和偶数。
26.编写程序:加密数据,方法:对给定数值,每一位数字均加2,且在[0,9]范围内,若加密后某位数字 大于9,则取其被10除的余数.
27.编写程序:计算从1995年1月1日至2000年12月10日共有多少天。闰年的2月有29天.闰年满足如下条件 :能被400整除或能被4 整除但不能被100整除。
28.编程求解一元二次方程 ax2+bx+c=0的根。
29.有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?
31.已知abc+cba=1333,其中a、b、c均为一位数,编写一个程序求出a、b、c分别代表什么数字。
32.鸡兔共有30只,脚共有90只,编写一程序计算鸡兔各有多少只。
33.输入两个正整数m和n,求其最大公约数和最小公倍数.
34.输入一行字符,分别统计出其中英文字母、空格、数字和其它字符的个数。见87题
35.一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6=1+2+3.编程:找出1000以内的所 有完数。
36.猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩 下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再 吃时,见只剩下一个桃子了。求第一天共摘了多少.
37.有一分数序列:2/13/25/38/513/821/13...求出这个数列的前20项之和.
38.编写一个程序显示ASCII码65~90(十进制)的字符对照表。并输出6个数换一行。
39.已知xyz+yzz=532,其中x、y、z都是数字,编写一个程序求出x、y、z分别代表什么数字。
40.已知四位数a2b3能被23整除,编写一程序求此四位数。
41.输入n,计算s=1+1+2+1+2+3+1+2+3+4+...+1+2+3+4+...+n
42.从两个红球,三个白球,四个黑球中任意取出五个球,且其中必有白球,编写程序输出所有可能方案
43.花数”是指一个三位数,其各位数字立方和等于该数。
44.编写一程序:求1-3+5-7+…-99+101的值。
45.编写一程序:输入一个正偶数n,将其分解成两个素数之和。
46.编写程序,从键盘输入6名学生的5门成绩,分别统计出每个学生的平均成绩。
47.编程在屏幕上输出具有7行的正三角形。
48.若用0至9之间不同的三个数构成一个三位数,编写一个程序统计出共有多少种方法。
49.编程输出100—200之间第一个能被3整除的之前的所有整数。
50.把100—200之间的不能被3整除的整数输出。
51.求输入的10个整数中正数的个数以及其平均值。
52.求出1000以内的所有素数,要求一行输出30个。
53.有1020个西瓜,第一天卖一半多两个,以后每天卖剩下的一半多两个,问几天以后能卖完?。
54.4位反序数:设N是一个四位数,它的9倍恰好是其反序数,求N.
55.有限5位数:个位数为6且能被3整除的五位数共有多少?
56.编写一程序计算1到正整数n之间的奇数之和以及偶数之和。
57.编写一程序计算100到1000之间有多少个数其各位数字之和是5。
58.学校有近千名学生,在操场上排队,5人一行余2人,7人一行余3人,3人一行余1人,编写一程序求该 校的学生人数。
59.编写一程序实现从键盘输入10个数,找到第一个能被7整除的数。若,找到,打印此数后退出循环;若 未找到,打印“not exist”。
60.编写一程序:计算用一角、二角和五角凑成一元有多少种组合,并打印输出每种组合。
61.在数组a中按照顺序查找值为y的元素。若数组a中不存在该元素,则输出不存在;若存在这样的元素,则显示元素的下标,以及元素的总个数 见实验指导书P60必做题1。
62.数组中存放N个元素,编写程序删除掉下标为奇数的元素,使得数组中只存放下标为偶数的元素。.
63.数组s中存放有N个同学的某一门功课的成绩。要求编写程序,求出有多少个同学的成绩高于此门功课的平均分。
64.输入一个3行3列矩阵的所有元素,求该矩阵周边各元素的和。 见实验指导书P65必做题1。
65.判定一个字符串是否是回文串。(所谓回文串是指从开头读和从末尾读均为相同字符的字符串。例如:abcdcba。 见实验指导书P71必做题1。
66.读入一个字符串,要求将该字符中所有字符按照递增的顺序进行排序(采用冒泡排序算法)后输出。
67.编程将两个字符串连接起来,不准使用strcat函数。
68.有10个字符串,找出每个字符串中最大字符,并按顺序放入一维数组a[10]中,即第i个字符串中最大字符放入a[i]中,输出a[i]数组。
69.编程将任意十进制数转化成N进制。
70.设数组a中的元素均为正整数,编程求a数组中偶数的个数和偶数的平均值。
71.数组a包括10个整数,把a中所有的后项除以前项之商取整后存入数组b,并按每行3个元素的格式输出数组b.试编程。.
72.编程:从键盘输入一个字符串a,并在a串中的最大元素后边插入字符串b
73.输入一个正整数,按逆序输出各位的数字。
74.将二维数组行列元素互换,存到另一个数组中。
75.有一个3*4矩阵,求最大元素值及其行、列号。
76.有10个字符串,找出每个字符串中最大字符,依次存入一维字符数组a中,即第i个字符串中的最大字符放入a[i]中,输出数组a 同题68
77.设数组a中的元素均为正整数,编程求a数组中偶数的个数和偶数的平均值 同题70
78.编写一个程序,将字符数组s2中的全部字符拷贝到字符数组s1中。不得使用strcpy函数。拷贝时,‘\0‘也要拷贝过去。
79.将一个字符串中下标值为偶数的元素由小到大排序,其它元素不变。
80.使用二维数组打印杨辉三角形
81.从键盘输入一个二维整型数组,如a[4\][4\]={ 1,2,3,4,2,2,5,6,3,5,3,7,4,6,7,4},试编程检查一个二维数组是否对称(即对所有i,j都有a[i\][j\]=a[j\][i\])。
82.输入5个整数,找出最大数和最小数所在的位置,并把二者对调,然后输出调整后的5个数.
83.将字符串S中所有下标为奇数的位置上的字母大小写互换。
84.求矩阵a和b的和,结果存入矩阵c中并按矩阵形式输出。
85.有5个同学,每个同学有4门功课的考试成绩,求每人的平均成绩和每门功课的平均成绩。要求只用一个2维数组完成;
86. 编写一程序完成字符串处理函数(strcat字符串连接函数功能,不允许使用strcat函数实现),即连接两字符串a,b,将字符串b中字符连接到字符串a后成为一个字符串。(要求两字符串a,b 在主函数中输入,连接部分编写一函数完成,结果由主函数输出完成。)
87.编写函数统计字符串中字母、数字、空格和其他字符的个数。(要求在主函数中输入字符串以及输出上述结果,子函数完成统计功能。)
88.采用函数的方法实现“冒泡法”排序对输入的10个字符按从小到大的顺序进行排列。(要求在主函数中输入字符并输出排序结果。提示:字符从键盘接收到后放入数组中存放,数组名作为函数参数。)
89.编写一函数将一十进制数转换成2进制数并按顺序输出。(要求在主函数中输入此十进制数,由子函数进行转换并把结果传递给主函数。)
90.编写一程序实现:输入年、月、日,计算出该日是该年的第多少天。(要求在主函数中输入数据,计算过程由函数完成并将最后结果返回主函数输出。)
91.使用函数实现求n的阶乘。(主函数输入数据n,子函数求出阶乘的值并返回给主函数) 见实验指导书P80必做题第2题。
92.使用函数求两个整数的最大公约数和最小公倍数。(主函数输入两个数,子函数gongyue( )用来求最大公约数,子函数gongbei( )用来求最小公倍数) 见实验指导书P81选做题第1题。
93.使用函数求某长整型数据的各位数字之积。(主函数输入长整型数据,子函数func( )分离出各位数字,并将乘积返回给主函数) 见实验指导书P83选做题第3题。
94.使用函数求3名同学5门课的平均成绩。(主函数输入3名同学5门课的成绩,子函数计算出某名同学5门课的均分并返回给主函数)
95.使用函数实现字符串的颠倒存放操作。(主函数中使用字符串处理函数实现字符串的输入,子函数实现字符串的颠倒操作,使用字符串名作为函数参数。注意:应实现字符串的颠倒存放,而不是逆序输出)
96.子串删除。函数delete(s,i,n)实现从字符串s中删除下标为i的字符开始的n个字符。(主函数实现全局字符数组s和全局变量i、n的输入,并假设i 、n和i+n的值都小于字符串的
长度)
97.输入一字符串,如果该字符串中含有字符’s’,则返回该字符串的最后一个字符,否则输出“no”。(主函数输入一行字符,子函数getline( )的作用是判断是否含有’s’,返回最后一个字母或输出“no”。)
98.使用函数求解一元二次方程的根,方程的系数由主函数输入得到,并且设a、b均不等于0。
99.编写一程序完成字符串处理函数(strcpy字符串复制函数功能,不允许使用strcpy函数实现),即将字符串a的内容完整的复制到字符串b中(连同字符串a中’\0’也要复制)。(要求字符串a内容在主函数中输入,复制部分编写一函数完成,结果由主函数输出完成。)
100.编写一程序完成对于一个大于等于3的正整数,判断它是不是一个素数(要求数据由主函数输入,判断部分编写一函数实现,结果由主函数输出完成。)
101.编写一程序将一包含n个字符的字符串中从第m个字符开始的全部字符复制到另外一个字符串(n>m)。(要求数据由主函数输入,复制部分编写一函数实现,复制后结果由主函数输出完成。)
102.使用函数实现华氏温度向摄氏温度的转换,转换公式如下:C=(5/9)*(F-32),其中C为摄氏温度,F为华氏温度。(子函数实现温度转化,并将结果返回给主函数).见实验指导书P79必做题第1题。
103.写一个函数,求一个字符串的长度,在main函数中输入字符串,并输出其长度。.
104.用函数实现一些程序:计算10个学生的1门课程成绩的平均值.. 见实验指导书P85必做题第1题。
105.有15个数按由大到小顺序存放在一个数组int a={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}中,输入一个数用顺序查找法找出该数是数组中的第几个元素的值(元素下标值),若该数不在数组中则打印“无此数”。 (要求数据由主函数输入,查找部分编写一函数实现,结果由主函数输出完成。)
106.定义一个带参数的宏,完成从四个数中找出最大数的操作。
107.根据已知算法定义一个带参数的宏,用来判别程序中输入的年份是否闰年。
108.试定义一个带参数的宏swap(x,y),以实现两个整数之间的交换,并利用它将一维数组a和b的所有元素的值进行交换。
109.输入两个整数,求它们相除的余数.用带参数的宏来实现,编程序.
110.定义两个带参数的宏,一个用来求S(s=1/2(a+b+c)),另个用来求area(area为三角形的面积)。写程序,在程序中用带实参的宏名来求面积area。
111.已知字符串S中的内容为“Student!”,请用指针的方法将S中的内容逆序输出,且不能改变串中的内容。
112.输入一行文字,找出其中大写字母、小写字母、空格、数字以及其他字符个数。(要求用指针实现)。
113.通过指针操作,将输入的3个字符串,按由大到小的顺序输出。
114.定义整型数组a,有10个元素,用指针实现数组中的全部元素的输出.
115.编一程序,将字符串computer赋给一个字符数组,然后从第一个字母开始间隔地输出该串。请用指针完成。
116.利用指针编写一程序,将字符串中的第m个字符开始的全部字符复制成另一个字符串。要求在主函数中输入字符串及m的值并输出复制结果,在被调函数中完成复制。
117.用指针法实现:输入10个数,按由小到大的顺序输出。
118.用指针法实现:写一个函数,求一个字符串的长度。在main函数中输入字符串,并输出其长度值。
119.从键盘输入10个学生的成绩,显示其中的最高分、最低分和平均分。用指针实现。
120.数组中存放N个元素,编写程序删除掉下标为奇数的元素,使得数组中只存放下标为偶数的元素。用指针实现。
+20
View File
@@ -0,0 +1,20 @@
#include <stdio.h>
// !定义一些ANSI颜色代码
#define RESET "\033[0m"
#define BLACK "\033[30m" /* Black */
#define RED "\033[31m" /* Red */
#define GREEN "\033[32m" /* Green */
#define YELLOW "\033[33m" /* Yellow */
#define BLUE "\033[34m" /* Blue */
#define MAGENTA "\033[35m" /* Magenta */
#define CYAN "\033[36m" /* Cyan */
#define WHITE "\033[37m" /* White */
int main() {
// 使用颜色代码输出文本
printf(YELLOW "This is black text\n" RESET);
printf(RED "This is red text\n" RESET);
printf(GREEN "This is green text\n" RESET);
// ... 其他颜色输出
return 0;
}
+478
View File
@@ -0,0 +1,478 @@
1.输入一小写字母,分别以字符形式与数值形式输出与该小写字母相应的大写字母
2.输入一个华氏温度,要求输出摄氏温度。公式为c=5/9*(f-32)
3.写一个程序,输入实数X,输出Y,计算<img src="https://yp.smallkun.cn/markdown/image-20250116004443767.png!compress" alt="image-20250116004443767" style="zoom:33%;" />
4.编写程序:读入三个整数a,b,c,然后交换它们中的数,使a存放b的值,b存放c的值,c存放a的值。
5.编写程序:输入9时23分并把它化为分钟后输出。(从零点整开始计算)。
6.要将“Chiina”翻译成密码,密码规律是:用原来的字母后面第4个字母代替原来的字母。例如,字母“ A”后面的4个字母是“E”,用“E”代替“A”。因此,“Chian”应译成“Glmre”。用赋初值的方法 是c1,c2,c3,c4,c5五个变量的值分别为‘C’、‘h’、‘i’、‘n’、‘a’,经过运算,使c1、c2、 c3、c4、c5分别为‘G’、‘l’、‘m’、‘r’、‘e’,并输出
7.编写程序,用getchar函数读入两个字符c1,c2,然后分别用putchar函数和prinf函数输出这两个字符以 及它们的ASCII值。
8.设圆半径r=1.5,圆柱高h=3,求圆周长,圆面积,圆球表面积,圆球体积,圆柱体积
9.编写程序,输入两个整数 ,计算并输出它们的和、差、积、除(精确除)、整除及模的结果。
10.编一程序,对于一个给定的一个百分制成绩,输出相应的五分制成绩。设:90分以上为ˊAˊ,80~89 分为ˊBˊ,70~79分为ˊCˊ,60~69分为ˊDˊ,60分以下为ˊEˊ。
11.输入3个整数,要求按由小到大的顺序输出
12.输入4个数,输出其中的最大数和最小数。
13.有以函数y=x(x<1);2x-1(1<=x<10);3x-11(x>=10).写一程序,输入x,输出y.
14.给定一个不多于5的正整数,要求:(1)求它是几位数;(2)分别打印出每一位数字(3)按逆序打 印出各位数字.
15.编写程序,要求输入整数a和b.若a2+b2大于100,则输出a2+b2百位以上的数字,否则输出两数之和。
16.根据输入的三角形的三边判断是否能组成三角形,若可以则输出它的面积和三角形的类型
17.判断输入的正整数是否既是5又是7的整倍数。若是,则输出yes,否则输出no
18.输入4个整数,求4个数中的偶数之和.
19.输入4个整数,求4个数中的奇数之和
20.假设奖金税率如下(a代表奖金,r代表税率)a<500 r=0%;500<=a<1000 r=5%;1000<=a<2000 r=8%;
2000<=a<3000 r=10%;3000<=a r=15%编写程序用if语句实现:对输入的一个资金数,求税率和应交 税款以及实际奖金数(扣除奖金税后)。
21.输入一个字符,如果是大写字母,转换为小写,如果不是不转换。最后输出。
22.键盘上输入三角形三边a,b,c 的值,计算三角形面积,并输出三角形的三边a,b,c及面积area的值。三 角形面积的公式:s=(a+b+c)/2 area=sqrt[s(s-a)(s-b)(s-c)].
23.编写一个程序,根据用户输入的一个字母判定它是星期几。要求用switch语句实现程序控制,当第一个字母相同时,如:T(t)uesday 和T(t)hursday故需要进一步输入U或u或H或h确认。
24.编写一个程序:输入某年某月,判断这一月有多少天?
25.从键盘上输入字母或0~9的数字,编写程序对其进行分类。字母可分为大写字母和小写字母,数字可分 为奇数和偶数。
26.编写程序:加密数据,方法:对给定数值,每一位数字均加2,且在[0,9]范围内,若加密后某位数字 大于9,则取其被10除的余数.
27.编写程序:计算从1995年1月1日至2000年12月10日共有多少天。闰年的2月有29天.闰年满足如下条件 :能被400整除或能被4 整除但不能被100整除。
28.编程求解一元二次方程 ax2+bx+c=0的根。
29.有1、2、3、4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?
31.已知abc+cba=1333,其中a、b、c均为一位数,编写一个程序求出a、b、c分别代表什么数字。
32.鸡兔共有30只,脚共有90只,编写一程序计算鸡兔各有多少只。
33.输入两个正整数m和n,求其最大公约数和最小公倍数.
34.输入一行字符,分别统计出其中英文字母、空格、数字和其它字符的个数。见87题
35.一个数如果恰好等于它的因子之和,这个数就称为“完数”。例如6=1+2+3.编程:找出1000以内的所 有完数。
36.猴子吃桃问题:猴子第一天摘下若干个桃子,当即吃了一半,还不瘾,又多吃了一个第二天早上又将剩 下的桃子吃掉一半,又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再 吃时,见只剩下一个桃子了。求第一天共摘了多少.
37.有一分数序列:2/13/25/38/513/821/13...求出这个数列的前20项之和.
38.编写一个程序显示ASCII码65~90(十进制)的字符对照表。并输出6个数换一行。
39.已知xyz+yzz=532,其中x、y、z都是数字,编写一个程序求出x、y、z分别代表什么数字。
40.已知四位数a2b3能被23整除,编写一程序求此四位数。
41.输入n,计算s=1+1+2+1+2+3+1+2+3+4+...+1+2+3+4+...+n
42.从两个红球,三个白球,四个黑球中任意取出五个球,且其中必有白球,编写程序输出所有可能方案
43.花数”是指一个三位数,其各位数字立方和等于该数。
44.编写一程序:求1-3+5-7+…-99+101的值。
45.编写一程序:输入一个正偶数n,将其分解成两个素数之和。
46.编写程序,从键盘输入6名学生的5门成绩,分别统计出每个学生的平均成绩。
47.编程在屏幕上输出具有7行的正三角形。
48.若用0至9之间不同的三个数构成一个三位数,编写一个程序统计出共有多少种方法。
49.编程输出100—200之间第一个能被3整除的之前的所有整数。
50.把100—200之间的不能被3整除的整数输出。
51.求输入的10个整数中正数的个数以及其平均值。
52.求出1000以内的所有素数,要求一行输出30个。
53.有1020个西瓜,第一天卖一半多两个,以后每天卖剩下的一半多两个,问几天以后能卖完?。
54.4位反序数:设N是一个四位数,它的9倍恰好是其反序数,求N.
55.有限5位数:个位数为6且能被3整除的五位数共有多少?
56.编写一程序计算1到正整数n之间的奇数之和以及偶数之和。
57.编写一程序计算100到1000之间有多少个数其各位数字之和是5。
58.学校有近千名学生,在操场上排队,5人一行余2人,7人一行余3人,3人一行余1人,编写一程序求该 校的学生人数。
59.编写一程序实现从键盘输入10个数,找到第一个能被7整除的数。若,找到,打印此数后退出循环;若 未找到,打印“not exist”。
60.编写一程序:计算用一角、二角和五角凑成一元有多少种组合,并打印输出每种组合。
61.在数组a中按照顺序查找值为y的元素。若数组a中不存在该元素,则输出不存在;若存在这样的元素,则显示元素的下标,以及元素的总个数 见实验指导书P60必做题1。
62.数组中存放N个元素,编写程序删除掉下标为奇数的元素,使得数组中只存放下标为偶数的元素。.
63.数组s中存放有N个同学的某一门功课的成绩。要求编写程序,求出有多少个同学的成绩高于此门功课的平均分。
64.输入一个3行3列矩阵的所有元素,求该矩阵周边各元素的和。 见实验指导书P65必做题1。
65.判定一个字符串是否是回文串。(所谓回文串是指从开头读和从末尾读均为相同字符的字符串。例如:abcdcba。 见实验指导书P71必做题1。
66.读入一个字符串,要求将该字符中所有字符按照递增的顺序进行排序(采用冒泡排序算法)后输出。
67.编程将两个字符串连接起来,不准使用strcat函数。
68.有10个字符串,找出每个字符串中最大字符,并按顺序放入一维数组a[10]中,即第i个字符串中最大字符放入a[i]中,输出a[i]数组。
69.编程将任意十进制数转化成N进制。
70.设数组a中的元素均为正整数,编程求a数组中偶数的个数和偶数的平均值。
71.数组a包括10个整数,把a中所有的后项除以前项之商取整后存入数组b,并按每行3个元素的格式输出数组b.试编程。.
72.编程:从键盘输入一个字符串a,并在a串中的最大元素后边插入字符串b
73.输入一个正整数,按逆序输出各位的数字。
74.将二维数组行列元素互换,存到另一个数组中。
75.有一个3*4矩阵,求最大元素值及其行、列号。
76.有10个字符串,找出每个字符串中最大字符,依次存入一维字符数组a中,即第i个字符串中的最大字符放入a[i]中,输出数组a 同题68
77.设数组a中的元素均为正整数,编程求a数组中偶数的个数和偶数的平均值 同题70
78.编写一个程序,将字符数组s2中的全部字符拷贝到字符数组s1中。不得使用strcpy函数。拷贝时,‘\0‘也要拷贝过去。
79.将一个字符串中下标值为偶数的元素由小到大排序,其它元素不变。
80.使用二维数组打印杨辉三角形
81.从键盘输入一个二维整型数组,如a\[4\]\[4\]={ 1,2,3,4,2,2,5,6,3,5,3,7,4,6,7,4},试编程检查一个二维数组是否对称(即对所有i,j都有a\[i\]\[j\]=a\[j\]\[i\])。
82.输入5个整数,找出最大数和最小数所在的位置,并把二者对调,然后输出调整后的5个数.
83.将字符串S中所有下标为奇数的位置上的字母大小写互换。
84.求矩阵a和b的和,结果存入矩阵c中并按矩阵形式输出。
85.有5个同学,每个同学有4门功课的考试成绩,求每人的平均成绩和每门功课的平均成绩。要求只用一个2维数组完成;
86. 编写一程序完成字符串处理函数(strcat字符串连接函数功能,不允许使用strcat函数实现),即连接两字符串a,b,将字符串b中字符连接到字符串a后成为一个字符串。(要求两字符串a,b 在主函数中输入,连接部分编写一函数完成,结果由主函数输出完成。)
87.编写函数统计字符串中字母、数字、空格和其他字符的个数。(要求在主函数中输入字符串以及输出上述结果,子函数完成统计功能。)
88.采用函数的方法实现“冒泡法”排序对输入的10个字符按从小到大的顺序进行排列。(要求在主函数中输入字符并输出排序结果。提示:字符从键盘接收到后放入数组中存放,数组名作为函数参数。)
89.编写一函数将一十进制数转换成2进制数并按顺序输出。(要求在主函数中输入此十进制数,由子函数进行转换并把结果传递给主函数。)
90.编写一程序实现:输入年、月、日,计算出该日是该年的第多少天。(要求在主函数中输入数据,计算过程由函数完成并将最后结果返回主函数输出。)
91.使用函数实现求n的阶乘。(主函数输入数据n,子函数求出阶乘的值并返回给主函数) 见实验指导书P80必做题第2题。
92.使用函数求两个整数的最大公约数和最小公倍数。(主函数输入两个数,子函数gongyue( )用来求最大公约数,子函数gongbei( )用来求最小公倍数) 见实验指导书P81选做题第1题。
93.使用函数求某长整型数据的各位数字之积。(主函数输入长整型数据,子函数func( )分离出各位数字,并将乘积返回给主函数) 见实验指导书P83选做题第3题。
94.使用函数求3名同学5门课的平均成绩。(主函数输入3名同学5门课的成绩,子函数计算出某名同学5门课的均分并返回给主函数)
95.使用函数实现字符串的颠倒存放操作。(主函数中使用字符串处理函数实现字符串的输入,子函数实现字符串的颠倒操作,使用字符串名作为函数参数。注意:应实现字符串的颠倒存放,而不是逆序输出)
96.子串删除。函数delete(s,i,n)实现从字符串s中删除下标为i的字符开始的n个字符。(主函数实现全局字符数组s和全局变量i、n的输入,并假设i 、n和i+n的值都小于字符串的
长度)
97.输入一字符串,如果该字符串中含有字符’s’,则返回该字符串的最后一个字符,否则输出“no”。(主函数输入一行字符,子函数getline( )的作用是判断是否含有’s’,返回最后一个字母或输出“no”。)
98.使用函数求解一元二次方程的根,方程的系数由主函数输入得到,并且设a、b均不等于0。
99.编写一程序完成字符串处理函数(strcpy字符串复制函数功能,不允许使用strcpy函数实现),即将字符串a的内容完整的复制到字符串b中(连同字符串a中’\0’也要复制)。(要求字符串a内容在主函数中输入,复制部分编写一函数完成,结果由主函数输出完成。)
100.编写一程序完成对于一个大于等于3的正整数,判断它是不是一个素数(要求数据由主函数输入,判断部分编写一函数实现,结果由主函数输出完成。)
101.编写一程序将一包含n个字符的字符串中从第m个字符开始的全部字符复制到另外一个字符串(n>m)。(要求数据由主函数输入,复制部分编写一函数实现,复制后结果由主函数输出完成。)
102.使用函数实现华氏温度向摄氏温度的转换,转换公式如下:C=(5/9)*(F-32),其中C为摄氏温度,F为华氏温度。(子函数实现温度转化,并将结果返回给主函数).见实验指导书P79必做题第1题。
103.写一个函数,求一个字符串的长度,在main函数中输入字符串,并输出其长度。.
104.用函数实现一些程序:计算10个学生的1门课程成绩的平均值.. 见实验指导书P85必做题第1题。
105.有15个数按由大到小顺序存放在一个数组int a={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}中,输入一个数用顺序查找法找出该数是数组中的第几个元素的值(元素下标值),若该数不在数组中则打印“无此数”。 (要求数据由主函数输入,查找部分编写一函数实现,结果由主函数输出完成。)
106.定义一个带参数的宏,完成从四个数中找出最大数的操作。
107.根据已知算法定义一个带参数的宏,用来判别程序中输入的年份是否闰年。
108.试定义一个带参数的宏swap(x,y),以实现两个整数之间的交换,并利用它将一维数组a和b的所有元素的值进行交换。
109.输入两个整数,求它们相除的余数.用带参数的宏来实现,编程序.
110.定义两个带参数的宏,一个用来求S(s=1/2(a+b+c)),另个用来求area(area为三角形的面积)。写程序,在程序中用带实参的宏名来求面积area。
111.已知字符串S中的内容为“Student!”,请用指针的方法将S中的内容逆序输出,且不能改变串中的内容。
112.输入一行文字,找出其中大写字母、小写字母、空格、数字以及其他字符个数。(要求用指针实现)。
113.通过指针操作,将输入的3个字符串,按由大到小的顺序输出。
114.定义整型数组a,有10个元素,用指针实现数组中的全部元素的输出.
115.编一程序,将字符串computer赋给一个字符数组,然后从第一个字母开始间隔地输出该串。请用指针完成。
116.利用指针编写一程序,将字符串中的第m个字符开始的全部字符复制成另一个字符串。要求在主函数中输入字符串及m的值并输出复制结果,在被调函数中完成复制。
117.用指针法实现:输入10个数,按由小到大的顺序输出。
118.用指针法实现:写一个函数,求一个字符串的长度。在main函数中输入字符串,并输出其长度值。
119.从键盘输入10个学生的成绩,显示其中的最高分、最低分和平均分。用指针实现。
120.数组中存放N个元素,编写程序删除掉下标为奇数的元素,使得数组中只存放下标为偶数的元素。用指针实现。
+107
View File
@@ -0,0 +1,107 @@
```sql
/*
1-9题 40分
1-4 创建表、修改、添加、删除字段,记录插入、记录删除、记录更新
创建主键、外键、唯一约束
5.tj11 查询
6.tj12 查询
7.查询+视图
8.触发器
9.存储过程、存储函数
*/
#1-4
#(,)
CREATE TABLE (
[ZEROFILL] DEFAULT COMMENT ,
[ZEROFILL] DEFAULT COMMENT
);
#
DROP TABLE ;
#
TRUNCATE ;
#
ALTER TABLE MODIFY ;
#+
ALTER TABLE CHANGE ;
#
ALTER TABLE DROP ;
#
ALTER TABLE ADD ;
#
ALTER TABLE MODIFY PRIMARY KEY;
ALTER TABLE ADD CONSTRAINT PRIMARY KEY();
#()
ALTER TABLE MODIFY AUTO_INCREMENT;
#()
ALTER TABLE MODIFY PRIMARY KEY AUTO_INCREMENT;
#
ALTER TABLE AUTO_INCREMENT = ;
#
ALTER TABLE ALTER SET DEFAULT ;
#
ALTER TABLE ADD CONSTRAINT FOREIGN KEY() REFERENCES () [ON UPDATE CASCADE/SET NULL ON DELETE CASCADE/SET NULL]
#
ALTER TABLE MODIFY UNIQUE;
ALTER TABLE ADD CONSTRAINT UNIQUE();
#
INSERT INTO ()
VALUES(DEFAULT, , );
INSERT INTO ()
SET =, =, =;
#
UPDATE
SET =
WHERE ;
#
DELETE FROM
WHERE ;
#5-7
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY /(123)
LIMIT , #C语言数组一样 0
#
CREATE VIEW AS
;
#
ALTER VIEW AS
;
#
DROP VIEW ;
#8
DELIMITER $$
DROP TRIGGER IF EXISTS ;
CREATE TRIGGER
BEFORE/AFTER UPDATE/DELETE/INSERT ON
FOR EACH ROW
BEGIN
#BEGIN END
END $$
DELIMITER ;
#9
DELIMITER $$
DROP PROCEDURE IF EXISTS ;
CREATE PROCEDURE (IN/OUT , IN/OUT )
BEGIN
#BEGIN END
END $$
DELIMITER ;
DELIMITER $$
DROP FUNCTION IF EXISTS ;
CREATE FUNCTION ( , )
RETURNS
DETERMINISTIC/NOT DETERMINISTIC #
BEGIN
RETURN ;#
END $$
DELIMITER ;
```
+21
View File
@@ -0,0 +1,21 @@
```sql
#1.
ALTER TABLE t_student MODIFY sex ENUM('', '');
#2.
ALTER TABLE t_student ADD tel CHAR(20);
#3.
ALTER TABLE t_coach MODIFY salary INT(6) ZEROFILL;
#4.
INSERT INTO t_coach()
VALUES(DEFAULT, '赵欣彤', '', 25, 6000);
#5.
UPDATE t_class c
SET c.period = 18
WHERE c.id = 10005;
#6. tj11
#7. tj12
#8.
```
+246
View File
@@ -0,0 +1,246 @@
### C语言-1
```c
/*------------------------------------------------------------------------------
(1)【程序设计】定义一个大小为50的整型数组,将数字1~50存入该数组,利用指针将数组中的值输出,每行5个,每个数字占4个符号位,左对齐。
------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,*p,array[50];
for(i=0;i<50;i++)
{
array[i]=i+1;
}
p=array;
/**********Program**********/
//p 一级指针 可以指向整型的一维数组
for(i=0;i<50;i++){//0~49
printf("%-4d ", p[i]);
if((i+1)%5==0){
printf("\n");
}
}
/********** End **********/
}
```
### C语言-2
```c
/*----------------------------------------------------------------------
【程序设计】
------------------------------------------------------------------------
题目:要求实现一个函数,能够合并两个整数数组,合并后进行降序排序并删除重复元素。
示例1
输入输出如下所示:
请输入第一个数组的6个元素,每个元素之间用空格隔开:1 3 5 7 10 6
请输入第二个数组的6个元素,每个元素之间用空格隔开:10 4 2 6 11 30
合并后降序排列的数组:30 11 10 7 6 5 4 3 2 1
------------------------------------------------------------------------
注意:请勿改动程序中的其他内容。
----------------------------------------------------------------------*/
#include <stdio.h>
int* mergeArrays(int *arr1, int size1, int *arr2, int size2,int *newLen);
int main() {
int size1=6;
int size2=6;
int arr1[6];
int arr2[6];
int i;
int newLen = 0;
int* mergedArray;
printf("请输入第一个数组的6个元素,每个元素之间用空格隔开:");
for ( i = 0; i < size1; i++) {
scanf("%d", &arr1[i]);
}
printf("请输入第二个数组的6个元素,每个元素之间用空格隔开:");
for ( i = 0; i < size2; i++) {
scanf("%d", &arr2[i]);
}
mergedArray = mergeArrays(arr1, size1, arr2, size2, &newLen);
printf("合并后降序排列的数组:");
for (i = 0; i < newLen; i++) {
printf("%d ", mergedArray[i]);
}
printf("\n");
return 0;
}
int* mergeArrays(int *arr1,int size1,int *arr2,int size2,int *newLen) {
static int mergedArray[20];
/**********Program**********/
int i, j=0, temp;
//合并数组
for(i=0;i<size1;i++){
mergedArray[j++] = arr1[i];
mergedArray[j++] = arr2[i];
}
//降序排序
for(i=0;i<size1*2-1;i++){//已经有序的个数
for(j=0;j<size1*2-i-1;j++){//i每+1 代表最前面已经有一个最小的元素
if(mergedArray[j] < mergedArray[j+1]){ //无序的元素两两比较小值后移
temp = mergedArray[j];
mergedArray[j] = mergedArray[j+1];
mergedArray[j+1] = temp;
}
}
}
//去重
/*
默认第一个数字不用判断,从数组中第二个元素开始判断,
是否等于前一项如果不等于则进行赋值操作,然后元素个数加一
*/
*newLen = 1;//当前数组中已经过滤后的有效数字个数
for(i=1;i<size1*2;i++){//使用i变量从1下标元素开始 遍历数组中的所有数字
if(mergedArray[(*newLen) - 1] != mergedArray[i]){
//如果当前判断的元素不等于前一个元素则插入到有效数字位置
mergedArray[(*newLen)++] = mergedArray[i];
}
}
/********** End **********/
return mergedArray;
}
```
### MySQL-1
```sql
#1. +
ALTER TABLE t_user MODIFY uid INT(11) PRIMARY KEY AUTO_INCREMENT;
#
ALTER TABLE t_user ADD PRIMARY KEY(uid);
#2.
#DEFAULT //NULL
INSERT INTO t_user()
VALUES(DEFAULT, 'mike', 'mm123', '小明', DEFAULT);
#3.
UPDATE t_user u
SET u.`password` = '888888'
WHERE u.username = 'Dennis';
#4. tj11 +
SELECT u.nickname, c.mid, c.score, c.content
FROM t_user u, t_comment c
WHERE u.uid = c.uid AND u.nickname = '白色';
#5. tj12 +
SELECT m.mname, ROUND(AVG(c.score), 2)
FROM t_movie m, t_comment c
WHERE m.mid = c.mid
GROUP BY m.mid;
#6. tj13 +
SELECT m.mname, COUNT(*)
FROM t_movie m, t_comment c
WHERE m.mid = c.mid
GROUP BY m.mid;
#7
CREATE VIEW v_movie AS
SELECT m.mname, u.nickname, c.score, c.content
FROM t_user u, t_movie m , t_comment c
WHERE u.uid = c.uid AND m.mid = c.mid;
#8
DELIMITER $$
DROP PROCEDURE IF EXISTS pro_getUserNumber;
CREATE PROCEDURE pro_getUserNumber(IN in_uid INT, OUT out_number INT)
BEGIN
SET out_number = (
SELECT COUNT(*)
FROM t_user u, t_comment c
WHERE u.uid = c.uid AND u.uid = in_uid
);
END $$
DELIMITER ;
#9
DELIMITER $$
DROP TRIGGER IF EXISTS tri_userlog;
CREATE TRIGGER tri_userlog
AFTER INSERT ON t_user
FOR EACH ROW
BEGIN
INSERT INTO t_log()
VALUES(DEFAULT, NEW.uid, '新增用户', '2024-01-01');
END $$
DELIMITER ;
```
### MySQL-2
```sql
#1
ALTER TABLE t_examinee MODIFY sex CHAR(2);
DESC t_examinee;#
#2
INSERT INTO t_room()
VALUES(DEFAULT, '202教室', '2号教学楼');
#3
DELETE FROM t_teacher
WHERE rid IS NULL;
#4
UPDATE t_examinee
SET tel = '1396668888'
WHERE ename = '龚致远';
#5 tj11 +
SELECT e.ename, r.rname, r.site
FROM t_examinee e, t_room r
WHERE e.rid = r.rid AND e.ename = '陶宇宁';
#6 tj12
SELECT r.rname, r.site, t.tname, t.tel
FROM t_teacher t, t_room r
WHERE t.rid = r.rid AND r.rname = '402教室';
#7
CREATE VIEW v_exam AS
SELECT e.ename, e.sex, e.tel, e.examnum, r.rname, r.site
FROM t_examinee e, t_room r
WHERE e.rid = r.rid;
#8
DELIMITER $$
DROP PROCEDURE IF EXISTS pro_getExamNumber;
CREATE PROCEDURE pro_getExamNumber(IN in_rid INT, OUT out_number INT)
BEGIN
SELECT COUNT(*) INTO out_number
FROM t_examinee e
WHERE e.rid = in_rid;
END $$
DELIMITER ;
#9
DELIMITER $$
DROP TRIGGER IF EXISTS tri_examlog;
CREATE TRIGGER tri_examlog
BEFORE INSERT ON t_examinee
FOR EACH ROW
BEGIN
INSERT INTO t_log()
VALUES(DEFAULT, NEW.eid, '新增考生', '2024-01-01');
END $$
DELIMITER ;
```
+346
View File
@@ -0,0 +1,346 @@
### C语言-1
```c
/*------------------------------------------------------------------------------
【程序设计】输入一个1000以内的三位数,找出小于这个三位数且个位数字与十位数字之和
除以10所得的余数等于百位数字的数,并输出满足条件的数字之和。
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdio.h>
int main()
{
int a,b,c,d,i,j,sum=0;
scanf("%d",&j);
/**********Program**********/
for(i=100;i<j;i++){
a = i%10;//个位
b = i%100/10;//十位
c = i/100;//百位
d = (a+b)%10;//个位+十位 取模
if(c == d){
sum += i;
}
}
/********** End **********/
printf("%d\n",sum);
}
```
### C语言-2
```c
/*------------------------------------------------------------------------------
【程序设计】任意一个大于0的正整数,都可以写成若干个2的正整数次幂的和的形式。
例如:7=2^2+2^1+2^0
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<ctype.h>
#include<stdlib.h>
#define N 4
void binary_power(unsigned int x)
{
int flag =1;
unsigned int s,t,y;
printf("%u=",x);
/**********Program**********/
t = 1;
y = 0;
//二进制的权位值 2^2 2^1 2^0
//从末尾开始一直乘 乘到 大于传入的x就停止 同时记录下次方数
while(t <= x){
t*=2;
y++;
}
y--;//2^y 会正好大于x
printf("2^%d", y);//最高位
x -= (int)pow(2, y);//求2的y次方 同时对x进行减法运算
y--;
while(x > 0){
t = 1;
s = (int)pow(2, y);
if(x >= s){//当前权位值没有大于需要运算的数据
x -= s;
printf("+2^%d", y);
}
y--;
}
/********** End **********/
printf("\n");
}
int main()
{
unsigned int n[N]={1,15,32,144};
int i;
for(i=0;i<N;++i)
binary_power(n[i]);
return 0;
}
```
### C语言-3
```c
/*------------------------------------------------------------------------------
【程序设计】从键盘接收3个无序的整数,将这3个数据都插入到升序排列的数组中,并保持数组仍然有序。
输入输出如下:
4 6 9 12 15 18 23 26 32 39
1 5 6
1 4 5 6 6 9 12 15 18 23 26 32 39
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdio.h>
#define N 10
void main( )
{
int a[N+5]={4,6,9,12,15,18,23,26,32,39},p,x,i,j;
for(i=0;i<N;i++){
printf("%d ",a[i]);
}
printf("\n");
/**********Program**********/
for(i=N;i<N+3;i++){
scanf("%d", a+i);
}
for(i=0;i<N+3-1;i++){
for(j=0;j<N+3-1-i;j++){
if(a[j] > a[j+1]){
x = a[j];
a[j] = a[j+1];
a[j+1] = x;
}
}
}
/********** End **********/
for(i=0;i<N+3;i++){
printf("%d ",a[i]);
}
printf("\n");
}
```
### C语言-4
```c
/*------------------------------------------------------------------------------
【程序设计】输入一个小于等于10000的整数n,在[100,n]之间打印出各位数字和为5的所有整数的个数.
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdio.h>
void main()
{
int a,b,c,d,k,i,n;
k=0;
scanf("%d",&n);
/**********Program**********/
for(i=100;i<=n;i++){
a = i;//备份一遍i的数据
d = 0;
while(a){
d += (a%10);
a /= 10;
}
if(d == 5){
k++;
}
}
/********** End **********/
printf("%d\n",k);
}
```
### C语言-5
```c
/*------------------------------------------------------------------------------
【程序设计】编写函数rtrim,用来删除字符串尾部的空格,首部和中间的空格不删除。例如:字符串为:" A BC DEF "
删除后的结果是" A BC DEF"。要求函数形参采用指针变量。
测试输入: A BC DEF
测试输出: A BC DEF
说明:测试输入中,A前有4个空格,F后有5个空格
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void main()
{
void rtrim(char *p);
char s[100];
gets(s);
rtrim(s);
puts(s);
}
void rtrim(char *p)
{
int i;
/**********Program**********/
i=0;
while(*(p+i) != '\0'){
i++;
}
while(*(p+i-1) == ' '){
*(p+i-1) = '\0';
i--;
}
/********** End **********/
}
```
### C语言-6
```c
/*------------------------------------------------------------------------------
【程序设计】定义一个函数实现字符串的逆序存放(连续的字符串,中间不包含空格),要求用指针实现。
在主函数中调用函数实现字符串逆序存放。运行程序,输入字符串,输出逆序后的字符串。
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdlib.h>
#include<stdio.h>
void reversed_str(char *str){
char *p=str,*q=str;
int temp;
while(*q!='\0'){
q++;
}
q--;
/**********Program**********/
while(p < q){
temp = *p;
*p = *q;
*q = temp;
p++;
q--;
}
/********** End **********/
}
int main(){
char s[50];
printf("输入字符串:");
scanf("%s",s);
printf("逆序前:%s\n",s);
reversed_str(s);
printf("逆序后:%s\n",s);
return 0;
}
```
### C语言-7
```c
/*------------------------------------------------------------------------------
【程序设计】从键盘输入一位整数i,计算其各位数字之和。
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include<stdio.h>
#include <stdlib.h>
int main(){
int i,sum=0,a;
scanf("%d",&i);
/**********Program**********/
while(i){
sum += i%10;
i/=10;
}
/********** End **********/
printf("%d\n",sum);
return 0;
}
```
### C语言-8
```c
/*------------------------------------------------------------------------------
【程序设计】编写函数,判断一个字符串是否是回文。在主函数中输入一个字符串,调用自定义函数,输出结果。
所谓回文是指顺读和倒读都一样的字符串。如"XZYKYZX"是回文。
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,否则不得分。
仅在Program-End之间填入若干语句。不要删除标志否则不得分。
------------------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
void main()
{
char s[50];
int hw(char *s);
gets(s);
if(hw(s))
printf("是回文!\n");
else
printf("不是回文!\n");
}
int hw(char *s)
{
int flag=1;
char *p,*q;
/**********Program**********/
p = s;//指向字符串首元素
q = s+strlen(s)-1;//指向末尾元素
while(p < q){
if(*p != *q){
flag = 0;
break;
}
p++;
q--;
}
return flag;
/********** End **********/
}
```
+297
View File
@@ -0,0 +1,297 @@
### 贪吃蛇
```c
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <time.h>
#include <process.h>
#define WIDTH 50 //宽度
#define HEIGHT 30 //高度
#define SNAKE_LENGHT 100 //蛇的最大长度
#define UP 1
#define DOWN 2
#define LEFT 3
#define RGIHT 4
char map[HEIGHT][WIDTH];//地图字符数组
int sankeX[SNAKE_LENGHT], sankeY[SNAKE_LENGHT];//蛇的坐标
int foodX, foodY;//食物的坐标
int size = 1;//当前蛇的长度
int gameStatus = 1;
int direction = RGIHT;
/*
_kbhit()用来判断输入的是否是空格
_getch()用来判断键盘输入的内容
*/
void draw(void* param){
int i, j;
char buffer[(HEIGHT+1)*(WIDTH+1)];
int k;
while(gameStatus){
system("cls");
k=0;
for(i=0;i<HEIGHT;i++){
for(j=0;j<WIDTH;j++){
buffer[k++] = map[i][j];
}
buffer[k++] = '\n';
}
buffer[k] = '\0';
printf("%s\n", buffer);
Sleep(200);
}
}
//打印地图
void changeMap(void* param){
int i, j, k;
int isFill;
while(gameStatus){
for(i=0;i<HEIGHT;i++){
for(j=0;j<WIDTH;j++){
if(i==0 || i == HEIGHT-1 || j==0 || j == WIDTH - 1){
map[i][j] = '#';
}else if(i == foodY && j == foodX){
map[i][j] = '$';
}else if(i == sankeY[0] && j == sankeX[0]){
map[i][j] = '0';
}else{
isFill = 0;
for(k=1;k<size;k++){
if(i == sankeY[k] && j == sankeX[k]){
map[i][j] = 'o';
isFill = 1;
}
}
if(!isFill){
map[i][j] = ' ';
}
}
}
}
}
}
void changeSnake(void* param){
//蛇的移动
while(gameStatus){
int sankeXpre = sankeX[0], sankeYpre=sankeY[0];
int sankeXpre2, sankeYpre2;
int i;
Sleep(400-size*2);
sankeX[0] += (direction == RGIHT)?1:(direction == LEFT)?-1:0;
sankeY[0] += (direction == DOWN)?1:(direction == UP)?-1:0;
for(i=1;i<size;i++){
sankeXpre2 = sankeX[i];
sankeYpre2 = sankeY[i];
sankeX[i] = sankeXpre;
sankeY[i] = sankeYpre;
sankeXpre = sankeXpre2;
sankeYpre = sankeYpre2;
}
//判断蛇是否吃到食物
if(sankeX[0] == foodX && sankeY[0] == foodY){
size++;
foodX = rand()%(WIDTH-5)+3;
foodY = rand()%(HEIGHT-5)+3;
}
//边界检测、以及是否撞到自己
for(i=1;i<size;i++){
if(sankeX[0] == sankeX[i] && sankeY[0] == sankeY[i]){
gameStatus = 0;
}
}
if(sankeX[0] == 0 || sankeX[0] == WIDTH || sankeY[0]==0 || sankeY[0] == HEIGHT){
gameStatus = 0;
}
}
}
void input(void* param){
char key;
while(gameStatus){
if(_kbhit()){
key = _getch();
switch(key){
case 'w':direction=UP;break;
case 's':direction=DOWN;break;
case 'a':direction=LEFT;break;
case 'd':direction=RGIHT;break;
case 'q':gameStatus=0;break;
}
}
}
}
int main() {
system("color 02");
srand((unsigned)time(NULL));
sankeX[0] = WIDTH/2;
sankeY[0] = HEIGHT/2;
foodX = rand()%(WIDTH-5)+3;
foodY = rand()%(HEIGHT-5)+3;
_beginthread(changeMap, 0, NULL);
_beginthread(draw, 0, NULL);
_beginthread(input, 0, NULL);
_beginthread(changeSnake, 0, NULL);
while(gameStatus){
}
printf("游戏结束您的得分是%d\n", size-1);
return 0;
}
```
<img src="https://yp.smallkun.cn/markdown/image-20250104225941821.png!compress" alt="image-20250104225941821" style="zoom:50%;" />
<img src="https://yp.smallkun.cn/markdown/image-20250104225957306.png!compress" alt="image-20250104225957306" style="zoom:50%;" />
### 飞机大战
```c
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <process.h>
#include <Windows.h>
#define HEIGHT 40
#define WIDTH 30
char map[HEIGHT][WIDTH];
int score = 0;
int gameStatus = 1;
int planeX = 12;
int planeY = 36;
#define bulletNum 1000
int bulletX[bulletNum];
int bulletY[bulletNum];
int bulletRear = 0;//最后的子弹
int bulletFront = 0;//最前面的子弹
char* plane[6] = {" * ", "*****", " * * "};
void changeMap(void* param){
int i, j;
while(gameStatus){
for(i=0;i<HEIGHT;i++){
for(j=0;j<WIDTH;j++){
if(i == HEIGHT-1){
map[i][j] = '~';
}else if(j == 0 || j == WIDTH-1){
map[i][j] = '|';
}else{
map[i][j] = ' ';
}
}
}
for(i = 0;i<3;i++){
for(j = 0;j<5;j++){
map[planeY+i][planeX+j] = plane[i][j];
}
}
i=bulletFront;
while(i!=bulletRear){
map[bulletY[i]][bulletX[i]] = '*';
i=(i+1)%bulletNum;
}
Sleep(100);
}
}
void darwMap(void* param){
int i, j, k;
char buffer[100000];
while(gameStatus){
k=0;
for(i=0;i<HEIGHT;i++){
for(j=0;j<WIDTH;j++){
buffer[k++] = map[i][j];
}
buffer[k++] = '\n';
}
buffer[k] = '\0';
system("cls");
printf(buffer);
printf("您的得分:%d\n", score);
printf("操作说明:WSAD分别对印前后左右移动\n**空格是发出子弹**\n");
}
}
void changeBullets(void* param){
int i;
while(gameStatus){
Sleep(500);
i=bulletFront;
while(i!=bulletRear){
bulletY[i]--;
if(bulletY[i] < 0){
bulletFront=(bulletFront+1)%bulletNum;
}
i=(i+1)%bulletNum;
}
}
}
void shootBullets(){
// planeY+1
bulletX[bulletRear] = planeX+2;
bulletY[bulletRear++] = planeY-1;
}
void input(void* param){
char key;
while(gameStatus){
if(_kbhit()){
key = _getch();
switch(key){
case 'q':gameStatus = 0;break;
case 'w':planeY--;break;
case 's':planeY++;break;
case 'a':planeX--;break;
case 'd':planeX++;break;
case 32:shootBullets();break;
}
}
}
}
int main(void){
system("color 02");
_beginthread(changeMap, 0, NULL);
_beginthread(darwMap, 0, NULL);
_beginthread(input, 0, NULL);
_beginthread(changeBullets, 0, NULL);
while(gameStatus){
}
return 0;
}
```
<img src="https://yp.smallkun.cn/markdown/image-20250105004011680.png!compress" alt="image-20250105004011680" style="zoom:50%;" />
+67
View File
@@ -0,0 +1,67 @@
### 标准输入输出
```c
#include <stdio.h>
/*
scanf 格式化输入
printf 格式化输出
getchar 读取单个字符
putchar 输出单个字符
gets 读取一行字符串 空格也会读入
puts 输出字符串(会自带一个换行)
*/
int main(){
char str[100];
/*
scanf("%s", str);//占位符遇到空格结束
*/
gets(str);//读取一行字符串
printf("%s\n", str);
return 0;
}
```
### 字符串处理
```c
#include <stdio.h>
#include <string.h>
/*
strlen 返回当前字符串长度 以结束符为标记
strcpy(目标串, 需要复制的串) 复制字符串
strncpy(目标串, 需要复制的串) 复制指定长度的字符串
strcat(字符串1, 字符串2) 拼接两个字符串,相当于在字符串1后加上字符串2后返回字符串1的首地址
strncat(字符串1, 字符串2) 拼接指定长度字符串(字符串2的长度)
*/
int main(void){
/*
烫烫烫:未初始化的字符数组打印出来
屯屯屯:未初始化的堆空间(C++)
锟斤拷:将GBK字符编码的文字转换为UTF-8后再转换成GBK
*/
char *str = "HelloWolrd";//指向一个字符串常量的首地址
char str2[20];
char str3[20];
char *str4;
char str5[20] = "";
strcpy(str2, str);//将字符串str的数据复制到str2这个字符数组中
strncpy(str3, str, 5);//复制str中的前5个字符到str3中
str3[5] = '\0';//设置结束标记
puts(str2);//会一直打印字符直到遇到字符串结束标记
puts(str3);
str4 = strcat(str2, str3);//str4相当于指向str2的首地址
puts(str2);//打印str2字符数组
puts(str4);//str4是一个字符串指针 指向str2的首个元素
strncat(str5, str3, 3);//将str5和str3中的三个字符拼接起来并存储在str5中
puts(str5);//打印str5
return 0;
}
```
+111
View File
@@ -0,0 +1,111 @@
```c
/*
这段代码实现的是经典的 汉诺塔问题 的递归解法。
汉诺塔问题 是一个数学问题,具体描述如下:
给定三个柱子:A、B、C
有若干个大小不等的圆盘(通常为n个),初始时所有圆盘都堆叠在A柱子上,从小到大按顺序叠放;
目标是将这些圆盘从A柱子移动到C柱子上,并且每次只能移动一个圆盘,且大的圆盘不能放在小的圆盘上面。
在这段代码中,hanoi 函数递归地解决了这个问题,参数 n 表示要移动的圆盘数,x、y、z 分别表示源柱子、辅助柱子和目标柱子。
代码详解:
基本思路:
如果只有一个盘子(n == 1),直接从 x 移动到 z。
如果有多个盘子(n > 1),可以通过以下步骤完成: 先将前 n-1 个盘子从 x 移到 y,这时 z 作为辅助柱子。
将第 n 个盘子从 x 移动到 z。
最后将 n-1 个盘子从 y 移到 z,这时 x 作为辅助柱子。
函数 hanoi 的参数:
n:表示要移动的圆盘的数量。
x:源柱子。
y:辅助柱子。
z:目标柱子。
递归过程:
对于每个递归调用,问题规模逐渐减小,最终会到达只有一个盘子的情况(基准条件)。
程序输出:
A -> C
A -> B
C -> B
这个输出表示了将两个圆盘从A柱子移动到C柱子所需的步骤。输出结果每一行表示一个移动的操作。
总结:
这段代码是解决汉诺塔问题的经典递归解法。通过分而治之的策略,把问题分解为更小的子问题来求解。
*/
```
### 函数递归打印汉诺塔移动步骤
```c
#include <stdio.h>
/*
n:盘片数
x:源柱子
y:中间柱子
z:目标柱子
判断盘子个数:
如果只有一个盘子,那么直接搬到目标柱子
否则先将上面的n-1的盘子通过目标柱子移
动到非目标柱子上后再将剩下的最大的盘子移动到目标柱子
*/
//n的盘子从x通过y移动到z
void hanoi(int n, char x, char y, char z){
if(n == 1){
printf("%c -> %c\n", x, z);
}else{
hanoi(n-1, x, z, y);
printf("%c -> %c\n", x, z);
hanoi(n-1, y, x, z);
}
}
int main(void){
hanoi(3, 'A', 'B', 'C');
return 0;
}
```
### 函数递归求汉诺塔移动的次数
```c
#include <stdio.h>
/*
n:盘片数
x:源柱子
y:中间柱子
z:目标柱子
判断盘子个数:
如果只有一个盘子,那么直接搬到目标柱子
否则先将上面的n-1的盘子通过目标柱子移
动到非目标柱子上后再将剩下的最大的盘子移动到目标柱子
*/
//n的盘子从x通过y移动到z
//int count = 0;//移动盘片的次数
//而不是只经过B柱子的次数
int hanoi(int n, char x, char y, char z){
int count = 0;//局部变量 用来存储当前这次函数调用中的移动盘子的次数
if(n == 1){
//printf("%c -> %c\n", x, z);
count++;
}else{
count += hanoi(n-1, x, z, y);
//printf("%c -> %c\n", x, z);
count++;
count += hanoi(n-1, y, x, z);
}
return count;
}
int main(void){
printf("%d\n", hanoi(3, 'A', 'B', 'C'));
return 0;
}
```
+107
View File
@@ -0,0 +1,107 @@
### 写法1-暴力写法 使用数组来模拟队列
```c
#include <stdio.h>
/*
约瑟夫环,人数n,编号m
队列 先进先出
a 3 1 2
头 下标
尾 下标
*/
//rear尾巴 front头
int queue[200] = {0};
int rear=0, front=0;
//用来拿到队列最前面的元素值
int get(){
int temp = queue[front];
queue[front++] = 0;
return temp;
}
//用来在队列末尾差值
void put(int n){
queue[rear++] = n;
}
//打印队列当前状态
void print(){
int i;
for(i=0;i<200;i++){
if(queue[i] != 0){
printf("%d ", queue[i]);
}
}
printf("\n");
}
//判断队列是否为空
int isEmpty(){
int count = 0;
int i;
for(i=0;i<200;i++){
if(queue[i] != 0){
count++;
}
}
return count;
}
int main(){
int n, m;//n人数 m为弹出的编号
int i, count = 0;
scanf("%d %d", &n, &m);
for(i=1;i<=n;i++){
put(i);
}
print();
while(isEmpty()){
count++;
if(count % m == 0){
printf("%d ", get());
}else{
put(get());
}
}
return 0;
}
```
### 写法2-循环队列 使用数组模拟循环队列
```c
#include <stdio.h>
/*
使用数组模拟循环队列
*/
int main(){
int joseph[100] = {0};
int n, m, count = 0;//n:人数 m:编号数 count:已出局的人数
int i = 1, k = 0;//i:用来遍历数组 k用来记录已经报数的编号
printf("请输入人数以及编号数:");
scanf("%d %d", &n, &m);
for(i = 0; i < n;i++){
joseph[i] = i+1;//标记为1 则为非空代表当前下标编号有人
}
i = 0;
while(n > count){
if(joseph[i]){
k++;//报数
if(k%m == 0){//判断是否弹出
printf("%d ", joseph[i]);
joseph[i] = 0;//标记为0 代表当前下标的人已经弹出
count ++;
}
}
i = (i+1)%n;
}
printf("\n");
return 0;
}
```
+156
View File
@@ -0,0 +1,156 @@
### 顺序表
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <Windows.h>
/*
顺序表 连续存储的动态数组
链表 分散存储的动态数组
栈 后进先出的数组
队列 先进先出的数组
*/
//顺序表
typedef struct List{
int *arr;//用来存储数据首地址
int size;//用来存储当前已经插入的元素个数
int capacity;//用来存储最大的容量
}List;
//函数声明
//对顺序表进行初始化
void init(List *list, int n){
//对List结构体中arr指针变量 指向一块动态内存分配的地址
list->arr = (int *)malloc(sizeof(int)*n);
//malloc 用来分配指定大小的内存空间并返回 void*类型的首地址
list->size = 0;//设置当前元素个数为0
list->capacity = n;//设置当前数组容量为n
memset(list->arr, 0, sizeof(int)*n);
//memset对指定内存空间 设置初始值为0
}
//传入list结构体指针 并对其中
void enlargeList(List *list){
//对数组元素进行扩容 数组起始地址 扩大后的内存大小
list->arr = (int *)realloc(list->arr, sizeof(int)*list->capacity*2);
//对扩容后的空间进行初始化赋值给0
memset(list->arr + list->capacity, 0, list->capacity*sizeof(int));
//容量扩大一倍
list->capacity *= 2;
}
//在顺序表最后面插值
void add(List *list, int num){
//对数组最后一个位置进行赋值
//当前数组元素个数应小于当前容量
if(list->size == list->capacity){
enlargeList(list);
}
*(list->arr + list->size) = num;
list->size++;//元素个数加一
}
//遍历数组中元素并打印
void traverse(List *list){
int i;
for(i=0;i<list->size;i++){
printf("%2d ", *(list->arr + i));
if((i+1)%10==0){
printf("\n",(i+1));
//Sleep(1000);
}
}
printf("\n");
}
int getRandNum(int startNum, int endNum){
return rand()%(endNum - startNum) + startNum;
//计算出start~end之间的随机整数并包括start和end
}
//在指定位置插值
void addByIndex(List *list, int num, int n){
int i;
if(list->size == list->capacity){
enlargeList(list);
}
//将这个位置-1开始的所有元素整体往后挪动一个位置
for(i=list->size-1;i>=n-1;i--){
*(list->arr+i+1) = *(list->arr+i);
}
*(list->arr+n-1) = num;
list->size++;//元素个数+1
}
//删除指定位置元素并返回该元素
int deleteByIndex(List *list, int n){
int i;
//从删除位置n-1开始 元素整体前移,覆盖掉n-1位置需要删除的元素
for(i=n-1;i<list->size-1;i++){
*(list->arr + i) = *(list->arr + i + 1);
}
*(list->arr + list->size - 1) = 0;
list->size--;
}
//判断顺序表是否为空
//size为0则返回1 代表数组是空的
int isEmpty(List *list){
return list->size?0:1;
}
//判断顺序表是否已满
//size==capacity 为真
int isFull(List *list){
return list->size == list->capacity?1:0;
}
//获取顺序表中的元素个数
int size(List *list){
return list->size;
}
//对顺序表中元素进行升序排序
void sort(List *list){
int i, j, temp;
for(i=0;i<list->size-1;i++){
for(j=0;j<list->size-1-i;j++){
if(list->arr[j] > list->arr[j+1]){
temp = list->arr[j];
list->arr[j] = list->arr[j+1];
list->arr[j+1] = temp;
}
}
}
}
int main(void){
List list;//定义结构体变量
List *p = &list;
int i;
system("color f4");
srand((unsigned)time(NULL));//以当前时间为随机数种子
init(p, 1);//顺序表的初始化
add(p, 1);
add(p, 2);
add(p, 3);
addByIndex(p, 66, 2);
addByIndex(p, 100, 1);
deleteByIndex(p, 3);
sort(p);
traverse(p);
return 0;
}
```
+199
View File
@@ -0,0 +1,199 @@
创建一个空数据库名字为`book_store_db`,字符集使用UTF8
## 创建表
目的:
1)熟练掌握创建表结构的方法。
2)掌握查看表信息的方法。
内容:
(1)使用 MySQL 创建会员表(如表 3-9 所示)、图书表(如表 3-10 所示)的表结构。
(2)使用 MySQL 创建图书类别表(如表 3-11 所示)、订购表(如表 3-12 所示)的表结构。
3)使用 DROP TABLE 语句删除上述创建的表,然后使用 CREATE TABLE 语句再次创建上述表。
4)查看会员表的信息。
(5)修改会员表结构。添加字段「联系地址」,数据类型设置为 VARCHAR(50);更改「联系地址」为「联系方式」;删除添加的字段「联系地址」。
(6)使用创建表时添加约束和为已存在的表添加约束这两种方式给表添加约束。
表 3-9 会员表(user)结构
![48910-00-93-1](https://yp.smallkun.cn/markdown/v2-1f98e1d0f99c7b562479e8a54e940cf1_r.jpg!compress)
表 3-10 图书表(book)结构
![48910-00-93-2](https://yp.smallkun.cn/markdown/v2-396b2759e6c20106ecc661ccdf6c7c68_r.jpg!compress)
表 3-11 图书类别表(category)结构
![48910-00-94-1](https://yp.smallkun.cn/markdown/v2-38a46a4e9729af94160e6169e388daf3_r.jpg!compress)
表 3-12 订购表(b_order)结构
![48910-00-94-2](https://yp.smallkun.cn/markdown/v2-bb75ef1b2b959a881528f9e922659618_r.jpg!compress)
## 插入、更新、删除数据
目的:熟练掌握使用 INSERT、DELETE、UPDATE 语句向表中添加、删除、修改记录。
内容:
(1)「网上书店」数据库中的数据分别如表 4-1 至表 4-4 所示。
表 4-1 user 表数据
![48910-00-101-1](https://yp.smallkun.cn/markdown/v2-47201f068f5b42aef0ffdf868fbd9941_r.jpg!compress)
表 4-2 book 表数据
![48910-00-101-2](https://yp.smallkun.cn/markdown/v2-071c5c7c1866bfe8454f256a58ec0459_r.jpg!compress)
表 4-3 category 表数据
![48910-00-101-3](https://yp.smallkun.cn/markdown/v2-1d54f4342cf93f74586bf84b78741e70_r.jpg!compress)
表 4-4 b_order 表数据
![48910-00-102-1](https://yp.smallkun.cn/markdown/v2-a4033c268bbe2e6a74002332b5d76b07_r.jpg!compress)
(2)使用 SQL 语句分别向 user 表(表 4-1)、book 表(表 4-2)、category 表(表 4-3)、b_order 表(表 4-4)插入记录。
(3)使用 SQL 语句修改表中记录。
① 把 user 表中 uid 字段值为 1001 的记录的 uname 字段值修改为「何大姑」。
② 把 b_order 表中 uid 字段值为 1003 且 bid 字段值为 3 的记录的 ordernum 字段值改为「10」,并把该记录的 orderdate 字段值改为「2016-10-01」,deliverydate 字段值设为「2016-10-03」。
(4)使用 SQL 语句删除表中记录。
① 删除 2015 年的订单信息。
② 清空 book 表。
## 简单查询
目的:掌握 SELECT 语句中 DISTINCT 子句、LIMIT 子句、WHERE 子句以及 ORDER BY 子句的使用。
内容如下。
(1)查询会员表,输出积分高于 500 分的会员昵称和联系电话。
(2)查询会员表,输出积分低于 200 分的会员昵称和联系电话,分别用英文 username、telephone 指定别名。
(3)查询会员表,输出 E-mail 是 QQ 邮箱的会员昵称及其 E-mail。
(4)查询订购表,输出订购日期是 2016 年 10 月的订单的详细信息。
(5)查询订购表,输出订货的会员编号,要求删除重复行。
(6)查询图书表,输出图书的名称和价格,并把查询结果按价格降序排列。
(7)查询图书表,输出价格最高的三种图书的名称和价格。
## 分组查询
目的:掌握集合函数、GROUP BY 子句、HAVING 子句。
内容如下。
(1)查询图书表,输出所有图书的最高价格、最低价格、平均价格。
(2)查询图书表,输出每一类图书的数量。
(3)查询图书表,输出每一类图书的最高价格、最低价格、平均价格。
(4)查询订购表,输出订购数量超过 3 本的会员编号和订购数量。
## 多表连接查询、子查询
目的:掌握连接查询和子查询
内容如下。
(1)输出所有图书的图书名称、价格以及所属类别名称。
(2)输出订购了《平凡的世界》的会员昵称、联系电话、订购数量。
(3)输出订购了图书的会员昵称和联系电话。
4)输出无人订购的图书名称和价格。
(5)输出详细订购信息,包括订购图书的会员呢称、联系电话、所订图书名称、数量、价格、折扣价。
## 存储过程
目的:掌握存储过程的创建和执行。掌握存储过程中输入、输出参数的使用。
内容:
(1)在「网上书店」数据库中创建一个名为 proc_1 的存储过程,实现查询所有会员信息的功能。
(2)在「网上书店」数据库中创建一个名为 proc_2 的存储过程,要求实现如下功能:根据会员昵称查询会员的积分情况。并调用存储过程,查询「平平人生」和「感动心灵」的积分。
(3)在「网上书店」数据库中创建一个名为 proc_3 的存储过程,要求实现如下功能:根据会员昵称查询会员的订购信息,如果该会员没有订购任何图书,则输出「某某会员没有订购图书」的信息;否则输出订购图书的相关信息。调用存储过程,显示会员「四十不惑」订购图书的情况。
## 视图
目的:掌握视图的定义、维护、使用。
内容:
(1)定义基于图书表的视图(包含图书编号、图书名称、作者、价格、出版社、图书类别)。
(2)查询图书表视图,输出图书的名称和价格,并把查询结果按价格降序排列。
(3)查询图书表视图,输出价格最高的三种图书的名称和价格。
## 触发器
### 创建
目的:掌握触发器的创建和执行。
内容:在「网上书店」数据库中创建一个名为 tri_1 的触发器,当向订购表中插入记录时,如果订购量 <=0,就将订购量设置为 1。
### 使用
目的:掌握触发器的使用。
内容:
(1)在「网上书店」数据库中创建一个名为 tri_2 的触发器,要求实现如下功能:当删除图书类别表中的某个图书类别时,将图书表中对应的图书类别的值设置为 NULL。
(2)在「网上书店」数据库中创建一个名为 tri_3 的触发器,要求实现如下功能:当删除某个会员的时候,自动删除该会员的订购信息。
### 删除
目的:掌握触发器的删除
内容:删除网上书店数据库中的触发器 tri_1。
## 用户管理
### 创建新用户
目的:掌握使用 SQL 语句进行用户的创建、查看和删除操作。
内容:
(1)使用 SQL 语句创建 test 用户。
(2)使用 SQL 语句查看创建的 test 用户的信息。
(3)使用 SQL 语句删除 test 用户。
### 用户权限授予和回收
目的:掌握使用 SQL 语句授予和收回用户权限。
内容:
(1)使用 SQL 语句授予 test 用户对「学生选课」数据库中 studentInfo 表、teacher 表的查询、插入、更新和删除数据的权限。
(2)使用 SQL 语句收回 test 用户的全部权限。
+334
View File
@@ -0,0 +1,334 @@
### 结构体类型定义
```c
/*
struct 结构体名{
数据类型 变量名;
数据类型 变量名;
};
CREATE TABLE 表名(
字段名 数据类型,
字段名 数据类型
);
*/
//声明了一个结构体类型 学生类型
struct student{
int id;//学号
char name[20];//姓名
int age;//年龄
char sex;//性别
double score;//成绩
};
```
### 结构体变量定义
```c
#include <stdio.h>
#include <string.h>
/*
struct 结构体名{
数据类型 变量名;
数据类型 变量名;
};
CREATE TABLE 表名(
字段名 数据类型,
字段名 数据类型
);
*/
//定义了一个结构体类型 学生类型
struct student{
int id;//学号
char name[20];//姓名
int age;//年龄
char sex[2];//性别
double score;//成绩
};
int main(void){
//结构体类型如果没有取别名的情况下
//需要 使用 struct 结构体名 结构体变量名; 来定义结构体变量
//定义了一个学生变量s1
struct student s1;//存储一个的学生
//对结构体变量进行赋值操作
s1.id = 100;
strcpy(s1.name, "小明");
s1.age = 18;
strcpy(s1.sex, "");
s1.score = 99;
//对结构体变量进行取值操作
printf("%d %s %d %s %.0lf\n", s1.id, s1.name, s1.age, s1.sex, s1.score);
return 0;
}
```
```c
#include <stdio.h>
#include <string.h>
//结构体类型的定义
//1.在主函数内 通过struct 结构体类型名 变量1, 变量2;
//2.在定义结构体类型的时候定义
//3.只在定义结构体类型时定义变量(结构体类型只使用一次)
struct student{
int id;//学号
char name[20];//姓名
int age;//年龄
char sex[2];//性别
double score;//成绩
}stu1, stu2;
//在定义结构体类型的时候同时定义了两个结构体变量stu1, stu2
int main(void){
stu1.id = 1;
stu2.id = 2;
printf("%d %d\n", stu1.id, stu2.id);
return 0;
}
```
### 使用typedef对结构体类型起别名
```c
#include <stdio.h>
#include <string.h>
/*
struct 结构体名{
数据类型 变量名;
数据类型 变量名;
};
CREATE TABLE 表名(
字段名 数据类型,
字段名 数据类型
);
*/
//定义了一个结构体类型 学生类型
//typedef 数据类型 类型别名;
//typedef int element;
/*
typedef struct 结构体类型名{
数据类型 变量名1;
数据类型 变量名2;
}别名;
*/
typedef struct student{
//4+20+4+2+8
int id;//学号
char name[20];//姓名
int age;//年龄
char sex[2];//性别
double score;//成绩
}student;
//struct student <=> student
int main(void){
//结构体类型如果没有取别名的情况下
//需要 使用 struct 结构体名 结构体变量名; 来定义结构体变量
//定义了一个学生变量s1
struct student s1;//存储一个的学生
student s2;
//对结构体变量进行赋值操作
s1.id = 100;
strcpy(s1.name, "小明");
s1.age = 18;
strcpy(s1.sex, "");
s1.score = 99;
//对结构体变量进行取值操作
printf("%d %s %d %s %.0lf\n", s1.id, s1.name, s1.age, s1.sex, s1.score);
return 0;
}
```
### 习题-1
```c
#include <stdio.h>
/*
1.定义一个图书类型,要求存储以下数据,图书编号、图书名、作者名、出版社、价格
定义两个图书变量,别分命名为book1、book2存储以下数据
1 数据结构 桃桃 高等教育出版社 59.9
2 操作系统 台球王子 高等教育出版社 58.9
并打印出来
*/
struct book{
int id;//图书编号
char title[50];//图书名称
char author[50];//作者名称
char publishing[50];//出版社
double price;//价格
};
int main(){
struct book book1={1, "数据结构", "桃桃", "高等教育出版社", 59.9};
struct book book2={2, "操作系统", "台球王子", "高等教育出版社", 58.9};
printf("%d\t %s\t %s\t\t %s\t %.1lf\n", book1.id, book1.title,
book1.author, book1.publishing, book1.price);
printf("%d\t %s\t %s\t %s\t %.1lf\n", book2.id, book2.title,
book2.author, book2.publishing, book2.price);
return 0;
}
```
### 习题-2
```c
#include <stdio.h>
/*
2.定义一个动物类型,要求存储以下数据,自行推断成员变量类型
1 斑马 素食 一级保护动物
2 小熊猫 素食 一级保护动物
3 蝙蝠 肉食 其他动物
*/
typedef struct animal{
int id;
char type[20];
char foodType[20];
char leve[20];
}animal;
int main(){
animal a1 = {1, "斑马", "素食", "一级保护动物"};
animal a2 = {2, "小熊猫", "素食", "一级保护动物"};
animal a3 = {3, "蝙蝠", "肉食", "一级保护动物"};
printf("%d\t %s\t %s\t %s\n", a1.id, a1.type, a1.foodType, a1.leve);
printf("%d\t %s\t %s\t %s\n", a2.id, a2.type, a2.foodType, a2.leve);
printf("%d\t %s\t %s\t %s\n", a3.id, a3.type, a3.foodType, a3.leve);
return 0;
}
```
### 结构体数组、指针
```c
#include <stdio.h>
/*
2.定义一个动物类型,要求存储以下数据,自行推断成员变量类型
1 斑马 素食 一级保护动物
2 小熊猫 素食 一级保护动物
3 蝙蝠 肉食 其他动物
*/
typedef struct animal{
int id;
char type[20];
char foodType[20];
char leve[20];
}animal;
int main(){
int i;
animal aList[3] = {
{1, "斑马", "素食", "一级保护动物"},
{2, "小熊猫", "素食", "一级保护动物"},
{3, "蝙蝠", "肉食", "一级保护动物"}};
animal *pA = aList;//定义一个动物指针指向数组的第一个结构体变量的元素
//(*pA).id <=> pA->id
//1.使用*访问符得到元素
//printf("%d\n", (*pA).id);
//printf("%d\n", pA->id);
for(i=0;i<3;i++){
//aList[i] <=> *(aList+i
printf("%d\t %s\t %s\t %s\n", (aList+i)->id, (aList+i)->type,
(aList+i)->foodType, (aList+i)->leve);
}
return 0;
}
```
### 结构体类型作为函数的参数
```c
#include <stdio.h>
/*
2.定义一个动物类型,要求存储以下数据,自行推断成员变量类型
1 斑马 素食 一级保护动物
2 小熊猫 素食 一级保护动物
3 蝙蝠 肉食 其他动物
*/
typedef struct animal{
int id;
char type[20];
char foodType[20];
char leve[20];
}animal;
//结构体变量作为函数的参数
void print(animal a){
printf("%d\t %s\t %s\t %s\n", a.id, a.type, a.foodType, a.leve);
}
//结构体的指针变量作为函数的参数
void print2(animal *a){
printf("%d\t %s\t %s\t %s\n", a->id, a->type, a->foodType, a->leve);
}
int main(){
int i;
animal aList[3] = {
{1, "斑马", "素食", "一级保护动物"},
{2, "小熊猫", "素食", "一级保护动物"},
{3, "蝙蝠", "肉食", "一级保护动物"}};
animal *pA = aList;//定义一个动物指针指向数组的第一个结构体变量的元素
//(*pA).id <=> pA->id
//1.使用*访问符得到元素
//printf("%d\n", (*pA).id);
//printf("%d\n", pA->id);
for(i=0;i<3;i++){
print2(aList+i);
}
return 0;
}
```
### 使用结构体存储点通过函数计算两个点之间的距离
```c
#include <stdio.h>
#include <math.h>
typedef struct point{
int x;
int y;
}point;
float distance(point *p1, point *p2){
/*
pow((float)(p2->y - p1->y), 2) <=> (y2-y1)*(y2-y1)
*/
return sqrt(pow((float)(p2->y - p1->y), 2) + pow((float)(p2->x - p1->x), 2));
}
int main(){
point p1 = {1, 2}, p2 = {2, 2};
printf("两点之间的距离为%.2lf\n", distance(&p1, &p2));
return 0;
}
```
+110
View File
@@ -0,0 +1,110 @@
### 数据库
```sql
#1
CREATE TABLE t_family(
fno INT(11) PRIMARY KEY AUTO_INCREMENT,
eno INT(11) NOT NULL COMMENT '职工编号',
ename VARCHAR(255) NOT NULL COMMENT '职工姓名',
faname VARCHAR(255),
moname VARCHAR(255)
);
#2
ALTER TABLE t_salary ADD grade VARCHAR(255) COMMENT '评级';
#3
ALTER TABLE t_employee MODIFY sex ENUM('', '');
#4
UPDATE t_department d
SET d.tel = '128'
WHERE d.dname = '法务部';
#5
SELECT e.ename, e.sex, e.birthday
FROM t_employee e
WHERE e.birthday >= '2000-1-1'
ORDER BY e.birthday DESC;
#6
SELECT d.dname, SUM(s.basepay+s.overtime+s.allowance+s.insurance)
FROM t_department d, t_employee e, t_salary s
WHERE e.dno = d.dno AND e.eno = s.eno
GROUP BY d.dno;
#7 +
CREATE VIEW v_jobcount AS
SELECT j.jobtitle, COUNT(*)
FROM t_job j, t_employee e
WHERE j.jno = e.jobno
GROUP BY j.jno
ORDER BY 2;
#8
CREATE TRIGGER tri_updateGrade
BEFORE UPDATE ON t_salary FOR EACH ROW
BEGIN
IF NEW.basepay < 6000 THEN
SET NEW.grade = 'C';
ELSEIF NEW.basepay < 8000 THEN
SET NEW.grade = 'B';
ELSEIF NEW.basepay >= 8000 THEN
SET NEW.grade = 'A';
END IF;
END;
#9
CREATE PROCEDURE `pro_getDepartmentTel`(in `in_dno` int, OUT dept_phone VARCHAR(100))
BEGIN
SELECT CONCAT('部门名称-', dname, ',电话-', tel) INTO dept_phone
FROM t_department
WHERE dno = `in_dno` limit 1;
IF dept_phone IS NULL THEN
SET dept_phone = '没有找到相应的部门';
END IF;
END
```
### C语言-1
```c
/*---------------------------------------------------------
【程序设计】输入n个整数,以-1结束,求所输入的整数中,十位是奇数的所有整数之和。
例1
输入n个整数,求十位为奇数的数之和(输入-1结束):
10 15 20 25 30 40 50 -1
十位为奇数的数之和为: 105
例2
输入n个整数,求十位为奇数的数之和(输入-1结束):
8 18 28 -38 48 58 -1 98
十位为奇数的数之和为: 38
------------------------------------------------------------------------
注意:部分源程序给出如下。请勿改动主函数main或其它函数中给出的内容,仅在
Program-End之间填入若干语句。不要删除标志否则不得分。
---------------------------------------------------------*/
#include <stdio.h>
int main() {
int num,tenDigit;
int sum = 0,i;
printf("输入n个整数,求十位为奇数的数之和(输入-1结束):\n");
while (1)
{
scanf("%d", &num);
/**********Program**********/
if(num == -1){
break;
}
if((num<0?num*-1:num)%100/10%2==1){
sum += num;
}
/********** End **********/
}
printf("十位为奇数的数之和为: %d\n", sum);
}
```