square（4）的值（C语言求一个数的因子的平方和）

本文目录

• C语言求一个数的因子的平方和
• 4的平方根是多少
• 编制一个产生均值为1,方差为4的高斯分布随机数程序,求最大值,最小值,均值和方差.
• 4的平方是多少
• 正多边形边数公式

C语言求一个数的因子的平方和

方法一：暴力枚举
使用循环枚举从1到n的每一个数，如果这个数是n的因子，那么就将它的平方加到总和中。
代码如下：
#include 《stdio.h》
int main() {
int n;
printf("请输入一个正整数n:");
scanf("%d", &n);
int sum = 0;
for (int i = 1; i 《= n; i++) {
if (n % i == 0) { // 判断i是否为n的因子
sum += i * i; // 累加i的平方到总和中
}
}
printf("结果为：%d\n", sum);
return 0;
}
方法二：优化枚举
暴力枚举的时间复杂度为O(n)，我们可以采用优化的方式。
1.在循环中我们发现，n的因子肯定是成对出现的， 那么循环到n的平方根时就可以结束了。
2.如果n是偶数，那么它的因子一定都是偶数，可以把循环范围缩小到偶数部分。
代码如下：
#include 《stdio.h》
#include《math.h》
int main() {
int n;
printf("请输入一个正整数n:");
scanf("%d", &n);
int sum = 0;
int i;
// 根据奇偶性确定循环范围
if (n % 2 == 0) {
for (i = 2; i * i 《 n; i += 2) {
if (n % i == 0) {
sum += i * i + (n / i) * (n / i);
}
}
if (i * i == n) {
sum += i * i;
}
} else {
for (i = 3; i * i 《 n; i += 2) {
if (n % i == 0) {
sum += i * i + (n / i) * (n / i);
}
}
if (i * i == n) {
sum += i * i;
}
}
sum += 1;
printf("结果为：%d\n", sum);
return 0;
}
方法三：质因数分解
我们可以将n分解为质因数乘积的形式，然后根据每个因子的个数来计算平方和。
例如，如果n = 12，则分解为 2^2 * 3，因子为{1, 2, 3, 4, 6, 12}。其中，1出现2次，2出现3次，3出现2次，4出现1次，6出现1次，12出现1次。
因此，平方和为1^2 * 2 + 2^2 * 3 + 3^2 * 2 + 4^2 * 1 + 6^2 * 1 + 12^2 * 1 = 210。
代码如下：
#include 《stdio.h》
#include 《math.h》
int main() {
int n;
printf("请输入一个正整数n:");
scanf("%d", &n);
int sum = 1; // 注意要加上1的平方
for (int i = 2; i 《= sqrt(n); i++) {
int count = 0; // 记录i的个数
while (n % i == 0) {
count++;
n = n / i;
}
if (count 》 0) {
sum += pow(i, 2) * count; // 累加i的平方乘以个数到总和中
}
}
if (n 》 1) { // n可能有一个大于sqrt(n)的因子
sum += n * n;
}
printf("结果为：%d\n", sum);
return 0;
}
需要注意的是，每次除以质因子时，要使用循环进行除法，直到不能整除为止。同时，最后还要判断剩下的n是否为1，如果不为1，则说明有一个大于sqrt(n)的因子。

4的平方根是多少

4的平方根是2，因为2×2=4，所以√4=2。

平方根又叫二次方根，表示为〔±√￣〕，其中属于非负数的平方根称之为算术平方根（arithmetic square root）。一个正数有两个实平方根，它们互为相反数，负数没有平方根。

一个正数如果有平方根，那么必定有两个，它们互为相反数。显然，如果知道了这两个平方根的一个，那么就可以及时的根据相反数的概念得到它的另一个平方根。

扩展资料：

开方的计算步骤：

1、将被开方数的整数部分从个位起向左每隔两位划为一段，用撇号分开（竖式中的11’56），分成几段，表示所求平方根是几位数；

2、根据左边第一段里的数，求得平方根的最高位上的数（竖式中的3）；

3、从第一段的数减去最高位上数的平方，在它们的差的右边写上第二段数组成第一个余数（竖式中的256）；

4、把求得的最高位数乘以2去试除第一个余数，所得的最大整数作为试商（2×30除256，所得的最大整数是 4，即试商是4）；

5、用商的最高位数的2倍加上这个试商再乘以试商．如果所得的积小于或等于余数，试商就是平方根的第二位数；如果所得的积大于余数，就把试商减小再试（竖式中（2×30+4）×4=256，说明试商4就是平方根的第二位数）；

6、用同样的方法，继续求平方根的其他各位上的数。

编制一个产生均值为1,方差为4的高斯分布随机数程序,求最大值,最小值,均值和方差.

分太少，算了，给你一个源程序吧，C++的boost库，你直接调用吧，这样就不用自己再写那个产生随机数的函数，使用这个函数产生你要求的样本，统计这个样本得到你后边的均值和方差，老师大概是想让你比较产生出来的值和你的理论值1和4有多少差别。
/* boost random/normal_distribution.hpp header file
*
* Copyright Jens Maurer 2000-2001
* Distributed under the Boost Software License, Version 1.0. (See
* accompanying file LICENSE_1_0.txt or copy at
***隐藏网址***
*
***隐藏网址***
*
* $Id: normal_distribution.hpp,v 1.20 2004/07/27 03:43:32 dgregor Exp $
*
* Revision history
* 2001-02-18 moved to individual header files
*/
#ifndef BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP
#define BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP
#include 《cmath》
#include 《cassert》
#include 《iostream》
#include 《boost/limits.hpp》
#include 《boost/static_assert.hpp》
namespace boost {
// deterministic polar method, uses trigonometric functions
template《class RealType = double》
class normal_distribution
{
public:
typedef RealType input_type;
typedef RealType result_type;
#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) && !(defined(BOOST_MSVC) && BOOST_MSVC 《= 1300)
BOOST_STATIC_ASSERT(!std::numeric_limits《RealType》::is_integer);
#endif
explicit normal_distribution(const result_type& mean = result_type(0),
const result_type& sigma = result_type(1))
: _mean(mean), _sigma(sigma), _valid(false)
{
assert(sigma 》= result_type(0));
}
// compiler-generated copy constructor is NOT fine, need to purge cache
normal_distribution(const normal_distribution& other)
: _mean(other._mean), _sigma(other._sigma), _valid(false)
{
}
// compiler-generated copy ctor and assignment operator are fine
RealType mean() const { return _mean; }
RealType sigma() const { return _sigma; }
void reset() { _valid = false; }
template《class Engine》
result_type operator()(Engine& eng)
{
#ifndef BOOST_NO_STDC_NAMESPACE
// allow for Koenig lookup
using std::sqrt; using std::log; using std::sin; using std::cos;
#endif
if(!_valid) {
_r1 = eng();
_r2 = eng();
_cached_rho = sqrt(-result_type(2) * log(result_type(1)-_r2));
_valid = true;
} else {
_valid = false;
}
// Can we have a boost::mathconst please?
const result_type pi = result_type(3.14159265358979323846);

return _cached_rho * (_valid ?
cos(result_type(2)*pi*_r1) :
sin(result_type(2)*pi*_r1))
* _sigma + _mean;
}
#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
template《class CharT, class Traits》
friend std::basic_ostream《CharT,Traits》&
operator《《(std::basic_ostream《CharT,Traits》& os, const normal_distribution& nd)
{
os 《《 nd._mean 《《 " " 《《 nd._sigma 《《 " "
《《 nd._valid 《《 " " 《《 nd._cached_rho 《《 " " 《《 nd._r1;
return os;
}
template《class CharT, class Traits》
friend std::basic_istream《CharT,Traits》&
operator》》(std::basic_istream《CharT,Traits》& is, normal_distribution& nd)
{
is 》》 std::ws 》》 nd._mean 》》 std::ws 》》 nd._sigma
》》 std::ws 》》 nd._valid 》》 std::ws 》》 nd._cached_rho
》》 std::ws 》》 nd._r1;
return is;
}
#endif
private:
result_type _mean, _sigma;
result_type _r1, _r2, _cached_rho;
bool _valid;
};
} // namespace boost
#endif // BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP

4的平方是多少

4的平方是16。

解答过程如下：

平方表示的含义是两个数字相乘，4的平方表示两个数字“4”相乘，即4×4=16，写作4²=16。

平方是一种运算，比如，a的平方表示a×a，简写成a，也可写成a×a(a的一次方乘a的一次方等于a的2次方），例如4*4=16，8*8=64，平方符号为2。

扩展资料

平方（面积单位）

平方米（m²，英文：squaremeter），是面积的公制单位。定义为边长为1米的正方形的面积。在生活中平方米通常简称为“平米”或“平方”。港台地区则称为“平方公尺”。

单位换算：1㎡（1平方米）=100dm²（100平方分米）=10000cm²（10000平方厘米）=1000000mm²（1000000平方毫米）=0.0001公顷=0.000001km²（0.000001平方公里）=0.01公亩=0.0002471054英亩=0.0000003861平方英里=10.763910417平方英尺=0.0015亩。

单位换算就是把平方米换算成平方分米、平方厘米、平方毫米后将他们之间的进位和单位一起平方。例如1m=10dm；1㎡=10dm×10dm=100dm²。其余的都可以按照这样的换算方法换算得出。

正多边形边数公式

正多边形的边数公式为：n = 4 × tan(π/n)，其中，n 表示正多边形的边数，π表示圆周率。

正多边形边数公式是由希腊数学家阿基米德（Archimedes）在他著名的《圆的测量》（Measurement of the Circle）一书中首次给出的。在这本书中，阿基米德利用弧长逐渐逼近多边形的方法，推导出了圆周率的逼近值。利用这种方法，阿基米德还推导出了正多边形的周长公式和面积公式。

正多边形边数公式是由周长和半径之间的关系推导而来的。由于正多边形的边和半径都相等，因此正多边形的周长直接与其边长成正比。而正多边形内角和总是等于 (n - 2)×180 度，每个内角又都是 360 度除以边数 n，因此可以得到每个内角为 (n - 2) × 180 / n 度。

由于正多边形的内角为圆心角，因此可以通过三角函数来计算正多边形的边长。因此，利用周长和内角的关系以及三角函数，阿基米德就推导出了正多边形边数公式。正多边形边数公式可以用于计算正多边形的边数，也可以用于其他相关问题的计算。

常见正多边形的边数

1、三角形（Equilateral triangle）：3个边。

2、四边形（Square）：4个边。

3、五边形（Pentagon）：5个边。

4、六边形（Hexagon）：6个边。

5、七边形（Heptagon）：7个边。

6、八边形（Octagon）：8个边。

7、九边形（Nonagon）：9个边。

8、十边形（Decagon）：10个边。

9、十二边形（Dodecagon）：12个边。

10、二十边形（Icosagon）：20个边。