fmod函数

发表于 2024-09-14 | 分类于 c语言 | 暂无评论

要对浮点数进行类似取模的操作，你可以使用math.h库中的fmod函数，它专门用于浮点数的取模运算。

代码如下：

#include <math.h>

m = ceil(fmod(t, 60));

这样，fmod(t, 60)会返回t除以60后的余数，然后再用ceil函数取整。

stdlib.h

发表于 2024-09-10 | 分类于 c语言 | 暂无评论

#include <stdlib.h> 是 C 标准库的一个头文件，它包含了许多与内存分配、进程控制、随机数生成、排序/搜索以及数据类型转换等相关的函数声明。这个头文件在 C 和 C++ 中都被广泛使用。

以下是 stdlib.h 中一些常用的函数和它们的用途：

1. 动态内存分配

malloc()：分配一块未初始化的内存。

void* malloc(size_t size);

例如：

int* arr = (int*) malloc(10 * sizeof(int));

calloc()：分配一块内存并将其初始化为零。

void* calloc(size_t num, size_t size);

例如：

int* arr = (int*) calloc(10, sizeof(int));

realloc()：重新调整已分配的内存块的大小。

void* realloc(void* ptr, size_t new_size);

例如：

arr = (int*) realloc(arr, 20 * sizeof(int));

free()：释放动态分配的内存。
```
void free(void* ptr);
```
例如：
```
free(arr);
```

2. 随机数生成

rand()：生成一个介于 0 和 RAND_MAX 之间的随机整数。
```
int rand(void);
```
例如：
```
int random_value = rand();
```
srand()：设置随机数生成器的种子，常用于生成不同的随机数序列。
```
void srand(unsigned int seed);
```
例如：
```
srand(time(NULL)); // 使用当前时间作为种子
```

3. 进程控制

exit()：终止程序执行，并返回一个状态码。
```
void exit(int status);
```
例如：
```
exit(0); // 正常退出
```

system()：执行系统命令。

int system(const char* command);

例如：

system("ls"); // 在Linux系统中列出目录内容

4. 类型转换

atoi()：将字符串转换为整数。

int atoi(const char* str);

例如：

int num = atoi("123");

atof()：将字符串转换为浮点数。

double atof(const char* str);

例如：

double num = atof("123.45");

atol()：将字符串转换为长整数。
```
long atol(const char* str);
```
strtol()、strtod()：这些函数提供了更灵活的字符串到数值转换方式，可以指定进制或错误处理。
```
long int strtol(const char* str, char** endptr, int base);
```

5. 排序与查找

qsort()：使用快速排序算法对数组进行排序。

void qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*));

例如，排序一个整型数组：

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

qsort(arr, n, sizeof(int), compare);

bsearch()：使用二分查找在已排序的数组中查找元素。

void* bsearch(const void* key, const void* base, size_t num, size_t size, int (*compar)(const void*, const void*));

6. 环境变量

getenv()：获取环境变量的值。

char* getenv(const char* name);

例如：

char* path = getenv("PATH");

总结

#include <stdlib.h> 头文件提供了 C 程序中许多基础功能，包括：

动态内存分配 (malloc、calloc、realloc、free)
随机数生成 (rand、srand)
进程控制 (exit、system)
字符串和数值之间的转换 (atoi、atof、strtol)
数组排序和查找 (qsort、bsearch)

它是一个通用的、实用的库，几乎在每一个 C 程序中都能找到它的使用场景。

bits stdc++.h

发表于 2024-09-10 | 分类于 c语言 | 暂无评论

#include<bits/stdc++.h> 是一个在 C++ 编程中经常使用的头文件，它包含了 C++ 标准库中几乎所有的头文件。因此，它在很多竞赛编程或者快速原型开发中被广泛使用，因为它可以避免手动包含每一个单独需要的库文件。

不过，需要注意以下几点：

不是标准库的一部分：#include<bits/stdc++.h> 这个文件并不是 C++ 标准的一部分，它是 GCC（GNU Compiler Collection）编译器的一部分，因此它可能在其他编译器上不可用。例如，Visual Studio 编译器就不支持这个头文件。
编译速度变慢：因为它包含了几乎所有的标准库头文件，导致编译时间会比你只包含需要的头文件要长。所以在实际的开发中（尤其是在大型项目中），并不推荐使用这个文件。
良好的编程习惯：在生产环境或大型项目中，最好只包含你确实需要的头文件，这样可以提高代码的可读性、可维护性以及编译速度。

所以，#include<bits/stdc++.h> 虽然非常方便，尤其是在竞赛编程中，但并不是一个“万能库”，也不是推荐在所有情况下使用的库。

动态数组

发表于 2024-09-10 | 分类于 c语言 | 暂无评论

在 C 语言中，动态数组指的是在程序运行时动态分配的数组，其大小不需要在编译时确定。我们通过动态内存分配函数（如 malloc、calloc 和 realloc）来实现动态数组。

动态数组的基本操作

malloc 分配动态数组：
malloc 函数可以分配指定大小的内存。它返回一个 void* 类型的指针，需要强制转换为适当的指针类型。

语法：

void* malloc(size_t size);

例如，创建一个动态分配的整型数组：

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

int main() {
    int n;  // 数组的大小
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    // 动态分配一个包含 n 个整数的数组
    int* array = (int*) malloc(n * sizeof(int));

    // 检查内存分配是否成功
    if (array == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    // 使用数组
    for (int i = 0; i < n; i++) {
        array[i] = i + 1;  // 示例填充数组
    }

    // 打印数组
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 释放内存
    free(array);

    return 0;
}

malloc 分配 n * sizeof(int) 个字节，用于存储 n 个整数。
如果内存分配失败，malloc 返回 NULL，程序可以通过这个指针检查分配是否成功。
使用完动态数组后，必须调用 free() 来释放分配的内存。

calloc 分配动态数组：
calloc 是另一种动态内存分配函数，它会将分配的内存初始化为零。
语法：
```
void* calloc(size_t num, size_t size);
```
例如：
```
int* array = (int*) calloc(n, sizeof(int));
```
calloc 与 malloc 的主要区别是，calloc 分配的内存会被初始化为零，而 malloc 分配的内存是未初始化的。
realloc 调整动态数组大小：
如果你需要调整动态数组的大小，可以使用 realloc 函数。它会重新分配内存，保留原有的数据内容。
语法：
```
void* realloc(void* ptr, size_t new_size);
```
例如：
```
array = (int*) realloc(array, new_size * sizeof(int));
```
- realloc 接收一个指向之前分配内存的指针 ptr 和新的大小 new_size。
- 如果重新分配失败，realloc 返回 NULL，原来的内存块依然有效。

示例：使用 `realloc` 调整数组大小

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

int main() {
    int n = 5;
    int* array = (int*) malloc(n * sizeof(int));

    // 填充数组
    for (int i = 0; i < n; i++) {
        array[i] = i + 1;
    }

    printf("Original array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 调整数组大小
    int new_size = 10;
    array = (int*) realloc(array, new_size * sizeof(int));

    // 为新数组的元素赋值
    for (int i = n; i < new_size; i++) {
        array[i] = i + 1;
    }

    printf("Resized array: ");
    for (int i = 0; i < new_size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");

    // 释放内存
    free(array);

    return 0;
}

总结：

动态数组的大小在运行时分配，不需要在编译时确定。
使用 malloc 或 calloc 来分配动态数组，使用 realloc 来调整数组大小。
使用完动态数组后，记得调用 free() 来释放内存。

求最大公约数

发表于 2024-09-10 | 分类于 c语言 | 暂无评论

在 C++17 及之后的版本中，标准库中引入了一个内置的 gcd 函数，用于计算两个整数的最大公约数（GCD）。它位于 <numeric> 头文件中，并使用欧几里得算法来高效地计算 GCD。

使用方法：

该函数位于 std 命名空间下，函数签名如下：
```
template <class T>
T gcd(T a, T b);
```
该模板函数可以接受任意整数类型的参数，包括 int、long、long long 等。

示例代码：

#include <iostream>
#include <numeric>  // 包含 gcd 函数
#include <vector>

int main() {
    int a = 56;
    int b = 98;

    // 使用 C++17 的内置 gcd 函数
    int result = std::gcd(a, b);
    std::cout << "GCD of " << a << " and " << b << " is " << result << std::endl;

    return 0;
}

输出：

GCD of 56 and 98 is 14

特点和优点：

高效实现：std::gcd 函数使用的是经过优化的欧几里得算法，能够高效地计算两个整数的最大公约数。
支持的类型：它支持任意整数类型，包括有符号和无符号的整数类型。
C++ 标准库保证：因为是标准库提供的函数，能确保跨平台的兼容性和性能优化。

使用范围：

你可以使用 std::gcd 来计算各种整数类型的 GCD，包括 int、long、long long，甚至自定义类型，只要它们遵循整数类型的基本规则。

示例：结合多个数的 GCD

你可以利用 std::gcd 来计算多个数的 GCD。假设我们想要计算一个数组中所有元素的 GCD，可以像这样结合 std::gcd 和 std::accumulate：

#include <iostream>
#include <numeric>  // 包含 gcd 和 accumulate 函数
#include <vector>

int main() {
    std::vector<int> nums = {56, 98, 42};

    // 使用 accumulate 来计算多个数的 GCD
    int result = std::accumulate(nums.begin(), nums.end(), nums[0], std::gcd<int, int>);

    std::cout << "GCD of the array is " << result << std::endl;

    return 0;
}

输出：

GCD of the array is 14

在c语言中也可以这样实现

在标准的 C 语言库中（如 stdio.h 或 stdlib.h），没有内置的 gcd 函数。因此，如果需要在 C 语言中计算两个整数的最大公约数（GCD），你需要自己编写该函数。

代码：

long long gcd(long long a,long long b)
{
    while(a != b)
    {
        if(a > b)
        {
            a = a - b;
        }
        else
        {
            b = b - a;
        }
    }
    return a;  // 返回a或b，因为最后它们相等并且是GCD
}

在每次循环中通过减法逐步接近两个数的最大公约数，源于“更相减损术”的原理。这种方法可以追溯到古代的数学家欧几里得，并且可以用来证明两个数的最大公约数在减法中逐渐逼近。

这段代码的目的是计算两个数 a 和 b 的最大公约数（GCD，Greatest Common Divisor）以下是对代码的解释：

while 循环执行的是一种较原始的 GCD 计算方法，称为“减法法”。它通过逐步减少两个数的值直到它们相等。
- 在每次循环中，它比较 aa 和 bb 的大小。如果 aa 大于 bb，就用 aa - bb 更新 aa，否则用 bb - aa 更新 bb。最终，aa 和 bb 会变成相等的数，而这个数就是它们的最大公约数。

原理：

假设我们有两个数 a 和 b，且 a > b。在减法法中，我们每次用较大的数减去较小的数，直到两个数相等。以下是这种方法的核心思想：

保持最大公约数不变：
- 设 d 是 a 和 b 的最大公约数，即 d = gcd(a, b)，这意味着 a 和 b 都可以被 d 整除（即 a = d * m，b = d * n，其中 m 和 n 是整数）。
- 当我们用较大的数 a 减去较小的数 b 后，得到的新数 a' = a - b。
- 注意到 a' = a - b 仍然可以被 d 整除，因为：
  [
  a' = a - b = d m - d n = d * (m - n)
  ]
  所以 a' 也是 d 的倍数，仍然与 b 有相同的最大公约数。
收敛到最大公约数：
- 在每次减法后，新的数对 (a', b) 或 (a, b') 的差值越来越小。最终，两个数会变得相等，而这个相等的数就是 a 和 b 的最大公约数。
- 由于在每次减法中，两个数的最大公约数保持不变，最终我们得到的相等数（即 aa = bb）就是它们的最大公约数。

举例说明：

假设 a = 24，b = 18，我们通过每次减法逐步计算最大公约数：

第一次循环：a = 24, b = 18，因为 a > b，所以 a = a - b = 24 - 18 = 6。
第二次循环：a = 6, b = 18，因为 b > a，所以 b = b - a = 18 - 6 = 12。
第三次循环：a = 6, b = 12，因为 b > a，所以 b = b - a = 12 - 6 = 6。
最后，a = b = 6，所以最大公约数是 6。

每一步中，最大公约数一直保持不变，直到最后两个数相等为止，而这个相等的数就是最大公约数。

优化：

实际计算 GCD 可以使用 欧几里得算法，它比这种减法法更高效。改进后的代码如下：

递归实现的代码示例：

long long gcd(long long a,long long b)
{
    if(b == 0)
        return a;
    return gcd(b, a % b);  // 欧几里得算法
}

迭代实现的代码示例：

除了递归，你也可以用迭代的方式实现：

#include <iostream>

long long gcd(long long a, long long b) {
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

解释：

欧几里得算法的原理是通过递归地使用模运算来逐步缩小问题规模，直到其中一个数为 0。此时，另一个数就是它们的最大公约数。
在循环中，a % b 计算出 a 除以 b 的余数，接着交换 a 和 b 的值，继续计算，直到 b 为 0。

这个实现方法比使用减法的方式更高效，尤其对于较大的数。

欧几里得算法（Euclidean algorithm）是一个用于计算两个整数的最大公约数（GCD，Greatest Common Divisor）的经典算法。它的基本原理是基于一个非常重要的数学定理：

定理：

若 d 是 a 和 b 的最大公约数，则 d 也是 b 和 a % b 的最大公约数。

证明：

设 a 和 b 是两个整数，且 a > b，则可以写成如下的关系：
a = b * q + r
其中：

q 是商（整数），
r 是余数，即 r = a % b。

根据这个关系式，可以重写为：
r = a - b * q

现在，让我们从 d = gcd(a, b) 出发进行推导，假设 d 是 a 和 b 的最大公约数。根据最大公约数的定义：

d 可以整除 a，即 a = d * m，其中 m 是某个整数。
d 也可以整除 b，即 b = d * n，其中 n 是某个整数。

接下来，我们要证明 d 也可以整除 r（即 a % b）。根据前面的等式：
r = a - b * q
代入 a = d * m 和 b = d * n：
r = d m - (d n) * q
r = d (m - n q)

因此，r 是 d 的倍数，这说明 d 也整除 r。

结论：

因为 d 整除 b，并且 d 也整除 r，根据最大公约数的定义，d 是 b 和 r 的公约数。
因此，d = gcd(b, r)，而 r = a % b，这就证明了：
gcd(a, b) = gcd(b, a % b)

这个过程可以重复，直到余数为 0。此时，剩下的数就是 a 和 b 的最大公约数。

算法原理：

给定两个整数 a 和 b，其中 a > b。
根据定理，gcd(a, b) 等于 gcd(b, a % b)。换句话说，较大的数 a 可以被较小的数 b 除尽，并且我们继续用 a 除以 b 的余数来替换 a。
不断重复这个过程，将 b 和 a % b 作为新的一对数，直到其中一个数变为 0。
当其中一个数为 0 时，另一个数就是它们的最大公约数。

欧几里得算法的核心思想是基于一个重要的数学定理，这个定理解释了为什么最大公约数（GCD）可以通过 a 和 b 转换为 b 和 a % b 来计算。下面是这个定理的详细解释。

总结：

在欧几里得算法中，我们通过每次将 a 替换为 a % b，并不断计算余数，最终将问题缩小。
由于最大公约数 d 可以同时整除 b 和 a % b，因此 gcd(a, b) 可以递归地转换为 gcd(b, a % b)。
最终，当余数为 0 时，b 就是 a 和 b 的最大公约数。

这个定理和算法的关键在于利用了“除法余数不影响公约数”的特性，使得我们可以通过递归或迭代高效地计算出最大公约数。

欧几里得算法的优点：

高效：每一步都通过取模运算来减少较大数的大小，快速缩小问题的规模。相比于简单的逐个枚举约数，欧几里得算法能在对数时间内找到最大公约数。
简单实现：该算法只需要简单的取模运算，容易实现且计算量小。

另：求最小公倍数的方法：
另两数相乘然后除以最大公约数。
tip：为了防止爆int可以先除，再乘。

1. 动态内存分配

2. 随机数生成

3. 进程控制

4. 类型转换

5. 排序与查找

6. 环境变量

总结

动态数组的基本操作

示例：使用 realloc 调整数组大小

总结：

使用方法：

示例代码：

输出：

特点和优点：

使用范围：

示例：结合多个数的 GCD

输出：

在c语言中也可以这样实现

代码：

原理：

举例说明：

优化：

递归实现的代码示例：

迭代实现的代码示例：

解释：

定理：

证明：

结论：

算法原理：

总结：

欧几里得算法的优点：

示例：使用 `realloc` 调整数组大小