不正经

这个屌丝很懒，什么也没留下！

热门标签

十套专升本难度的C语言程序设计试卷：_专升本c语言程序设计考试题

作者：不正经 | 2024-04-13 07:47:24

踩

专升本c语言程序设计考试题

十套专升本难度的C语言程序设计试卷：

试卷一：

声明一个整型数组，长度为5，数组中每个元素的值都为0。要求使用for循环实现。

#include <stdio.h>

int main() {
    int a[5];
    int i;
    for (i = 0; i < 5; i++) {
        a[i] = 0;
    }
    for (i = 0; i < 5; i++) {
        printf("%d ", a[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

定义一个名为Person的结构体，包含两个成员：name和age，类型分别为char指针和整型。创建一个Person类型的结构体数组，长度为3，然后输入每个结构体的成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Person {
    char *name;
    int age;
};

int main() {
    struct Person p[3];
    int i;
    for (i = 0; i < 3; i++) {
        p[i].name = (char *) malloc(20 * sizeof(char));
        scanf("%s %d", p[i].name, &p[i].age);
    }
    for (i = 0; i < 3; i++) {
        printf("%s %d", p[i].name, p[i].age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

定义一个函数，函数名为swap，有两个整型参数a和b，用来交换a和b的值。在main函数中输入两个整数，并调用该函数交换它们的值，最后输出交换后的两个整数。

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    swap(&a, &b);
    printf("%d %d", a, b);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

试卷二：

定义一个名为Book的结构体，包含三个成员：id、title和price，类型分别为整型、字符串和浮点型。创建一个Book类型的结构体变量，然后输入每个成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Book {
    int id;
    char *title;
    float price;
};

int main() {
    struct Book b;
    b.title = (char *) malloc(20 * sizeof(char));
    scanf("%d %s %f", &b.id, b.title, &b.price);
    printf("%d %s %f", b.id, b.title, b.price);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

编写一个计算阶乘的函数，函数名为fact，有一个整型参数n，返回值为n的阶乘。在main函数中输入一个整数并调用该函数计算它的阶乘，最后输出结果。

#include <stdio.h>

int fact(int n) {
    int i;
    int result = 1;
    for (i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d", fact(n));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

编写一个程序，输入一个三位整数，将该数的各位数字反转后输出。例如，输入123，输出321。

#include <stdio.h>

int main() {
    int n;
    scanf("%d", &n);
    printf("%d", n % 10 * 100 + n / 10 % 10 * 10 + n / 100);
    return 0;
}
1
2
3
4
5
6
7
8

试卷三：

定义一个名为Rectangle的结构体，包含两个成员：width和height，类型分别为整型。创建一个Rectangle类型的结构体变量，然后输入它的成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Rectangle {
    int width;
    int height;
};

int main() {
    struct Rectangle r;
    scanf("%d %d", &r.width, &r.height);
    printf("%d %d", r.width, r.height);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

编写一个程序，输入两个整数，输出它们的和、差、积和商。

#include <stdio.h>

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d %d %d %d", a + b, a - b, a * b, a / b);
    return 0;
}
1
2
3
4
5
6
7
8

定义一个函数，函数名为max，有两个整型参数a和b，返回值为a和b中的较大者。然后在main函数中输入两个整数，并调用该函数求它们的最大值，最后输出结果。

#include <stdio.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", max(a, b));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

试卷四：

编写一个程序，输入三个整数a、b和c，判断它们是否能组成一个三角形，若能则输出周长和面积，否则输出“无法构成三角形”。

#include <stdio.h>
#include <math.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    if (a + b > c && a + c > b && b + c > a) {
        printf("%f %f", a + b + c,
               sqrt((a + b + c) / 2 * ((a + b + c) / 2 - a) * ((a + b + c) / 2 - b) * ((a + b + c) / 2 - c)));
    } else {
        printf("无法构成三角形");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

定义一个名为Person的结构体，包含两个成员：name和age，类型分别为char指针和整型。创建一个Person类型的结构体指针，然后输入该结构体的成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Person {
    char *name;
    int age;
};

int main() {
    struct Person *p = (struct Person *) malloc(sizeof(struct Person));
    p->name = (char *) malloc(20 * sizeof(char));
    scanf("%s %d", p->name, &p->age);
    printf("%s %d", p->name, p->age);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

编写一个计算平均值的函数，函数名为average，有两个实型参数a和b，返回值为a和b的平均值。在main函数中输入两个实数并调用该函数计算它们的平均值，最后输出结果。

#include <stdio.h>

float average(float a, float b) {
    return (a + b) / 2;
}

int main() {
    float a, b;
    scanf("%f %f", &a, &b);
    printf("%f", average(a, b));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

试卷五：

定义一个名为Student的结构体，包含三个成员：name、score和grade，类型分别为char指针、整型和char。创建一个Student类型的结构体数组，长度为3，然后输入每个结构体的成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Student {
    char *name;
    int score;
    char grade;
};

int main() {
    struct Student s[3];
    int i;
    for (i = 0; i < 3; i++) {
        s[i].name = (char *) malloc(20 * sizeof(char));
        scanf("%s %d %c", s[i].name, &s[i].score, &s[i].grade);
    }
    for (i = 0; i < 3; i++) {
        printf("%s %d %c", s[i].name, s[i].score, s[i].grade);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

编写一个程序，输入一个整数n，然后输出1~n的所有奇数之和和偶数之和。

#include <stdio.h>

int main() {
    int n, i, sum1 = 0, sum2 = 0;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (i % 2 == 0) {
            sum1 += i;
        } else {
            sum2 += i;
        }
    }
    printf("%d %d", sum1, sum2);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

编写一个程序，输入两个字符串s1和s2，判断它们是否相等，若相等则输出“相等”，否则输出“不相等”。

#include <stdio.h>
#include <string.h>

int main() {
    char s1[20], s2[20];
    scanf("%s %s", s1, s2);
    if (strcmp(s1, s2) == 0) {
        printf("相等");
    } else {
        printf("不相等");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

试卷六：

定义一个名为Point的结构体，包含两个成员：x和y，类型分别为实型。创建一个Point类型的结构体数组，长度为4，然后输入每个结构体的成员值并输出。

#include <stdio.h>
#include <string.h>
#include <cstdlib>

struct Point {
    float x;
    float y;
};


int main() {
    struct Point p[4];
    int i;
    for (i = 0; i < 4; i++) {
        scanf("%f %f", &p[i].x, &p[i].y);
    }
    for (i = 0; i < 4; i++) {
        printf("%f %f", p[i].x, p[i].y);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

编写一个程序，输入一个正整数n，输出它的所有质因数。

#include <stdio.h>

int main() {
    int n, i;
    scanf("%d", &n);
    for (i = 2; i <= n; i++) {
        while (n % i == 0) {
            printf("%d ", i);
            n /= i;
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

定义一个函数，函数名为power，有两个实型参数base和exp，返回值为base的exp次方。在main函数中输入两个实数并调用该函数求它们的积，最后输出结果。

#include <stdio.h>
#include <math.h>

float power(float base, float exp) {
    return pow(base, exp);
}

int main() {
    float base, exp;
    scanf("%f %f", &base, &exp);
    printf("%f", power(base, exp));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

试卷七：

编写一个程序，输入一个年份，判断它是否为闰年，若是则输出“是闰年”，否则输出“不是闰年”。

#include <stdio.h>

int main() {
    int year;
    scanf("%d", &year);
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        printf("是闰年");
    } else {
        printf("不是闰年");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

编写一个程序，输入一个整数n，判断它是否为回文数，若是则输出“是回文数”，否则输出“不是回文数”。例如，121是回文数，123不是回文数。

#include <stdio.h>

int  main(){
    int n, m, sum = 0;
    scanf("%d", &n);
    m = n;
    while (m != 0) {
        sum = sum * 10 + m % 10;
        m /= 10;
    }
    if (sum == n) {
        printf("是回文数");
    } else {
        printf("不是回文数");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

定义一个函数，函数名为factorial，有一个整型参数n，返回值为n的阶乘。使用递归实现该函数。在main函数中输入一个整数并调用该函数计算它的阶乘，最后输出结果。

#include <stdio.h>

int  factorial(int n){
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d", factorial(n));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

试卷八：

定义一个名为Complex的结构体，包含两个成员：real和imag，类型分别为实型。创建一个Complex类型的结构体变量，然后输入它的成员值并输出。

#include <stdio.h>

struct Complex {
    float real;
    float imag;
};

int main() {
    struct Complex c;
    scanf("%f %f", &c.real, &c.imag);
    printf("%f %f", c.real, c.imag);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

编写一个程序，输入一个正整数n，求它的约数个数，并输出。

#include <stdio.h>

int main() {
    int n, i, count = 0;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        if (n % i == 0) {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

编写一个程序，输入一张卡片的面值和数量，计算并输出总金额。

#include <stdio.h>

int main() {
    int n, i;
    float sum = 0;
    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        float value;
        int count;
        scanf("%f %d", &value, &count);
        sum += value * count;
    }
    printf("%f", sum);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

试卷九：

编写一个程序，输入一个字符串s，将它反转后输出。

#include <stdio.h>
#include <string.h>

int main() {
    char s[100];
    scanf("%s", s);
    int i, j;
    for (i = 0, j = strlen(s) - 1; i < j; i++, j--) {
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
    printf("%s", s);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

定义一个函数，函数名为prime，有一个整型参数n，返回值为n是否是素数。在main函数中输入一个整数并调用该函数判断它是否为素数，最后输出结果。

#include <stdio.h>

int prime(int n) {
    int i;
    for (i = 2; i < n; i++) {
        if (n % i == 0) {
            return 0;
        }
    }
    return 1;
}

int main() {
    int n;
    scanf("%d", &n);
    if (prime(n)) {
        printf("是素数");
    } else {
        printf("不是素数");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

定义一个函数，函数名为gcd，有两个整型参数a和b，返回值为a和b的最大公约数。然后在main函数中输入两个整数并调用该函数求它们的最大公约数，最后输出结果。

#include <stdio.h>

int gcd(int a, int b) {
    int i;
    for (i = a; i > 0; i--) {
        if (a % i == 0 && b % i == 0) {
            return i;
        }
    }
}

int main() {
    int a, b;
    scanf("%d %d", &a, &b);
    printf("%d", gcd(a, b));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

试卷十：

编写一个程序，输入一个字符串s和一个字符c，统计字符c在字符串s中出现的次数并输出。

#include <stdio.h>

int main(){
    char s[100], c;
    scanf("%s %c", s, &c);
    int i, count = 0;
    for (i = 0; s[i] != '\0'; i++) {
        if (s[i] == c) {
            count++;
        }
    }
    printf("%d", count);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

定义一个名为Circle的结构体，包含一个成员：radius，类型为实型。创建一个Circle类型的结构体指针，然后输入该结构体的成员值并输出。

#include <stdio.h>

struct Circle {
    float radius;
};

int main() {
    struct Circle *c;
    scanf("%f", &c->radius);
    printf("%f", c->radius);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

定义一个函数，函数名为reverse，有一个整型参数n，返回值为n的各位数字反转后的数值。在main函数中输入一个整数并调用该函数计算它反转后的数值，最后输出结果。

#include <stdio.h>

int reverse(int n) {
    int sum = 0;
    while (n != 0) {
        sum = sum * 10 + n % 10;
        n /= 10;
    }
    return sum;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d", reverse(n));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】