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

3459606395

@FishC

最佳答案

月排行榜 / 总排行榜

zhangjinxuan

2023-12-14 13:26:14

#include <stdio.h>

int main() {
        double a[5], sum;
        scanf("%lf%lf%lf%lf%lf", a, a + 1, a + 2, a + 3, a + 4);
        sum = *(a) + *(a + 1) + *(a + 2) + *(a + 3) + *(a + 4);
        printf("%lf\n", sum / 5.0);
}

跳转到最佳答案楼层

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

#include <stdio.h>

int main() {
        double a[5], sum;
        scanf("%lf%lf%lf%lf%lf", a, a + 1, a + 2, a + 3, a + 4);
        sum = *(a) + *(a + 1) + *(a + 2) + *(a + 3) + *(a + 4);
        printf("%lf\n", sum / 5.0);
}

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` 函数在循环内直接给成员变量赋值是错误的。

以下是改进后的代码：

#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;
}

这段代码在设置矩阵元素、计算 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阶行列式：

#include <iostream>

using namespace std;

class DeterminantSolver {
public:
    double det4x4(double matrix[4][4]) {
        double result = 0;
        double submatrix[3][3];
        
        // 用拉普拉斯展开公式计算4阶行列式
        for (int x = 0; x < 4; x++) {
            int subi = 0;
            for (int i = 1; i < 4; i++) {
                int subj = 0;
                for (int j = 0; j < 4; j++) {
                    if (j == x) {
                        continue;
                    }
                    submatrix[subi][subj] = matrix[i][j];
                    subj++;
                }
                subi++;
            }
            result += (x % 2 == 0 ? 1 : -1) * matrix[0][x] * det3x3(submatrix);
        }

        return result;
    }

private:
    double det3x3(double matrix[3][3]) {
        double result;
        result = matrix[0][0] * (matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1])
               - matrix[0][1] * (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0])
               + matrix[0][2] * (matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]);

        return result;
    }
};

int main() {
    DeterminantSolver solver;
    double matrix[4][4] = {
        {1.0, 2.0, 3.0, 4.0},
        {5.0, 6.0, 7.0, 8.0},
        {9.0, 10.0, 11.0, 12.0},
        {13.0, 14.0, 15.0, 16.0}
    };

    double result = solver.det4x4(matrix);

    cout << "The determinant of the 4x4 matrix is: " << result << endl;

    return 0;
}

这个示例代码实现了一个 `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阶行列式的代码。

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

#include <iostream>
#include <vector>

using namespace std;

class DeterminantSolver 
{
public:
    double computeDeterminant(const vector<vector<double>>& matrix) 
    {
        int n = matrix.size();
        if (n == 2) 
        {
            return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
        }

        double det = 0.0;
        for (int i = 0; i < n; ++i) 
        {
            vector<vector<double>> subMatrix = getSubMatrix(matrix, 0, i);
            det += (i % 2 == 0 ? 1 : -1) * matrix[0][i] * computeDeterminant(subMatrix);
        }
        return det;
    }

private:
    vector<vector<double>> getSubMatrix(const vector<vector<double>>& matrix, int p, int q) 
    {
        int n = matrix.size();
        vector<vector<double>> subMatrix(n - 1, vector<double>(n - 1));

        int row = 0;
        for (int i = 0; i < n; ++i) 
        {
            if (i == p) continue;
            int col = 0;
            for (int j = 0; j < n; ++j) 
            {
                if (j == q) continue;
                subMatrix[row][col++] = matrix[i][j];
            }
            row++;
        }
        return subMatrix;
    }
};

int main() 
{
    vector<vector<double>> matrix = {
        {1.0, 2.0, 3.0, 4.0},
        {5.0, 6.0, 7.0, 8.0},
        {9.0, 10.0, 11.0, 12.0},
        {13.0, 14.0, 15.0, 16.0}
    };

    DeterminantSolver solver;
    double det = solver.computeDeterminant(matrix);

    cout << "The determinant is: " << det << endl;

    return 0;
}

解释：
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矩阵的数据:

#include <iostream>
using namespace std;

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

    double get_det(double matrix[4][4], int n) {
        if (n == 2) {
            return det_2d(matrix);
        }
        double result = 0.0;
        double temp[4][4];
        for (int k = 0; k < n; ++k) {
            get_cofactor(matrix, temp, 0, k, n);
            result += (k % 2 == 0 ? 1 : -1) * matrix[0][k] * get_det(temp, n-1);
        }
        return result;
    }

private:
    double det_2d(double matrix[4][4]) {
        return (matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]);
    }

    void get_cofactor(double matrix[4][4], double temp[4][4], int p, int q, int n) {
        int i = 0, j = 0;
        for (int row = 0; row < n; row++) {
            for (int col = 0; col < n; col++) {
                if (row != p && col != q) {
                    temp[i][j++] = matrix[row][col];
                    if (j == n - 1) {
                        j = 0;
                        i++;
                    }
                }
            }
        }
    }
};

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

    det_solver solver;
    double result = solver.get_det(matrix, 4);

    cout << "Determinant: " << result << endl;

    return 0;
}

简要说明：
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';
}
检查