C primer plus编程练习-第10章

最新推荐文章于 2022-12-30 19:50:49 发布
最新推荐文章于 2022-12-30 19:50:49 发布
阅读量577 收藏 2
点赞数 1
分类专栏： C语言练习 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XIANGYUNFEITIAN/article/details/106463836
版权

1.修改程序清单10.7的rain.c程序， 用指针进行计算（仍然要声明并初始化数组）

#include<stdio.h>
#define MONTHS 12
#define YEARS 5
int main(void)
{
        float rain[YEARS][MONTHS] =
        {
                { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6 },
                { 8.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3 },
                { 9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4 },
                { 7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2 },
                { 7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2 }
        };
        float (*pr)[MONTHS];
        pr = rain;

        int year, month;
        float subtot, total;

        printf(" YEAR    RAINFALL (inches)\n");
        for (year = 0, total = 0; year < YEARS; year++)
        {
                for (month = 0, subtot = 0; month < MONTHS; month++)
                        subtot += *(*(pr + year) + month);
                printf("%5d %15.1f\n", 2010 + year, subtot);
                total += subtot;
        }
        printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);
        printf("MONTHLY AVERAGES:\n\n");
        printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct  Nov  Dec\n");

        for (month = 0; month < MONTHS; month++)
        {
                for (year = 0, subtot = 0; year < YEARS; year++)
                        subtot += *(*(pr + year) + month);
                printf("%4.1f ", subtot / YEARS);
        }
        printf("\n");

        return 0;
}

2.编写一个程序， 初始化一个double类型的数组， 然后把该数组的内容拷贝至3个其他数组中（在main()中声明这4个数组） 。 使用带数组表示法的函数进行第1份拷贝。 使用带指针表示法和指针递增的函数进行第2份拷贝。把目标数组名、 源数组名和待拷贝的元素个数作为前两个函数的参数。 第3个函数以目标数组名、 源数组名和指向源数组最后一个元素后面的元素的指针。 也就是说， 给定以下声明， 则函数调用如下所示：
double source[5] = {1.1, 2.2, 3.3, 4.4, 5.5};
double target1[5];
double target2[5];
double target3[5];
copy_arr(target1, source, 5);
copy_ptr(target2, source, 5);
copy_ptrs(target3, source, source + 5);

#include<stdio.h>
#define SIZE 5
void copy_arr(double t[], double s[], int n);
void copy_ptr(double *pt, double *ps, int n);
void copy_ptrs(double *pt, double *ps, double *end);
int main(void)
{
        double source[SIZE] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
        double target1[SIZE], target2[SIZE], target3[SIZE];

        printf("target1:\n");
        copy_arr(target1, source, SIZE);
        printf("target2:\n");
        copy_ptr(target2, source, SIZE);
        printf("target3:\n");
        copy_ptrs(target3, source, source + SIZE);

        return 0;
}

void copy_arr(double t[], double s[], int n)
{
        int i;
        for (i = 0; i < n; i++)
        {
                t[i] = s[i];
                printf("%g\t", t[i]);
        }
        putchar('\n');
        return;
}

void copy_ptr(double *pt, double *ps, int n)
{
        int i;
        for (i = 0; i < n; i++)
        {
                *pt = *ps;
                printf("%g\t", *ps);
                pt++;
                ps++;
        }
        putchar('\n');
        return;
}

void copy_ptrs(double *pt, double *ps, double *end)
{
        while (ps < end)
        {
                *pt = *ps;
                printf("%g\t", *ps);
                pt++;
                ps++;
        }
        putchar('\n');
        return;
}

3.编写一个函数， 返回储存在int类型数组中的最大值， 并在一个简单的程序中测试该函数

#include<stdio.h>
int max(int ar[], int n);

int main(void)
{
        int array[6] = { 4, 6, 104, -43, -32, 23 };

        printf("the largest integer is %d\n", max(array, 6));

        return 0;
}

int max(int ar[], int n)
{
        int i;
        int max = ar[0];

        for (i = 1; i < n; i++)
                if (max < ar[i])
                        max = ar[i];

        return max;
}

4.编写一个函数， 返回储存在double类型数组中最大值的下标， 并在一个简单的程序中测试该函数

#include<stdio.h>
int location(double ar[], int n);

int main(void)
{
        double array[6] = { 32.643, 32.7, -34343, 53, 9.321, 0 };

        printf("the index of the largest value is %d\n", location(array, 6));

        return 0;
}

int location(double ar[], int n)
{
        int index = 0;
        int j;

        for (j = 1; j < n; j++)
                if (ar[index] < ar[j])
                        index = j;

        return index;
}

5.编写一个函数， 返回储存在double类型数组中最大值和最小值的差值， 并在一个简单的程序中测试该函数

#include<stdio.h>
double difference(double ar[], int n);

int main(void)
{
        double array[10] = { 321, 0, 320.432, 2e3, 23.45, -0.34, 23, -321, 48, 34 };

        printf("the difference between the largest and smallest elements is %g\n", difference(array, 10));

        return 0;
}

double difference(double ar[], int n)
{
        double smallest = ar[0];
        double largest = ar[0];
        int i;

        for (i = 1; i < n; i++)
        {
                if (smallest > ar[i])
                        smallest = ar[i];
                if (largest < ar[i])
                        largest = ar[i];
        }

        return (largest - smallest);
}

6.编写一个函数， 把double类型数组中的数据倒序排列， 并在一个简单的程序中测试该函数

#include<stdio.h>
#define SIZE 10
void reverse(double s[], double t[], int n);

int main(void)
{
        double source[SIZE] = { 321, 0, 320.432, 2e3, 23.45, -0.34, 23, -321, 48, 34 };
        double target[SIZE];
        int i;

        reverse(source, target, SIZE);
        printf("target[10]: ");
        for (i = 0; i < SIZE; i++)
                printf("%g  ", target[i]);
        putchar('\n');

        return 0;
}

void reverse(double s[], double t[], int n)
{
        int i, j;

        for (i = 0, j = n-1; i < n; i++, j--)
                t[j] = s[i];

        return;
}

7.编写一个程序， 初始化一个double类型的二维数组， 使用编程练习2中的一个拷贝函数把该数组中的数据拷贝至另一个二维数组中（因为二维数组是数组的数组， 所以可以使用处理一维数组的拷贝函数来处理数组中的每个子数组）

#include<stdio.h>
#define SIZE 3
void copy(double s[], double t[], int n);
int main(void)
{
        double source[SIZE][5] =
        {
                { 1.1, 2.2, 3.3, 4.4, 5.5 },
                { 321, 0, 320.432, 2e3, 23.45 },
                { -0.34, 23, -321, 48, 34 }
        };
        double target[SIZE][5];
        int i, j;

        for (i = 0; i < SIZE; i++)
                copy(source[i], target[i], 5);
        for (i = 0; i < SIZE; i++)
        {
                for (j = 0; j < 5; j++)
                        printf("%g\t", target[i][j]);
                putchar('\n');
        }

        return 0;
}

void copy(double s[], double t[], int n)
{
        int i;

        for (i = 0; i < n; i++)
                t[i] = s[i];

        return;
}

8.使用编程练习2中的拷贝函数， 把一个内含7个元素的数组中第3～第5个元素拷贝至内含3个元素的数组中。 该函数本身不需要修改， 只需要选择合适的实际参数（实际参数不需要是数组名和数组大小， 只需要是数组元素的地址和待处理元素的个数）

#include<stdio.h>
#define SIZE1 7
#define SIZE2 3
void copy(double *ps, double *pt, int n);

int main(void)
{
        double sourse[SIZE1] = { 321, 0, 320.432, 2e3, 23.45, -0.34, 23 };
        double target[SIZE2];
        copy(&sourse[2], target, SIZE2);

        int i;
        for (i = 0; i < SIZE2; i++)
                printf("%g\t", target[i]);
        putchar('\n');
        return 0;
}

void copy(double *ps, double *pt, int n)
{
        int i;
        for (i = 0; i < n; i++)
        {
                *pt = *ps;
                ps++;
                pt++;
        }
        return;
}

9.编写一个程序， 初始化一个double类型的3×5二维数组， 使用一个处理变长数组的函数将其拷贝至另一个二维数组中。 还要编写一个以变长数组为形参的函数以显示两个数组的内容。 这两个函数应该能处理任意N×M数组（如果编译器不支持变长数组， 就使用传统C函数处理N×5的数组）

#include<stdio.h>
void copy(int n, int m, double s[n][m], double t[n][m]);
void show(int n, int m, double ar[n][m]);

int main(void)
{
        int row = 3;
        int col = 5;
        double source[3][5] =
        {
                 { 1.1, 2.2, 3.3, 4.4, 5.5 },
                 { 321, 0, 320.432, 2e3, 23.45 },
                 { -0.34, 23, -321, 48, 34 }
        };
        double target[row][col];

        copy(row, col, source, target);
        printf("source: \n");
        show(3, 5, source);
        printf("target:\n");
        show(row, col, target);

        return 0;
}

void copy(int n, int m, double s[n][m], double t[n][m])
{
        int i, j;
        for (i = 0; i < n; i++)
                for (j = 0; j < m; j++)
                        t[i][j] = s[i][j];
        return;
}

void show(int n, int m, double ar[n][m])
{
        int i, j;
        for (i = 0; i < n; i++)
        {
                for (j = 0; j < m; j++)
                        printf("%g\t", ar[i][j]);
                putchar('\n');
        }
        return;
}

10.编写一个函数， 把两个数组中相对应的元素相加， 然后把结果储存到第 3 个数组中。 也就是说， 如果数组1中包含的值是2、 4、 5、 8， 数组2中包含的值是1、 0、 4、 6， 那么该函数把3、 4、 9、 14赋给第3个数组。 函数接受3个数组名和一个数组大小。 在一个简单的程序中测试该函数

#include<stdio.h>
#define SIZE 5
void add(double s1[], double s2[], double t[], int n);

int main(void)
{
        double source1[SIZE] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
        double source2[SIZE] = { 321, 0, 320.432, 2e3, 23.45};
        double target[SIZE];
        add(source1, source2, target, SIZE);

        int i;
        for (i = 0; i < SIZE; i++)
                printf("%g\t", target[i]);
        putchar('\n');
        return 0;
}

void add(double s1[], double s2[], double t[], int n)
{
        int i;
        for (i = 0; i < n; i++)
                t[i] = s1[i] + s2[i];
        return;
}

11.编写一个程序， 声明一个int类型的3×5二维数组， 并用合适的值初始化它。 该程序打印数组中的值， 然后各值翻倍（即是原值的2倍） ， 并显示出各元素的新值。 编写一个函数显示数组的内容， 再编写一个函数把各元素的值翻倍。 这两个函数都以函数名和行数作为参数

#include<stdio.h>
void doub(int s[][5], int t[][5], int n);
void show(int ar[][5], int n);

int main(void)
{
        int source[3][5] =
        {
                { -5, 0, 23, 84, 3 },
                { 9, -32, 45, 2, 1 },
                { 0, 32, 5, -34, 3 }
        };
        int target[3][5];

        doub(source, target,3);
        printf("source:\n");
        show(source, 3);
        printf("target:\n");
        show(target, 3);

        return 0;
}

void doub(int s[][5], int t[][5], int n)
{
        int i, j;
        for (i = 0; i < n; i++)
                for (j = 0; j < 5; j++)
                        t[i][j] = s[i][j] * 2;
        return;
}

void show(int ar[][5], int n)
{
        int i, j;
        for (i = 0; i < n; i++)
        {
                for (j = 0; j < 5; j++)
                        printf("%d\t", ar[i][j]);
                putchar('\n');
        }
        return;
}

12.重写程序清单10.7的rain.c程序， 把main()中的主要任务都改成用函数来完成

#include<stdio.h>
#define MONTHS 12
#define YEARS 5
void summary_year(float r[][MONTHS], int n);
void summary_month(float r[][MONTHS], int n);
int main(void)
{
        float rain[YEARS][MONTHS] =
        {
                { 4.3, 4.3, 4.3, 3.0, 2.0, 1.2, 0.2, 0.2, 0.4, 2.4, 3.5, 6.6 },
                { 8.5, 8.2, 1.2, 1.6, 2.4, 0.0, 5.2, 0.9, 0.3, 0.9, 1.4, 7.3 },
                { 9.1, 8.5, 6.7, 4.3, 2.1, 0.8, 0.2, 0.2, 1.1, 2.3, 6.1, 8.4 },
                { 7.2, 9.9, 8.4, 3.3, 1.2, 0.8, 0.4, 0.0, 0.6, 1.7, 4.3, 6.2 },
                { 7.6, 5.6, 3.8, 2.8, 3.8, 0.2, 0.0, 0.0, 0.0, 1.3, 2.6, 5.2 }
        };

        summary_year(rain, YEARS);
        summary_month(rain, YEARS);

        return 0;
}

void summary_year(float r[][MONTHS], int n)
{
        int i, j;
        float subtot, total;

        printf("YEAR RAINFALL (inches)\n");
        for (i = 0, total = 0; i < n; i++)
        {
                for (j = 0, subtot = 0; j < MONTHS; j++)
                        subtot += r[i][j];
                printf("%5d  %15.1f\n", 2010 + i, subtot);
                total += subtot;
        }
        printf("\nThe yearly average is %.1f inches.\n\n", total / YEARS);

        return;
}

void summary_month(float r[][MONTHS], int n)
{
        int i, j;
        float subtot;

        printf("MONTHLY AVERAGES:\n\n");
        printf(" Jan  Feb  Mar  Apr  May  Jun  Jul  Aug  Sep  Oct  Nov  Dec\n");
        for (j = 0; j < MONTHS; j++)
        {
                for (i = 0, subtot = 0; i < n; i++)
                        subtot += r[i][j];
                printf("%4.1f ", subtot / YEARS);
        }
        putchar('\n');

        return;
}

13.编写一个程序， 提示用户输入3组数， 每组数包含5个double类型的数（假设用户都正确地响应， 不会输入非数值数据） 。 该程序应完成下列任务。
a.把用户输入的数据储存在3×5的数组中
b.计算每组（5个） 数据的平均值
c.计算所有数据的平均值
d.找出这15个数据中的最大值
e.打印结果
每个任务都要用单独的函数来完成（使用传统C处理数组的方式） 。 完成任务b， 要编写一个计算并返回一维数组平均值的函数， 利用循环调用该函数3次。 对于处理其他任务的函数， 应该把整个数组作为参数， 完成任务c和d的函数应把结果返回主调函数。

#include<stdio.h>
#define GROUP 3
#define SIZE 5
void save(double ar[][SIZE], int n);
double average_group(double ar[], int n);
double average_all(double ar[][SIZE], int n);
double max(double ar[][SIZE], int n);
void display(double ar[][SIZE], int n);

int main(void)
{
        double array[GROUP][SIZE];
        int i;

        printf("enter 3 sets of 5 double numbers each\n");
        save(array, GROUP);
        printf("array:\n");
        display(array, GROUP);
        printf("the average of each set of 5 values:\n");
        for (i = 0; i < GROUP; i++)
                printf("%10g", average_group(array[i], SIZE));
        printf("\nthe average of all the values: %g\n", average_all(array, GROUP));
        printf("the largest value of the 15 values: %g\n", max(array, GROUP));

        return 0;
}

void save(double ar[][SIZE], int n)
{
        int i, j;
        for (i = 0; i < n; i++)
                for (j = 0; j < SIZE; j++)
                        scanf("%lf", &ar[i][j]);
        return;
}

double average_group(double ar[], int n)
{
        int i;
        double sum = 0.0;

        for (i = 0; i < n; i++)
                sum += ar[i];

        return sum / n;
}

double average_all(double ar[][SIZE], int n)
{
        int i, j;
        double sum = 0.0;

        for (i = 0; i < n; i++)
                for (j = 0; j < SIZE; j++)
                        sum += ar[i][j];

        return sum / (n * SIZE);
}

double max(double ar[][SIZE], int n)
{
        int i, j;
        double max = ar[0][0];

        for (i = 0; i < n; i++)
                for (j = 0; j < SIZE; j++)
                        if (max < ar[i][j])
                                max = ar[i][j];

        return max;
}

void display(double ar[][SIZE], int n)
{
        int i, j;

        for (i = 0; i < n; i++)
        {
                for (j = 0; j < SIZE; j++)
                        printf("%8g", ar[i][j]);
                putchar('\n');
        }

        return;
}

14.以变长数组作为函数形参， 完成编程练习13

#include<stdio.h>
#define GROUP 3
#define SIZE 5
void save(int n, int m, double ar[n][m]);
double average_group(int n, double ar[n]);
double average_all(int n, int m, double ar[n][m]);
double max(int n, int m, double ar[n][m]);
void display(int n, int m, double ar[n][m]);

int main(void)
{
        double array[GROUP][SIZE];
        int i;

        printf("enter 3 sets of 5 double numbers each\n");
        save(GROUP, SIZE, array);
        printf("array:\n");
        display(GROUP,SIZE, array);
        printf("the average of each set of 5 values:\n");
        for (i = 0; i < GROUP; i++)
                printf("%10g", average_group(SIZE, array[i]));
        printf("\nthe average of all the values: %g\n", average_all(GROUP, SIZE, array));
        printf("the largest value of the 15 values: %g\n", max(GROUP, SIZE, array));

        return 0;
}

void save(int n, int m, double ar[n][m])
{
        int i, j;
        for (i = 0; i < n; i++)
                for (j = 0; j < m; j++)
                        scanf("%lf", &ar[i][j]);
        return;
}

double average_group(int n, double ar[n])
{
        int i;
        double sum = 0.0;

        for (i = 0; i < n; i++)
                sum += ar[i];

        return sum / n;
}

double average_all(int n, int m, double ar[n][m])
{
        int i, j;
        double sum = 0.0;

        for (i = 0; i < n; i++)
                for (j = 0; j < m; j++)
                        sum += ar[i][j];

        return sum / (n * m);
}

double max(int n, int m, double ar[n][m])
{
        int i, j;
        double max = ar[0][0];

        for (i = 0; i < n; i++)
                for (j = 0; j < m; j++)
                        if (max < ar[i][j])
                                max = ar[i][j];

        return max;
}

void display(int n, int m, double ar[n][m])
{
        int i, j;

        for (i = 0; i < n; i++)
        {
                for (j = 0; j < m; j++)
                        printf("%8g", ar[i][j]);
                putchar('\n');
        }

        return;
}
我想转行呢
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C PRIMER PLUS（第六版编程练习）10.13编程练习_10题
tianyabaiwei的博客
07-04 422
/*编写一个函数，把两个数组中相对应的元素相加，然后把结果存储到第3个数组中。 也就是说，如果数组1中包含的值是2、4、5、8，数组2中包含的值是1、0、4、6， 那么该函数把3、4、9、14赋给第3个数组。函数接受3个数组名和一个数组大小。 在一个简单的程序中测试该函数。 */ #include<stdio.h> #define SIZE 4 void add_ar(int source1[], int source2[], int target[], int size); void ou
把两个数组中相对应的元素相加，然后把结果出储存在第三个数组中
m0_46393069的博客
12-01 2267
程序代码为本人亲自编写，并非标准答案，仅供参考。 如果程序有任何bug或者有好的建议，欢迎在评论区留言，或者私信。 #include<stdio.h> #define SIZE 5 void sumarr(int*p,int*u,int *s,int n); void p_sum(int*p,int n); int main(void){ int arr[SIZE]={1,2,3,4,5}; int arr2[SIZE]={1,2,3,4,5}; int sum[SIZE];
编写一个函数，返回存储在int类型数组中的最大值，并在一个 简单的程序中测试该函数。
最新发布
weixin_45390022的博客
12-30 576
编写一个函数，返回存储在int类型数组中的最大值，并在一个 简单的程序中测试该函数。
C Primer Plus 第十章 课后答案
asdgyy的博客
10-02 1万+
目录   复习题 1.下面的程序将打印什么内容 2.在复习题1中，ref有多少个元素 3.在复习题1中，ref的地址是什么？ref + 1是什么意思？++ref指向什么 4.在下面的代码中，*ptr和*(ptr + 2)的值分别是什么 a. int *ptr; int torf[2][2] = {12, 14, 16}; ptr = torf[0]; b. int * ptr...
C Primer Plus第十章 编程练习答案
10-30
C Primer Plus第十章 编程练习答案，亲测编译运动通过。
编写一个函数，返回一个int数组中存储的最大数值
Aricia的博客
12-09 6881
输入 输入包括两行，第一行是数组大小n,第二行是n个数字，以空格隔开 输出 输出数组中最大数 样例输入 5 1 2 3 4 5 样例输出 5 #include&lt;stdio.h&gt; int a(int b[],int n) { int max,i; max=b[0]; for(i=0; i&lt;n; i++) { ...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
C++ Primer Plus 编程练习源码工程 第6章
07-10
在本资源中，我们主要关注的是"C++ Primer Plus"这本书的第六章编程练习。这是一组源码工程，由用户LeonardoLiuwenbo在学习过程中编写，旨在帮助读者加深对C++编程语言的理解，尤其是第六章涉及的概念和技术。下面...
编写一个函数，返回一个int数组中存储的最大数值，并在一个简单的程序中测试这个函数。（有缺陷）
fucklike的博客
03-04 4132
/*编写一个函数，返回一个int数组中存储的最大数值，并在一个简单的程序中测试这个函数。 没有完美运行，最后输入的数字总是无法检测*/ #include int max ( int a[],int n); int main () {    int i,c,a[100];    scanf ("%d\n",&c);   // c=a[0];    for (i=0;i
C Primer Plus(第6版) 第十章 编程练习及参考答案
weixin_51614848的博客
02-18 706
C Primer Plus(第6版) 第十章 编程练习及参考答案 编译环境：Microsoft Visual Studio 2019 备注：本文留作作者自用，如有错误敬请指出 （针对Microsoft Visual Studio 2019的一些特性对答案进行了修改） 1.修改程序清单10.7的rain.c程序,用指针进行计算(仍然要声明并初始化数组)。 #include<stdio.h> #include<stdlib.h> #define MONTHS 12 #define YEA
C Prime Plus中文第六版编程题——第十章练习
kasalala的博客
02-15 663
1.修改程序清单10.7的rain.c程序，用指针进行计算（仍然要声明并初始 化数组）。 #include <stdio.h> #include <stdlib.h> #define MONTHS 12 #define YEARS 5 int main() { const float rain[YEARS][MONTHS]={ {4.3, 4.3, ...
如何输入数赋给数组_C语言如何把用户输入的数据存入数组，并编写函数计算平均值（C Primer Plus 10-13）...
weixin_39544333的博客
01-19 1339
程序内容： 提示用户输入3组数，每组数包含5个double类型变量，计算每组数的平均值，全部数值的平均值，数组中的最大值…… 程序为C Primer Plus第十章第十三题的答案示例附：程序代码为本人亲自编写，并非书内标准答案，仅供参考。如果程序有任何bug或者有好的建议，可以在评论区留言，或者私信。程序主调函数代码：#include"deal.h" int main(void) { dou...
关于C语言给变量分配地址
u011235904的博客
07-05 1789
int a，，给变量a分配地址， &a表示地址位置， a表示变量， a=1，表示地址中的数据
C Primer Plus （第六版）中文版 第十章 编程练习答案
11-29 6320
C Primer Plus （第六版）中文版 第十章 编程练习答案
求三个数最大值 用函数)C语言,三个数中寻找最大值的5种方法-C语言实现
weixin_39665302的博客
05-20 8502
写在前面:这里是小王成长日志，一名在校大学生，想在学习之余将自己的学习笔记分享出来，记录自己的成长轨迹，帮助可能需要的人。欢迎关注与留言。某年某月某日，老师给我们布置了一个极其笨拙的方法用来求三个数中的最大值，还在最后让我们找其他方法，这就让我瞬间上了头！ 第一种-使用三元运算符如名字表示的三元运算符需要三个操作数。语法为：条件表达式？表达式1：表达式2。说明：问号前面的位置是判断的条件，判断结果...
编写一个函数，返回一个int数组中最大的元素的值和下标
weixin_44656803的博客
07-30 3447
我们都知道函数返回值只要一个，但是题目要我们实现两个返回值，这样貌似行不通？ 不要着急，我们可以运用指针，通过主函数来调用函数并将变量地址传递给函数，实现在传参的过程。 #include <stdio.h> int backmax(int arr[],int len,int *p); int main() { int arr[] = {1,3,5,8,7,2,5,4,3,5}; ...
(C语言)用函数实现求三个数最大值
热门推荐
Hunter Dreamer的博客
12-08 7万+
题目描述：从键盘输入三个数，之后调用函数实现求三个数的最大值 代码实现： #include&lt;stdio.h&gt; int main() { int qmax(int a,int b,int c); //求最大值函数的声明 int x,y,z; int max_value;//用来存最大值 scanf("%d%d%d",&amp;x,&amp;y,&am...
编写一个函数，返回double数组中最大元素的下标
weixin_57978782的博客
11-21 837
#include <stdio.h> int fun14(double arr[], int len); int main () { /* 4.编写一个函数，返回double数组中最大元素的下标 */ double a[]={1,43.3,5.3,55.6,74.8,2.5}; int maxIndex = fun14(a, sizeof(a) / sizeof(a[0])); printf("%d\n", maxIndex); return 0; } int fun14(dou.
C Primer Plus编程练习2章答案详解
"C Primer Plus 是一本经典的C语言学习书籍，本资源提供了该书第二章的编程练习答案，包括PE2-1至PE2-6的解答，涵盖了基础的输出、变量运算、函数调用等C语言核心概念。" 在这些编程练习中，我们可以看到以下几个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值