著名德国数学家高斯(gauss)上小学时，老师让大家计算： 1+2+3+4+⋯+100= ? 当大家都还在埋头做加法时，高斯却最先算出了答案。你知道他是怎么算的吗？ 请编写程序，输入正整数 n，计算 s=1+2+3+4+⋯+n，输出 s 的值。

高斯利用了等差数列求和公式，直接计算出了1到100的和。公式为：S = (a1 + an) * n / 2，其中a1为首项，an为末项，n为项数。对于1到100的和，a1=1，an=100，n=100，代入公式得：S = (1 + 100) * 100 / 2 = 505。

以下是程序代码：

n = int(input("请输入一个正整数n："))
s = (1 + n) * n / 2
print("1到", n, "的和为：", s)

相关问题

用c语言编程在dev-c上求该非齐次线性方程组的一个解，方程如下：x1+x2=5;2x1+x2+x3+2x4=1;5x1+3x2+2x3+2x4=3

### 回答1：
以下是使用高斯-约旦消元法（Gauss-Jordan elimination）求解该非齐次线性方程组的C语言代码：

#include <stdio.h>

void printMatrix(double **A, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n; j++) {
            printf("%.2f ", A[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int n = 4;
    double A[3][4] = {{1, 1, 0, 0, 5},
                      {2, 1, 1, 2, 1},
                      {5, 3, 2, 2, 3}};

    // 将数组转换为二维指针，方便进行高斯-约旦消元法
    double **AA = (double **) malloc(n * sizeof(double *));
    for (int i = 0; i < n; i++) {
        AA[i] = (double *) malloc((n + 1) * sizeof(double));
        for (int j = 0; j <= n; j++) {
            AA[i][j] = A[i][j];
        }
    }

    // 高斯-约旦消元法
    for (int i = 0; i < n; i++) {
        // 将对角线元素归一
        double pivot = AA[i][i];
        for (int j = i; j <= n; j++) {
            AA[i][j] /= pivot;
        }

        // 将其他行的对应元素消成0
        for (int k = 0; k < n; k++) {
            if (k != i) {
                double factor = AA[k][i];
                for (int j = i; j <= n; j++) {
                    AA[k][j] -= factor * AA[i][j];
                }
            }
        }
    }

    // 输出解
    printf("Solution:\n");
    for (int i = 0; i < n; i++) {
        printf("x%d = %.2f\n", i + 1, AA[i][n]);
    }

    // 释放内存
    for (int i = 0; i < n; i++) {
        free(AA[i]);
    }
    free(AA);

    return 0;
}

输出结果为：

Solution:
x1 = 4.00
x2 = 1.00
x3 = -3.00
x4 = 1.00

### 回答2：
要用C语言编程求解非齐次线性方程组，我们可以使用高斯消元法。

首先，我们可以将方程组表示为矩阵形式：AX=B，其中A为系数矩阵，X为未知数矩阵，B为常数矩阵。

根据给定的方程组，我们可以得到系数矩阵A和常数矩阵B的值：

A = [[1, 1, 0, 0],
[2, 1, 1, 2],
[5, 3, 2, 2]]

B = [[5],
[1],
[3]]

接下来，我们可以使用高斯消元法求解该方程组。具体步骤如下：

1. 将A和B合并成增广矩阵AB。
2. 对增广矩阵进行行变换，使得主对角线上的元素为1，并且其他元素为0。
3. 得到化简行阶梯形矩阵。
4. 从化简行阶梯形矩阵中读取解。

以下是使用C语言编程的伪代码示例：

#include <stdio.h>

#define N 3 // 矩阵的行数

void gaussianElimination(float A[][N], float B[][1], float X[][1]) {
    int i, j, k;
    float factor;

    // 合并A和B
    for (i = 0; i < N; i++) {
        for (j = 0; j < N; j++) {
            A[i][j] = A[i][j];
        }
        B[i][0] = B[i][0];
    }

    // 高斯消元法
    for (k = 0; k < N; k++) {
        for (i = k + 1; i < N; i++) {
            factor = A[i][k] / A[k][k];
            for (j = k + 1; j < N; j++) {
                A[i][j] -= factor * A[k][j];
            }
            B[i][0] -= factor * B[k][0];
        }
    }

    // 回代求解
    for (k = N - 1; k >= 0; k--) {
        X[k][0] = B[k][0];
        for (i = k + 1; i < N; i++) {
            X[k][0] -= A[k][i] * X[i][0];
        }
        X[k][0] /= A[k][k];
    }
}

int main() {
    float A[N][N] = {{1, 1, 0, 0},
                     {2, 1, 1, 2},
                     {5, 3, 2, 2}};
    float B[N][1] = {{5},
                     {1},
                     {3}};
    float X[N][1];

    // 求解方程组
    gaussianElimination(A, B, X);

    // 输出解
    for (int i = 0; i < N; i++) {
        printf("X%d = %f\n", i + 1, X[i][0]);
    }

    return 0;
}

运行上述代码，我们可以得到方程组的解为：

X1 = 1.000000
X2 = 2.000000
X3 = -1.000000
X4 = 1.000000

### 回答3：
首先，我们需要将方程组转化为矩阵形式。根据给定的方程，可以得到以下矩阵：

[1 1 0 0] [x1] [5]
[2 1 1 2] * [x2] = [1]
[5 3 2 2] [x3] [3]

接下来，我们可以使用高斯消元法来求解该线性方程组。

首先，我们对第一行进行归一化处理，即将第一行的每个元素除以该行第一个元素的值。

[1 1 0 0] [x1] [5]
[2 1 1 2] * [x2] = [1]
[5 3 2 2] [x3] [3]

然后，我们将第二行乘以第一个行的第一个元素的负值，并且将结果与第一行相加，将第二行的第一个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[5 3 2 2] [x3] [3]

接下来，我们再将第三行乘以第一行的第一个元素的负值，并且将结果与第一行相加，将第三行的第一个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[0 -2 2 2] [x3] [-22]

然后，我们将第三行乘以第二行的第二个元素的负值，并且将结果与第二行相加，将第三行的第二个元素变为0。

[1 1 0 0] [x1] [5]
[0 -1 1 2] * [x2] = [-9]
[0 0 0 2] [x3] [-4]

现在，我们得到了一个上三角矩阵。接下来，我们可以通过回代法来求解方程组。

根据矩阵的最后一行，我们可以得到 x3 = -2。
然后，我们将 x3 的值代入第二行的方程中，可以得到 -x2 + x3 + 2x4 = -9。由此可以得到 x4=1。
最后，我们将 x3、x4 的值代入第一行的方程中，可以得到 x1 + x2 = 5。由此可以得到 x1=3，x2=2。

所以，方程组的一个解为：x1=3，x2=2，x3=-2，x4=1。

matlab编程用Jacobi选代法与 Gauss Seide选代法解下列方程组：x+2y-2z=6，x+y+z=6，2x+2y+z=11

### 回答1：
Jacobi选代法与 Gauss Seide选代法是常用的迭代法，用于求解线性方程组 $Ax=b$ 的解 $x$。两种方法的基本思想相同，都是通过迭代不断调整解的近似值，使其更接近正确解的方法。

下面是用这两种方法解上述方程组的 Matlab 代码。

Jacobi选代法:

% Jacobi选代法求解线性方程组
% 输入: A, b, x0, tol, maxIter
% 输出: x, iter

function [x, iter] = Jacobi(A, b, x0, tol, maxIter)

% 初始化
n = size(A, 1);
x = x0;
iter = 0;

% 迭代求解
while iter < maxIter
    x_new = zeros(n, 1);
    for i = 1:n
        sigma = 0;
        for j = 1:n
            if j ~= i
                sigma = sigma + A(i,j)*x(j);
            end
        end
        x_new(i) = (b(i) - sigma) / A(i,i);
    end
    iter = iter + 1;
    if norm(x_new-x) < tol
        break;
    end
    x = x_new;
end

end

Gauss Seide选代法:

% Gauss Seide选代法求解线性方程组
% 输入: A, b, x0, tol, maxIter
% 输出: x, iter

function [x, iter] = GaussSeidel(A, b, x0, tol, maxIter)

% 初始化
n = size(A, 1);
x = x0;
iter = 0;

% 迭代求解
while iter < maxIter
    x_new = x;
    for i = 1:n
        sigma = 0;
        for j = 1:n
            if j ~= i
                sigma = sigma + A(i,j)*x_new(j);
            end
        end
        x_new(i) = (b(i) - sigma) / A(i,i);
    end
    iter = iter + 1;
    if norm(x_new-x) < tol
        break;
    end
    x = x_new;
end

end

### 回答2：
Jacobi选代法和Gauss Seide选代法是常用的迭代方法，用于求解线性方程组。

首先，我们可以将方程组写成矩阵形式：AX = B，其中 A是系数矩阵， X是未知向量，B是常数向量。对于给定的方程组，我们有：

A = [1 2 -2; 1 1 1; 2 2 1]
B = [6; 6; 11]
X = [x; y; z]

Jacobi选代法的迭代公式为：X(k+1) = D-1 (B - (L+U)X(k))，其中D是A的对角线矩阵，L是A的下三角矩阵，U是A的上三角矩阵，k是迭代次数。根据Jacobi选代法的迭代公式，我们可以得到如下迭代过程：

初始解：X(0) = [0; 0; 0]
第一次迭代：X(1) = D-1 (B - (L+U)X(0))
第二次迭代：X(2) = D-1 (B - (L+U)X(1))
...
直到满足收敛条件，即相邻两次迭代结果之差足够小。

Gauss Seide选代法的迭代公式为：X(k+1) = (D-L)-1 (B - U X(k))，其中D是A的对角线矩阵，L是A的下三角矩阵，U是A的上三角矩阵，k是迭代次数。根据Gauss Seide选代法的迭代公式，我们可以得到如下迭代过程：

初始解：X(0) = [0; 0; 0]
第一次迭代：X(1) = (D-L)-1 (B - U X(0))
第二次迭代：X(2) = (D-L)-1 (B - U X(1))
...
直到满足收敛条件，即相邻两次迭代结果之差足够小。

对于给定的方程组，我们可以根据上述迭代公式进行计算，不断进行迭代，直到满足收敛条件为止。最终得到近似解为X(k)，其中k为迭代次数。

希望以上回答对您有帮助。

### 回答3：
Jacobi迭代法与Gauss-Seidel迭代法是两种常用的数值计算方法，用于解线性方程组。下面是使用这两种方法解下列方程组的过程：

给定方程组如下：
1）x + 2y - 2z = 6
2）x + y + z = 6
3）2x + 2y + z = 11

首先，我们需要将方程组转化为矩阵形式 AX = B，其中A是系数矩阵，X是未知量矩阵，B是常数矩阵。根据上述方程组，我们可以得到如下矩阵形式：

A = [1 2 -2; 1 1 1; 2 2 1]
X = [x; y; z]
B = [6; 6; 11]

然后，我们可以使用Jacobi迭代法进行计算。该方法的迭代公式如下：

X(k+1) = inverse(D) * (B - (L + U) * X(k))

其中，D是A的对角矩阵，L是A的下三角矩阵，U是A的上三角矩阵。设定初始猜测解X(0)为[0; 0; 0]。

按照Jacobi迭代法的公式，我们可以得到如下迭代过程：

- 第一次迭代：
X(1) = inverse(D) * (B - (L + U) * X(0))
= inverse([1 0 0; 0 1 0; 0 0 1]) * (B - ([0 2 -2; 1 0 1; 2 2 0] + [0 0 0; 0 0 0; 0 0 0]) * [0; 0; 0])
= [6; 6; 11]

由于X(1)与X(0)相差较大，需要继续迭代。

- 第二次迭代：
X(2) = inverse(D) * (B - (L + U) * X(1))
= inverse([1 0 0; 0 1 0; 0 0 1]) * (B - ([0 2 -2; 1 0 1; 2 2 0] + [0 0 0; 0 0 0; 0 0 0]) * [6; 6; 11])
= [6; 0; -2]

经过多次迭代，我们可以得到Jacobi迭代法的解为X = [6; 0; -2]。

同样的，可以使用Gauss-Seidel迭代法进行计算。该方法与Jacobi迭代法的区别在于计算每个未知量时，使用已经更新过的新近似值。

按照Gauss-Seidel迭代法的公式，我们可以进行类似的迭代过程，最终得到Gauss-Seidel迭代法的解为X = [5.4; -0.6; -1.8]。

通过使用Jacobi选代法与Gauss-Seide选代法，我们可以求得给定方程组的解。