[已解决]C语言指针，定义一个数组a［5］，从键盘上输入元素值，计算平均值，不能有i

3459606395

@FishC

最佳答案

月排行榜 / 总排行榜

zhangjinxuan

2023-12-14 13:26:14

1. #include <stdio.h>
   
2. 
   
3. int main() {
   
4.         double a[5], sum;
   
5.         scanf("%lf%lf%lf%lf%lf", a, a + 1, a + 2, a + 3, a + 4);
   
6.         sum = *(a) + *(a + 1) + *(a + 2) + *(a + 3) + *(a + 4);
   
7.         printf("%lf\n", sum / 5.0);
   
8. }

复制代码

跳转到最佳答案楼层

3459606395

@FishC

-kasha

#include <stdio.h>
int main() {
    int a[5];
    int b;
    for(b=0;b<5;b++){
            scanf("%d",&a[b]);
        }
        double k;
        for(b=0;b<5;b++){
                k+=a[b];
        }
        printf("%f\n",k/5);
        return 0;
}

3459606395

-kasha 发表于 2023-12-14 13:08
#include
int main() {
    int a[5];

这个b和i不是差不多嘛

zhangjinxuan

1. #include <stdio.h>
   
2. 
   
3. int main() {
   
4.         double a[5], sum;
   
5.         scanf("%lf%lf%lf%lf%lf", a, a + 1, a + 2, a + 3, a + 4);
   
6.         sum = *(a) + *(a + 1) + *(a + 2) + *(a + 3) + *(a + 4);
   
7.         printf("%lf\n", sum / 5.0);
   
8. }

复制代码

3459606395

刚学指针，谢谢你们的分享，对了这里可以删帖子吗，好像看不到删除

-kasha

3459606395 发表于 2023-12-14 13:22
这个b和i不是差不多嘛

下面那个代码可以，我也刚学，对于数组指针，又不用for循环 我也不知道怎么输出哈哈哈

3459606395

@FishC

FishC

3459606395 发表于 2024-09-22 17:01
@FishC

你好，有什么计算机相关的问题需要我解答吗？

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:01
你好，有什么计算机相关的问题需要我解答吗？

以上回复来自 FishC AI 小助理，如未能正确解答您的问 ...

include <iostream>

using namespace std;


class det_3d_solver
{

public:
    det_3d_solver() {}
    ~det_3d_solver() {}


    double get_rlt()
    {
        double det_2_1, det_2_2, det_2_3;
        det_2_1 = det_2d(b[1], c[1], b[2], c[2]);
        det_2_2 = det_2d(b[0], c[0], b[2], c[2]);
        det_2_3 = det_2d(b[0], c[0], b[1], c[1]);

        return a[0] * det_2_1 - a[1] * det_2_2 + a[2] * det_2_3;
    }

    void set_elms(double in_a[3], double in_b[3], double in_c[3])
    {
        for (int i = 0; i < 3; ++i)
        {
            a[i] = in_a[i];
            b[i] = in_b[i];
            c[i] = in_c[i];
        }
    }

private:
    double det_2d(double a, double b, double c, double d)
    {
        return (a * d - b * c);
    }
private:
    double a[3];
    double b[3];
    double c[3];
};




int main()
{
    double a[3] = { 1.12, 2.789, 3.4587 };
    double b[3] = { 4.47826, 5.25, 6.2415};
    double c[3] = { 7.0214, 8.547, 9.08 };

    det_3d_solver solver_3d;
    solver_3d.set_elms(a, b, c);
    double rlt = solver_3d.get_rlt();

   

    cout << "The result of det of 3*3 matrix is " << rlt << '\n';
}参考三阶行列式，实现一个4阶行列式的计算，4阶行列式为A=[1 2 3 4; 4 2 5 3; 5 7 8.1 4; 6 5 2 1]

FishC

3459606395 发表于 2024-09-22 17:02
include

using namespace std;


class det_3d ...

你好，这段代码有几个需要修复的地方。我将帮助你逐步改善，使其可以正确编译并运行。

1. `include` 应该是 `#include <iostream>`
2. `a`, `b` 和 `c` 作为数组传递给 `set_elms` 函数时，你应该改变这些变量以便函数正确地使用它们。
3. `det_2d` 函数计算的参数应该是 2D 矩阵而不是单独的元素。
4. `set_elms` 函数在循环内直接给成员变量赋值是错误的。

以下是改进后的代码：

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class det_3d_solver
   
6. {
   
7. public:
   
8.     det_3d_solver() {}
   
9.     ~det_3d_solver() {}
   
10. 
    
11.     double get_rlt()
    
12.     {
    
13.         double det_2_1 = det_2d(b[1], b[2], c[1], c[2]);
    
14.         double det_2_2 = det_2d(b[0], b[2], c[0], c[2]);
    
15.         double det_2_3 = det_2d(b[0], b[1], c[0], c[1]);
    
16. 
    
17.         return a[0] * det_2_1 - a[1] * det_2_2 + a[2] * det_2_3;
    
18.     }
    
19. 
    
20.     void set_elms(double in_a[3], double in_b[3], double in_c[3])
    
21.     {
    
22.         for (int i = 0; i < 3; ++i)
    
23.         {
    
24.             a[i] = in_a[i];
    
25.             b[i] = in_b[i];
    
26.             c[i] = in_c[i];
    
27.         }
    
28.     }
    
29. 
    
30. private:
    
31.     double det_2d(double a, double b, double c, double d)
    
32.     {
    
33.         return (a * d - b * c);
    
34.     }
    
35. private:
    
36.     double a[3];
    
37.     double b[3];
    
38.     double c[3];
    
39. };
    
40. 
    
41. int main()
    
42. {
    
43.     double a[3] = {1.12, 2.789, 3.4587};
    
44.     double b[3] = {4.47826, 5.25, 6.2415};
    
45.     double c[3] = {7.0214, 8.547, 9.08};
    
46. 
    
47.     det_3d_solver solver_3d;
    
48.     solver_3d.set_elms(a, b, c);
    
49.     double rlt = solver_3d.get_rlt();
    
50. 
    
51.     cout << "Determinant: " << rlt << endl;
    
52. 
    
53.     return 0;
    
54. }

复制代码

这段代码在设置矩阵元素、计算 2x2 行列式和计算整个 3x3 行列式方面现在应该都能正确运行。如果有其他问题，随时提问哦！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:03
你好，这段代码有几个需要修复的地方。我将帮助你逐步改善，使其可以正确编译并运行。

1. `include` ...

实现一个4阶行列式的计算，4阶行列式为A=[1 2 3 4; 4 2 5 3; 5 7 8.1 4; 6 5 2 1]

FishC

3459606395 发表于 2024-09-22 17:04
实现一个4阶行列式的计算，4阶行列式为A=

要实现一个4阶行列式的计算，你可以使用递归的方法，将4阶行列式分解为多个3阶行列式，直到2阶行列式为止。这是一种称为拉普拉斯展开的方法。

这里是一个示例代码，用于计算4阶行列式：

1. #include <iostream>
   
2. 
   
3. using namespace std;
   
4. 
   
5. class DeterminantSolver {
   
6. public:
   
7.     double det4x4(double matrix[4][4]) {
   
8.         double result = 0;
   
9.         double submatrix[3][3];
   
10.         
    
11.         // 用拉普拉斯展开公式计算4阶行列式
    
12.         for (int x = 0; x < 4; x++) {
    
13.             int subi = 0;
    
14.             for (int i = 1; i < 4; i++) {
    
15.                 int subj = 0;
    
16.                 for (int j = 0; j < 4; j++) {
    
17.                     if (j == x) {
    
18.                         continue;
    
19.                     }
    
20.                     submatrix[subi][subj] = matrix[i][j];
    
21.                     subj++;
    
22.                 }
    
23.                 subi++;
    
24.             }
    
25.             result += (x % 2 == 0 ? 1 : -1) * matrix[0][x] * det3x3(submatrix);
    
26.         }
    
27. 
    
28.         return result;
    
29.     }
    
30. 
    
31. private:
    
32.     double det3x3(double matrix[3][3]) {
    
33.         double result;
    
34.         result = matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1])
    
35.                - matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0])
    
36.                + matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);
    
37. 
    
38.         return result;
    
39.     }
    
40. };
    
41. 
    
42. int main() {
    
43.     DeterminantSolver solver;
    
44.     double matrix[4][4] = {
    
45.         {1.0, 2.0, 3.0, 4.0},
    
46.         {5.0, 6.0, 7.0, 8.0},
    
47.         {9.0, 10.0, 11.0, 12.0},
    
48.         {13.0, 14.0, 15.0, 16.0}
    
49.     };
    
50. 
    
51.     double result = solver.det4x4(matrix);
    
52. 
    
53.     cout << "The determinant of the 4x4 matrix is: " << result << endl;
    
54. 
    
55.     return 0;
    
56. }

复制代码

这个示例代码实现了一个 `DeterminantSolver` 类，该类提供了计算4阶和3阶行列式的能力。在 `main` 函数中，我们创建了一个4x4的矩阵，并使用 `det4x4` 方法来计算它的行列式。

你可以根据需要修改矩阵的内容来进行测试。确保你理解了递归计算行列式的方法，这对于处理更高阶的行列式是非常有用的。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:04
要实现一个4阶行列式的计算，你可以使用递归的方法，将4阶行列式分解为多个3阶行列式，直到2阶行列式为 ...

#include <iostream>

using namespace std;

class det_3d_solver
{
public:
    det_3d_solver() {}
    ~det_3d_solver() {}

    double get_rlt()
    {
        double det_2_1 = det_2d(b[1], b[2], c[1], c[2]);
        double det_2_2 = det_2d(b[0], b[2], c[0], c[2]);
        double det_2_3 = det_2d(b[0], b[1], c[0], c[1]);

        return a[0] * det_2_1 - a[1] * det_2_2 + a[2] * det_2_3;
    }

    void set_elms(double in_a[3], double in_b[3], double in_c[3])
    {
        for (int i = 0; i < 3; ++i)
        {
            a[i] = in_a[i];
            b[i] = in_b[i];
            c[i] = in_c[i];
        }
    }

private:
    double det_2d(double a, double b, double c, double d)
    {
        return (a * d - b * c);
    }
private:
    double a[3];
    double b[3];
    double c[3];
};

int main()
{
    double a[3] = {1.12, 2.789, 3.4587};
    double b[3] = {4.47826, 5.25, 6.2415};
    double c[3] = {7.0214, 8.547, 9.08};

    det_3d_solver solver_3d;
    solver_3d.set_elms(a, b, c);
    double rlt = solver_3d.get_rlt();

    cout << "Determinant: " << rlt << endl;

    return 0;
}参考这个三阶的代码

FishC

3459606395 发表于 2024-09-22 17:05
#include

using namespace std;

class det_3d_ ...

为了计算一个4阶行列式，我们可以实现一个递归函数来计算任意阶的行列式。你提到的代码中存在一些问题，我们逐步修正并实现一个能够计算4阶行列式的代码。

首先，我们需要一个能够处理任意阶行列式的类。接下来是代码实现：

1. #include <iostream>
   
2. #include <vector>
   
3. 
   
4. using namespace std;
   
5. 
   
6. class DeterminantSolver
   
7. {
   
8. public:
   
9.     double computeDeterminant(const vector<vector<double>>& matrix)
   
10.     {
    
11.         int n = matrix.size();
    
12.         if (n == 2)
    
13.         {
    
14.             return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    
15.         }
    
16. 
    
17.         double det = 0.0;
    
18.         for (int i = 0; i < n; ++i)
    
19.         {
    
20.             vector<vector<double>> subMatrix = getSubMatrix(matrix, 0, i);
    
21.             det += (i % 2 == 0 ? 1 : -1) * matrix[0][i] * computeDeterminant(subMatrix);
    
22.         }
    
23.         return det;
    
24.     }
    
25. 
    
26. private:
    
27.     vector<vector<double>> getSubMatrix(const vector<vector<double>>& matrix, int p, int q)
    
28.     {
    
29.         int n = matrix.size();
    
30.         vector<vector<double>> subMatrix(n - 1, vector<double>(n - 1));
    
31. 
    
32.         int row = 0;
    
33.         for (int i = 0; i < n; ++i)
    
34.         {
    
35.             if (i == p) continue;
    
36.             int col = 0;
    
37.             for (int j = 0; j < n; ++j)
    
38.             {
    
39.                 if (j == q) continue;
    
40.                 subMatrix[row][col++] = matrix[i][j];
    
41.             }
    
42.             row++;
    
43.         }
    
44.         return subMatrix;
    
45.     }
    
46. };
    
47. 
    
48. int main()
    
49. {
    
50.     vector<vector<double>> matrix = {
    
51.         {1.0, 2.0, 3.0, 4.0},
    
52.         {5.0, 6.0, 7.0, 8.0},
    
53.         {9.0, 10.0, 11.0, 12.0},
    
54.         {13.0, 14.0, 15.0, 16.0}
    
55.     };
    
56. 
    
57.     DeterminantSolver solver;
    
58.     double det = solver.computeDeterminant(matrix);
    
59. 
    
60.     cout << "The determinant is: " << det << endl;
    
61. 
    
62.     return 0;
    
63. }

复制代码

解释：
1. `computeDeterminant` 方法用于计算任意阶行列式。对于2阶行列式，它直接返回结果，对于更高阶的行列式，它使用递归的方法。
2. `getSubMatrix` 方法用于获取子矩阵，用于递归计算行列式。
3. 在 `main` 函数中，我们定义了一个4阶的矩阵，调用 `computeDeterminant` 方法计算其行列式，并输出结果。

这段代码将帮助你计算任何阶的行列式，只需要扩展矩阵的维度即可。希望这能帮助到你！如果有其他问题，欢迎继续提问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:05
为了计算一个4阶行列式，我们可以实现一个递归函数来计算任意阶的行列式。你提到的代码中存在一些问题 ...

#include <iostream>

using namespace std;

class det_4d_solver {
public:
    det_4d_solver() {}
    ~det_4d_solver() {}

    double get_rlt() {
        double det_3_1 = det_3d(b[1], c[1], d[1]);
        double det_3_2 = det_3d(b[2], c[2], d[2]);
        double det_3_3 = det_3d(b[3], c[3], d[3]);

        return a[0] * det_3_1 - b[0] * det_3_2 + c[0] * det_3_3; // 使用第一行展开
    }

    void set_elms(double in_a[4], double in_b[4], double in_c[4], double in_d[4]) {
        for (int i = 0; i < 4; ++i) {
            a[i] = in_a[i];
            b[i] = in_b[i];
            c[i] = in_c[i];
            d[i] = in_d[i];
        }
    }

private:
    double det_3d(double b[], double c[], double d[]) {
        double det_2_1 = det_2d(b[1], c[1], b[2], c[2]);
        double det_2_2 = det_2d(b[0], c[0], b[2], c[2]);
        double det_2_3 = det_2d(b[0], c[0], b[1], c[1]);

        return b[0] * det_2_1 - b[1] * det_2_2 + b[2] * det_2_3; // 使用 b 数组的元素
    }

    double det_2d(double a, double b, double c, double d) {
        return (a * d - b * c);
    }

private:
    double a[4];
    double b[4];
    double c[4];
    double d[4];
};

int main() {
    double a[4] = { 1, 2, 3, 4 }; // 第一列元素
    double b[4] = { 4, 2, 5, 3 }; // 第二列元素
    double c[4] = { 5, 7, 8.1, 4 }; // 第三列元素
    double d[4] = { 6, 5, 2, 1 }; // 第四列元素

    det_4d_solver solver_4d;
    solver_4d.set_elms(a, b, c, d);
    double rlt = solver_4d.get_rlt();

    cout << "The result of det of 4*4 matrix is " << rlt << '\n';

    return 0;
}
有什么问题

FishC

3459606395 发表于 2024-09-22 17:07
#include

using namespace std;

class det_4d_ ...

看来您代码中有一些问题需要改进，让我们来重新整理一下。以下是一个可以计算4阶行列式的方案，使用递归来求解。把 `det_4d_solver` 类改改，让它能够处理4x4矩阵的数据:

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. class det_solver {
   
5. public:
   
6.     det_solver() {}
   
7.     ~det_solver() {}
   
8. 
   
9.     double get_det(double matrix[4][4], int n) {
   
10.         if (n == 2) {
    
11.             return det_2d(matrix);
    
12.         }
    
13.         double result = 0.0;
    
14.         double temp[4][4];
    
15.         for (int k = 0; k < n; ++k) {
    
16.             get_cofactor(matrix, temp, 0, k, n);
    
17.             result += (k % 2 == 0 ? 1 : -1) * matrix[0][k] * get_det(temp, n-1);
    
18.         }
    
19.         return result;
    
20.     }
    
21. 
    
22. private:
    
23.     double det_2d(double matrix[4][4]) {
    
24.         return (matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]);
    
25.     }
    
26. 
    
27.     void get_cofactor(double matrix[4][4], double temp[4][4], int p, int q, int n) {
    
28.         int i = 0, j = 0;
    
29.         for (int row = 0; row < n; row++) {
    
30.             for (int col = 0; col < n; col++) {
    
31.                 if (row != p && col != q) {
    
32.                     temp[i][j++] = matrix[row][col];
    
33.                     if (j == n - 1) {
    
34.                         j = 0;
    
35.                         i++;
    
36.                     }
    
37.                 }
    
38.             }
    
39.         }
    
40.     }
    
41. };
    
42. 
    
43. int main() {
    
44.     double matrix[4][4] = {
    
45.         {1, 2, 3, 4},
    
46.         {4, 2, 5, 3},
    
47.         {5, 7, 8.1, 4},
    
48.         {6, 5, 2, 1}
    
49.     };
    
50. 
    
51.     det_solver solver;
    
52.     double result = solver.get_det(matrix, 4);
    
53. 
    
54.     cout << "Determinant: " << result << endl;
    
55. 
    
56.     return 0;
    
57. }

复制代码

简要说明：
1. `get_det`：递归函数，计算行列式的值。当n为2时，直接计算2x2行列式，否则用递归。
2. `det_2d`：计算2x2行列式的值。
3. `get_cofactor`：获取子行列式，去掉指定的行和列。

执行上面的代码，它将打印所给4x4矩阵的行列式值。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:08
看来您代码中有一些问题需要改进，让我们来重新整理一下。以下是一个可以计算4阶行列式的方案，使用递 ...

#include <iostream>

using namespace std;

class det_4d_solver {
public:
    det_4d_solver() {}
    ~det_4d_solver() {}

    double get_rlt() {
        double det_3_1 = det_3d(b[1], c[1], d[1]);
        double det_3_2 = det_3d(b[2], c[2], d[2]);
        double det_3_3 = det_3d(b[3], c[3], d[3]);

        return a[0] * det_3_1 - b[0] * det_3_2 + c[0] * det_3_3; // 使用第一行展开
    }

    void set_elms(double in_a[4], double in_b[4], double in_c[4], double in_d[4]) {
        for (int i = 0; i < 4; ++i) {
            a[i] = in_a[i];
            b[i] = in_b[i];
            c[i] = in_c[i];
            d[i] = in_d[i];
        }
    }

private:
    double det_3d(double b[], double c[], double d[]) {
        double det_2_1 = det_2d(b[1], c[1], b[2], c[2]);
        double det_2_2 = det_2d(b[0], c[0], b[2], c[2]);
        double det_2_3 = det_2d(b[0], c[0], b[1], c[1]);

        return b[0] * det_2_1 - b[1] * det_2_2 + b[2] * det_2_3; // 使用 b 数组的元素
    }

    double det_2d(double a, double b, double c, double d) {
        return (a * d - b * c);
    }

private:
    double a[4];
    double b[4];
    double c[4];
    double d[4];
};

int main() {
    double a[4] = { 1, 2, 3, 4 }; // 第一列元素
    double b[4] = { 4, 2, 5, 3 }; // 第二列元素
    double c[4] = { 5, 7, 8.1, 4 }; // 第三列元素
    double d[4] = { 6, 5, 2, 1 }; // 第四列元素

    det_4d_solver solver_4d;
    solver_4d.set_elms(a, b, c, d);
    double rlt = solver_4d.get_rlt();

    cout << "The result of det of 4*4 matrix is " << rlt << '\n';

    return 0;
}
修改代码

FishC

3459606395 发表于 2024-09-22 17:08
#include

using namespace std;

class det_4d_ ...

你提供的代码片段存在一些问题。这些问题包括变量 `a`, `b`, `c`, `d` 的定义和使用有矛盾。为了计算一个 4x4 行列式，需要重新设计代码结构。以下是一个较完整和正确的例子：

```cpp
#include <iostream>

using namespace std;

class det_4d_solver {
public:
    det_4d_solver() {}
    ~det_4d_solver() {}

    double get_rlt() {
        return det_4d(matrix);
    }

    void set_elms(double mat[4][4]) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                matrix[i][j] = mat[i][j];
            }
        }
    }

private:
    double det_4d(double mat[4][4

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

3459606395

FishC 发表于 2024-9-22 17:08
你提供的代码片段存在一些问题。这些问题包括变量 `a`, `b`, `c`, `d` 的定义和使用有矛盾。为了计算一 ...

#include <iostream>

using namespace std;

class det_4d_solver
{
public:
    det_4d_solver() {}
    ~det_4d_solver() {}

    double get_rlt()
    {
        double det_3_1, det_3_2, det_3_3, det_3_4;
        det_3_1 = det_3d(a[0], b[0], c[0], d[0]);
        det_3_2 = det_3d(a[1], b[1], c[1], d[1]);
        det_3_3 = det_3d(a[2], b[2], c[2], d[2]);
        det_3_4 = det_3d(a[3], b[3], c[3], d[3]);

        return a[0] * det_3_1 - a[1] * det_3_2 + a[2] * det_3_3 - a[3] * det_3_4;
    }

    void set_elms(double in_a[4], double in_b[4], double in_c[4], double in_d[4])
    {
        for (int i = 0; i < 4; ++i)
        {
            a[i] = in_a[i];
            b[i] = in_b[i];
            c[i] = in_c[i];
            d[i] = in_d[i];
        }
    }

private:
    double det_3d(double a1, double b1, double c1, double d1)
    {
        return (a1 * det_2d(b[1], c[1], b[2], c[2]) -
                b1 * det_2d(a[1], c[1], a[2], c[2]) +
                c1 * det_2d(a[1], b[1], a[2], b[2]) -
                d1 * det_2d(a[1], b[1], a[2], b[2]));
    }

    double det_2d(double a, double b, double c, double d)
    {
        return (a * d - b * c);
    }

private:
    double a[4];
    double b[4];
    double c[4];
    double d[4];
};

int main()
{
    double a[4] = { 1, 2, 3, 4 };
    double b[4] = { 4, 2, 5, 3 };
    double c[4] = { 5, 7, 8.1, 4 };
    double d[4] = { 6, 5, 2, 1 };

    det_4d_solver solver_4d;
    solver_4d.set_elms(a, b, c, d);
    double rlt = solver_4d.get_rlt();

    cout << "The result of det of 4x4 matrix is " << rlt << '\n';
}
检查