记录一下linux一些清空文件内容的方法：



1. 使用重定向符号（>）将空内容重定向到文件中。这是最简单的方法，示例如下：

```
   > filename
```


  这将清空文件的内容，并将其变为空文件。[[1]](https://linux.cn/article-8024-1.html)

2. 使用cat命令将/dev/null设备的内容重定向到文件中。示例如下：
```
   cat /dev/null > filename
```
   这将将/dev/null设备的内容写入文件，实际上相当于清空了文件的内容。[[1]](https://linux.cn/article-8024-1.html)

3. 使用truncate命令将文件大小截为0。示例如下：
```
   truncate -s 0 filename
```
   这将将文件的大小截为0，从而清空了文件的内容。[[2]](https://blog.csdn.net/qq_39306908/article/details/117389938)



---
Learn more:
1. [技术|Linux 下清空或删除大文件内容的 5 种方法](https://linux.cn/article-8024-1.html)
2. [linux清空文件内容的三种方法-CSDN博客](https://blog.csdn.net/qq_39306908/article/details/117389938)
3. [linux清空文件内容的三种方法 - zqifa - 博客园](https://www.cnblogs.com/zqifa/p/linux-vim-4.html)

清空文件内容命令

/dev/null和/dev/zero是Unix和类Unix系统中的特殊设备文件。用。



1. /dev/null:
   - /dev/null是一个特殊的设备文件，也被称为空设备文件或黑洞文件。
   - 所有写入/dev/null的数据都会被丢弃，不会存储或输出。读取/dev/null会立即得到一个EOF（文件结束符）。
   - /dev/null通常被用于丢弃不需要的数据输出，或作为用于输入流的空文件。
   - 例如，可以使用以下命令将/dev/null用于清空文件：
     ```
     cat /dev/null >/etc/hosts
     ```
   - 可以使用重定向将无用的输出流写入/dev/null以丢弃无用信息[[1]](https://www.cnblogs.com/xiaodiky/p/15501760.html).

2. /dev/zero:
   - /dev/zero也是一个特殊的设备文件，它提供无限连续不断的空数据流（二进制的零流）。
   - 当读取/dev/zero时，它会提供无限的空字符(NULL, ASCII NUL, 0x00)。
   - /dev/zero的常见应用场景有两个：
     a. 用于覆盖其他文件信息，可以使用/dev/zero将文件内容清空。
     b. 用于生成指定大小的空文件，例如交换文件或模拟虚拟文件系统[[1]](https://www.cnblogs.com/xiaodiky/p/15501760.html).

---
Learn more:
1. [linux 中 /dev/null和/dev/zero的作用以及区别 - 咚咚小孩 - 博客园](https://www.cnblogs.com/xiaodiky/p/15501760.html)
2. [Linux 下的两个特殊的文件 -- /dev/null 和 /dev/zero 简介及对比_51CTO博客_Linux /dev/null](https://blog.51cto.com/u_15338614/3582498)
3. [Linux系统中有关/dev/null和/dev/zero文件说明及实践-阿里云开发者社区](https://developer.aliyun.com/article/531632)

/dev/zero和/dev/null

/dev/random是一个特殊的设备文件，用于在Unix和类Unix系统中生成随机数据。它是Linux和类Unix系统中的一部分，用于提供高质量的随机数。



关于/dev/random的一些重要信息：

1. 功能：/dev/random用于生成高质量的随机数据。它是一个真正的随机数发生器，通过收集来自设备驱动程序或其他来源的背景噪声来生成随机数[[1]](https://zh.wikipedia.org/wiki//dev/random)。

2. 阻塞特性：当熵池中的随机数据不足时，对/dev/random的读取操作会被阻塞，直到收集到足够的环境噪声为止[[1]](https://zh.wikipedia.org/wiki//dev/random)。这确保了生成的随机数具有最大可能的随机性。

3. 熵池：/dev/random包含一个熵池，用于存储收集到的噪声数据。熵池的大小和当前熵的值可以通过访问特定的文件来获取[[1]](https://zh.wikipedia.org/wiki//dev/random)。

4. /dev/urandom：/dev/urandom是/dev/random的一个副本，它使用熵池中的数据生成伪随机数。与/dev/random不同，对/dev/urandom的读取操作不会被阻塞，但其输出的熵可能小于/dev/random的[[1]](https://zh.wikipedia.org/wiki//dev/random)。

5. 其他操作系统支持：除了Linux，/dev/random和/dev/urandom也存在于其他类Unix系统中，如Solaris、Mac OS X、NetBSD、OpenBSD等[[1]](https://zh.wikipedia.org/wiki//dev/random)。

# 总结
/dev/random是一个用于生成高质量随机数据的特殊设备文件，在Unix和类Unix系统中广泛使用。它提供了真正的随机数发生器功能，并通过收集背景噪声来确保生成的随机数具有最大可能的随机性。

---
Learn more:
1. [/dev/random - 维基百科，自由的百科全书](https://zh.wikipedia.org/wiki//dev/random)
2. [技术|关于 /dev/urandom 的流言终结](https://linux.cn/article-10816-1.html)
3. [关于 /dev/urandom 的流言终结 - 知乎](https://zhuanlan.zhihu.com/p/64680713)

/dev/random和/dev/urandom

[题目](https://leetcode.cn/classic/problems/check-if-n-and-its-double-exist/description/)




```cpp
class Solution {
public:
    bool checkIfExist(std::vector<int>& arr) {
    std::unordered_set<int> seen;

    for (int num : arr) {
        // 检查当前元素的两倍和一半是否存在于集合中
        if (seen.count(num * 2) || (num % 2 == 0 && seen.count(num / 2))) {
            return true;
        }
        seen.insert(num);
    }

    return false;
}
};
```

检查整数及其两倍数是否存在

## 什么是傅里叶变换
傅里叶变换是一种数学工具，用于将一个函数从时域（时间域）转换到频域（频率域）。它是以法国数学家约瑟夫·傅里叶的名字命名的。傅里叶变换可以将一个函数表示为不同频率的正弦和余弦函数的叠加，从而揭示函数在不同频率上的能量分布情况。



傅里叶变换在物理学和工程学中有许多应用。它的基本思想是将一个函数分解为不同特征的正弦函数的和，类似于化学分析中分析化合物的元素成分。对于一个函数，傅里叶变换可以分析其组成部分，确定组成它的基本（正弦函数）成分[[1]](https://zh.wikipedia.org/wiki/%E5%82%85%E9%87%8C%E5%8F%B6%E5%8F%98%E6%8D%A2)。

傅里叶变换的定义有多种方式，但一般情况下，我们使用连续傅里叶变换的定义。连续傅里叶变换将一个可积函数表示成复指数函数的积分形式或级数形式。具体地说，对于一个函数f(x)，它的傅里叶变换表示为：

F[f](ξ) = ∫[-∞, ∞] f(x) e^(-2πixξ) dx [[1]](https://zh.wikipedia.org/wiki/%E5%82%85%E9%87%8C%E5%8F%B6%E5%8F%98%E6%8D%A2)

其中ξ为任意实数，ξ的定义域为频域。傅里叶变换将函数从时域转换到频域，将函数在不同频率上的能量分布情况展示出来。

傅里叶变换具有许多基本性质，其中包括线性性质和平移性质。线性性质表示两个函数的傅里叶变换之和等于各自变换之和。平移性质表示如果一个函数的傅里叶变换存在，那么对于任意实数ω0，函数f(x)e^(iω0x)的傅里叶变换也存在，并且满足以下关系：

F[f(x)e^(iω0x)] = F[f](ω - ω0) [[1]](https://zh.wikipedia.org/wiki/%E5%82%85%E9%87%8C%E5%8F%B6%E5%8F%98%E6%8D%A2)

傅里叶变换在许多领域都有广泛的应用，包括医学、数据科学、物理学、声学、光学、结构力学、量子力学、数论、组合数学、概率论、统计学、信号处理、密码学、大气科学、海洋学、通讯和金融等。例如，在信号处理中，傅里叶变换可以将复杂的信号分解成具有不同振幅的单一频率分量，并用于滤波等操作。在量子力学中，傅里叶变换可以将位置空间的波函数转换为动量空间的波函数。

---
Learn more:
1. [傅里叶变换 - 维基百科，自由的百科全书](https://zh.wikipedia.org/wiki/%E5%82%85%E9%87%8C%E5%8F%B6%E5%8F%98%E6%8D%A2)
2. [傅里叶变换的数学意义-电子发烧友网](https://www.elecfans.com/d/2238532.html)
3. [计算机视觉-图像的傅里叶变换 - 知乎](https://zhuanlan.zhihu.com/p/554363765)

## 简单应用
```cpp
#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<cmath>
#define N (1<<18)//如果不介意，可以开小点
using namespace std;
struct cmpx{//不一样的结构体，运算符重载
    double r,i;
    cmpx operator + (const cmpx &a)const{return (cmpx){r+a.r,i+a.i};}
    cmpx operator - (const cmpx &a)const{return (cmpx){r-a.r,i-a.i};}
    cmpx operator * (const cmpx &a)const{return (cmpx){r*a.r-i*a.i,r*a.i+i*a.r};}
};
int rev[N];
cmpx A[N],a[N],b[N],c[N];
int L,n;
void DFT(cmpx a[],int f){
     int i,j,k;
     for(i=0;i<L;i++)
     A[i]=a[rev[i]];
     for(i=0;i<L;i++)
     a[i]=A[i];
     for(i=2;i<=L;i<<=1){
                         cmpx wi=(cmpx){cos(2.0*M_PI/i),f*sin(2.0*M_PI/i)};
                         for(k=0;k<L;k+=i){
                                           cmpx w=(cmpx){1.0,0.0},x,y;
                                           for(j=0;j<i/2;j++){
                                                              x=a[k+j];
                                                              y=w*a[k+j+i/2];
                                                              a[k+j]=x+y;
                                                              a[k+j+i/2]=x-y;
                                                              w=w*wi;
                                                              }
                                           }
                         }
  if(f==-1)
  for(i=0;i<L;i++)
  a[i].r/=L;
}
void FFT(cmpx a[],cmpx b[],cmpx c[]){
     int i;
     DFT(a,1);
     DFT(b,1);
     for(i=0;i<L;i++)
     c[i]=a[i]*b[i];
     DFT(c,-1);
}
void init(int tmp){
     int i,t,j;
     for(n=0,L=1;L<tmp;L<<=1)
     n++;
     n++;
     L<<=1;
     for(i=0;i<L;i++)
     for(t=i,j=0;j<n;j++){
         rev[i]<<=1;
         rev[i]|=t&1;
         t>>=1;
         }
}
int ans[N];
void DSC(){//开始处理问题，开始处理问题，开始处理问题，重要的事情说3遍！
     int l1=0,l2=0,i;
     char ch=getchar();
     while(ch>'9'||ch<'0')
     ch=getchar();
     while(ch>='0'&&ch<='9'){
                             a[l1].r=ch-'0';
                             a[l1++].i=0.0;
                             ch=getchar();
                             }
     while(ch>'9'||ch<'0')
     ch=getchar();
     while(ch>='0'&&ch<='9'){
                             b[l2].r=ch-'0';
                             b[l2++].i=0.0;
                             ch=getchar();
                             }
    reverse(a,a+l1);
    reverse(b,b+l2);
    init(max(l1,l2));
    FFT(a,b,c);
    for(i=0;i<L;i++)
    ans[i]=(int)(c[i].r+0.5);
    for(i=0;i<L;i++){
                     ans[i+1]+=ans[i]/10;
                     ans[i]%=10;
                     }
    L=l1+l2+1;
    while(!ans[L]&&L>0)
    L--;
    for(i=L;~i;i--)
    putchar(ans[i]+'0');
    putchar('\n');
}
int main(){//主函数so easy
    DSC();
    return 0;
}
```
这份代码实现了整数的快速 Fourier 变换(FFT)来进行大整数的乘法。

主要步骤:

1. 定义复数结构体 cmpx,重载基本四则运算。

2. 定义FFT参数:
   - rev按位翻转数组,用于快速傅立叶变换复杂度优化。
   - A为FFT工作数组。
   - init函数初始化FFT参数。

3. DFT函数实现离散傅立叶变换,参数f区分正变换(1)和逆变换(-1)。

4. FFT函数调用DFT实现整数 FFT 乘法:
   - a,b长度分别FFT
   - 点乘得出结果c 
   - 调用DFT实现FFT乘法

5. DSC函数开始处理问题:
   - 读入整数a,b
   - 调用FFT函数乘法
   - 整形四舍五入取整数部分
   - 返回乘法结果

6. main函数调用DSC函数,完成大整数乘法运算。

整体采用FFT算法优化整数乘法计算复杂度,使得很大整数进行乘法也能在很短时间内得到结果。实现了详细的注释来解释每一步的目的。