C语言sqrt对long long数据是不是无效

在C语言标准库中，`<math.h>`头文件提供了一个函数`sqrt()`，用于计算平方根。这个函数默认处理的是`double`类型的浮点数，如果想要计算长整型(`long long`)的平方根，可能会遇到精度限制。

对于`long long`数据类型，直接使用`sqrt()`函数会进行隐式类型转换，将其转换成`double`再进行运算。这可能导致结果丢失精度，尤其是当数值非常大以至于超过`double`能精确表示的范围时。因此，如果需要准确计算`long long`的平方根，应该先将它转换为`double`或者其他可以精确表示浮点数的类型，然后再调用`sqrt()`。

例如：

#include <stdio.h>
#include <math.h>

long long safe_sqrt(long long n) {
    double num = (double)n;
    return (long long)sqrt(num);
}

int main() {
    long long num = ...; // 需要计算平方根的大数值
    long long result = safe_sqrt(num);
    printf("Square root of %lld is %lld\n", num, result);
    return 0;
}

相关问题

计算C语言中sqrt()函数参数为100000*100000时的结果

sqrt()函数的参数必须是一个浮点数，而100000*100000是一个整数，所以需要将其转换为浮点数再进行计算。同时，由于100000*100000的结果超出了int类型的范围，需要使用long long类型来存储。

代码如下：

#include <stdio.h>
#include <math.h>

int main() {
    long long x = 100000LL * 100000LL;
    double result = sqrt((double)x);
    printf("%f", result);
    return 0;
}

运行结果为：100000.000000。

如果正整数 m 的约数的个数为 t，就称 m 为 t 因子数。例如，素数就是 2 因子数。编 写程序，使计算机求不超过 263 的最大 4 因子数。要求除了 main() 函数的返回类型外， 程序全部使用的数据类型都为 unsigned long long ，使用c语言编写代码

以下是使用暴力枚举的方式实现的代码：

#include <stdio.h>
#include <stdlib.h>

unsigned long long count_divisor(unsigned long long n) {
    unsigned long long count = 0;
    for (unsigned long long i = 1; i <= n; i++) {
        if (n % i == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    unsigned long long max_num = 0;
    unsigned long long max_count = 0;
    for (unsigned long long i = 1; i <= 0xFFFFFFFFFFFFFFFF; i++) {
        unsigned long long count = count_divisor(i);
        if (count == 4) {
            max_num = i;
            max_count = count;
        }
    }
    printf("Max number with 4 divisors: %llu\n", max_num);
    return 0;
}

但是这种方法会超时，因为要枚举的数字非常大。因此，我们需要优化算法。

一个数的因子数可以通过其质因数分解后每个质因数的指数加1再相乘得到。例如，24=2^3*3^1，因子数为(3+1)*(1+1)=8。

因此，我们可以先生成所有不超过 263 的质数，然后枚举这些质数的组合，计算其积是否小于 263 ，如果小于，再计算其因子数，找到最大的 4 因子数。以下是代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

#define MAX_NUM 0xFFFFFFFFFFFFFFFFull

bool is_prime(unsigned long long n) {
    if (n < 2) {
        return false;
    }
    for (unsigned long long i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    // Generate primes
    unsigned long long primes[100000];
    unsigned long long num_primes = 0;
    for (unsigned long long i = 2; i <= sqrt(MAX_NUM); i++) {
        if (is_prime(i)) {
            primes[num_primes++] = i;
        }
    }

    // Find max 4-divisor number
    unsigned long long max_num = 0;
    unsigned long long max_count = 0;
    for (unsigned long long i = 0; i < num_primes; i++) {
        for (unsigned long long j = i+1; j < num_primes; j++) {
            unsigned long long n = primes[i] * primes[j];
            if (n >= MAX_NUM) {
                break;
            }
            for (unsigned long long k = j+1; k < num_primes; k++) {
                unsigned long long m = n * primes[k];
                if (m >= MAX_NUM) {
                    break;
                }
                for (unsigned long long l = k+1; l < num_primes; l++) {
                    unsigned long long p = m * primes[l];
                    if (p >= MAX_NUM) {
                        break;
                    }
                    unsigned long long count = 4;
                    if (count > max_count) {
                        max_count = count;
                        max_num = p;
                    }
                }
            }
        }
    }
    printf("Max number with 4 divisors: %llu\n", max_num);
    return 0;
}

这个算法的时间复杂度是 O(n^3)，但是因为 n 很小，因此可以在合理的时间内运行完成。