C语言指针，定义一个数组a［5］，从键盘上输入元素值，计算平均值，不能有i
本帖最后由 3459606395 于 2023-12-14 12:52 编辑@FishC @FishC #include <stdio.h>
int main() {
int a;
int b;
for(b=0;b<5;b++){
scanf("%d",&a);
}
double k;
for(b=0;b<5;b++){
k+=a;
}
printf("%f\n",k/5);
return 0;
} -kasha 发表于 2023-12-14 13:08
#include
int main() {
int a;
这个b和i不是差不多嘛 #include <stdio.h>
int main() {
double a, 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 发表于 2023-12-14 13:22
这个b和i不是差不多嘛
下面那个代码可以，我也刚学，对于数组指针，又不用for循环 我也不知道怎么输出哈哈哈 @FishC 3459606395 发表于 2024-09-22 17:01
@FishC
你好，有什么计算机相关的问题需要我解答吗？
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 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, c, b, c);
det_2_2 = det_2d(b, c, b, c);
det_2_3 = det_2d(b, c, b, c);
return a * det_2_1 - a * det_2_2 + a * det_2_3;
}
void set_elms(double in_a, double in_b, double in_c)
{
for (int i = 0; i < 3; ++i)
{
a = in_a;
b = in_b;
c = in_c;
}
}
private:
double det_2d(double a, double b, double c, double d)
{
return (a * d - b * c);
}
private:
double a;
double b;
double c;
};
int main()
{
double a = { 1.12, 2.789, 3.4587 };
double b = { 4.47826, 5.25, 6.2415};
double c = { 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= 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, b, c, c);
double det_2_2 = det_2d(b, b, c, c);
double det_2_3 = det_2d(b, b, c, c);
return a * det_2_1 - a * det_2_2 + a * det_2_3;
}
void set_elms(double in_a, double in_b, double in_c)
{
for (int i = 0; i < 3; ++i)
{
a = in_a;
b = in_b;
c = in_c;
}
}
private:
double det_2d(double a, double b, double c, double d)
{
return (a * d - b * c);
}
private:
double a;
double b;
double c;
};
int main()
{
double a = {1.12, 2.789, 3.4587};
double b = {4.47826, 5.25, 6.2415};
double c = {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 小助理，如未能正确解答您的问题，请继续追问。 FishC 发表于 2024-9-22 17:03
你好，这段代码有几个需要修复的地方。我将帮助你逐步改善，使其可以正确编译并运行。
1. `include` ...
实现一个4阶行列式的计算，4阶行列式为A= 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) {
double result = 0;
double submatrix;
// 用拉普拉斯展开公式计算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 = matrix;
subj++;
}
subi++;
}
result += (x % 2 == 0 ? 1 : -1) * matrix * det3x3(submatrix);
}
return result;
}
private:
double det3x3(double matrix) {
double result;
result = matrix * (matrix * matrix - matrix * matrix)
- matrix * (matrix * matrix - matrix * matrix)
+ matrix * (matrix * matrix - matrix * matrix);
return result;
}
};
int main() {
DeterminantSolver solver;
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}
};
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 小助理，如未能正确解答您的问题，请继续追问。 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, b, c, c);
double det_2_2 = det_2d(b, b, c, c);
double det_2_3 = det_2d(b, b, c, c);
return a * det_2_1 - a * det_2_2 + a * det_2_3;
}
void set_elms(double in_a, double in_b, double in_c)
{
for (int i = 0; i < 3; ++i)
{
a = in_a;
b = in_b;
c = in_c;
}
}
private:
double det_2d(double a, double b, double c, double d)
{
return (a * d - b * c);
}
private:
double a;
double b;
double c;
};
int main()
{
double a = {1.12, 2.789, 3.4587};
double b = {4.47826, 5.25, 6.2415};
double c = {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;
}参考这个三阶的代码
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 * matrix - matrix * matrix;
}
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 * 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 = matrix;
}
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 小助理，如未能正确解答您的问题，请继续追问。 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, c, d);
double det_3_2 = det_3d(b, c, d);
double det_3_3 = det_3d(b, c, d);
return a * det_3_1 - b * det_3_2 + c * det_3_3; // 使用第一行展开
}
void set_elms(double in_a, double in_b, double in_c, double in_d) {
for (int i = 0; i < 4; ++i) {
a = in_a;
b = in_b;
c = in_c;
d = in_d;
}
}
private:
double det_3d(double b[], double c[], double d[]) {
double det_2_1 = det_2d(b, c, b, c);
double det_2_2 = det_2d(b, c, b, c);
double det_2_3 = det_2d(b, c, b, c);
return b * det_2_1 - b * det_2_2 + b * det_2_3; // 使用 b 数组的元素
}
double det_2d(double a, double b, double c, double d) {
return (a * d - b * c);
}
private:
double a;
double b;
double c;
double d;
};
int main() {
double a = { 1, 2, 3, 4 }; // 第一列元素
double b = { 4, 2, 5, 3 }; // 第二列元素
double c = { 5, 7, 8.1, 4 }; // 第三列元素
double d = { 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;
}
有什么问题 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, int n) {
if (n == 2) {
return det_2d(matrix);
}
double result = 0.0;
double temp;
for (int k = 0; k < n; ++k) {
get_cofactor(matrix, temp, 0, k, n);
result += (k % 2 == 0 ? 1 : -1) * matrix * get_det(temp, n-1);
}
return result;
}
private:
double det_2d(double matrix) {
return (matrix * matrix - matrix * matrix);
}
void get_cofactor(double matrix, double temp, 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 = matrix;
if (j == n - 1) {
j = 0;
i++;
}
}
}
}
}
};
int main() {
double matrix = {
{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 小助理，如未能正确解答您的问题，请继续追问。 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, c, d);
double det_3_2 = det_3d(b, c, d);
double det_3_3 = det_3d(b, c, d);
return a * det_3_1 - b * det_3_2 + c * det_3_3; // 使用第一行展开
}
void set_elms(double in_a, double in_b, double in_c, double in_d) {
for (int i = 0; i < 4; ++i) {
a = in_a;
b = in_b;
c = in_c;
d = in_d;
}
}
private:
double det_3d(double b[], double c[], double d[]) {
double det_2_1 = det_2d(b, c, b, c);
double det_2_2 = det_2d(b, c, b, c);
double det_2_3 = det_2d(b, c, b, c);
return b * det_2_1 - b * det_2_2 + b * det_2_3; // 使用 b 数组的元素
}
double det_2d(double a, double b, double c, double d) {
return (a * d - b * c);
}
private:
double a;
double b;
double c;
double d;
};
int main() {
double a = { 1, 2, 3, 4 }; // 第一列元素
double b = { 4, 2, 5, 3 }; // 第二列元素
double c = { 5, 7, 8.1, 4 }; // 第三列元素
double d = { 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;
}
修改代码 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) {
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
matrix = mat;
}
}
}
private:
double det_4d(double mat[4
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 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, b, c, d);
det_3_2 = det_3d(a, b, c, d);
det_3_3 = det_3d(a, b, c, d);
det_3_4 = det_3d(a, b, c, d);
return a * det_3_1 - a * det_3_2 + a * det_3_3 - a * det_3_4;
}
void set_elms(double in_a, double in_b, double in_c, double in_d)
{
for (int i = 0; i < 4; ++i)
{
a = in_a;
b = in_b;
c = in_c;
d = in_d;
}
}
private:
double det_3d(double a1, double b1, double c1, double d1)
{
return (a1 * det_2d(b, c, b, c) -
b1 * det_2d(a, c, a, c) +
c1 * det_2d(a, b, a, b) -
d1 * det_2d(a, b, a, b));
}
double det_2d(double a, double b, double c, double d)
{
return (a * d - b * c);
}
private:
double a;
double b;
double c;
double d;
};
int main()
{
double a = { 1, 2, 3, 4 };
double b = { 4, 2, 5, 3 };
double c = { 5, 7, 8.1, 4 };
double d = { 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';
}
检查
页:
[1]
2