@ukipoi

首先你需要说清楚你在讨论实数还是在讨论 64 位浮点数

如果是实数，那么 “K 是-1 到 1 的所有数的总量” 这句话不成立，后面就不用讨论了。
不能设 K 是无限，然后把 K 当一个有限的数来做后续的讨论。

如果是 64 位浮点数，那么 “每一个 Y 出现的概率都是 1/K” 是错的。
比如
2 ^ 0.1000000000000002 和 2 ^ 0.10000000000000014 的结果都是 1.0717734625362934

https://www.postgresql.org/docs/current/datatype-character.html

网页内搜索 SQL standard
This somewhat bizarre exception is required by the SQL standard

通常都用 VARCHAR 的，没这个问题

或者上 PostgreSQL 全用 TEXT 完事。

如果只考虑数学问题（不考虑什么浮点数运算的事情），也不考虑边界（[] 和 () 的差别），这个问题是这样的

已有一个 0-1 之间均匀分布的随机数 x，在上面加一个变换 f，变成 0.5-2 之间分布的随机数 y，要求 0.5-1 的概率和 1-2 的概率相等。问这个变换是什么。

先假定 f 在 0.5-2 之间是单调连续函数（不单调的 f 当然也可以有，先不考虑了）

那么，f(0.5) = 1 且 0.5 <= f(x) <= 2 的 f 都符合要求，比如 f(x) = x + 0.5

如果再增加一个条件，y 在 0.5 - 2 的整个区间内的概率密度都不为 0
那么只要 f(0) = 0.5, f(0.5) = 1, f(1) = 2，f 就满足要求，你随便假设比如 f(x) = ax^2 + bx + c 然后解 a b c 就好了。
如果假设 f(x) = 2^(ax+b) ，就得到 lsylsy2 给出的指数函数。
类似的还有很多符合条件的函数。

如果再增加一个条件，0.5-1 和 1-2 之间的概率密度分别都是常数，那么两边都是直线。
给定 f(0) = 0.5, f(0.5) = 1, f(1) = 2，结果是唯一的，就是那个分段函数。

如果再回去看 geekbench 的测试结果，那 Intel 这个数字确实太惨了。

5950X 的单核性能比 9880H 快那么多

@hjc4869

这个很确定，是 2400 的，不是原装的内存。
是我在买这台机器之前很久另买的 16Gx2

@hjc4869

对的，我直接继续用 openssl 测了，在 AMD Ryzen 7 4700U 上

openssl speed -evp aes-256-xts -bytes 134217728 -multi 1
evp 6355342.75k

增加 -multi，大约到 -multi 4 的时候就会达到最大值了，有两倍多吧
evp 13651520.72k

这台机器的内存是 128bit 2400 DDR4 (38.4 GB/s)
那台 4770HQ 的机器是 128bit 1600 DDR3 (25.6 GB/s)，最多能跑到 6776863.34k

所以 openssl 大约能跑到内存带宽 / 3

@hjc4869

这玩意其实可以直接测，在我的机器上是这样的结果
都是 openssl 1.1.1h

Intel i7 4770HQ

openssl speed -evp aes-256-xts
type 16 bytes 64 bytes 256 bytes 1024 bytes 8192 bytes 16384 bytes
aes-256-xts 203022.96k 825995.49k 1748770.28k 2642286.01k 3120154.71k 3192675.31k

openssl speed -evp aes-256-xts -multi 4
evp 808941.94k 2783501.61k 6091693.65k 9758843.90k 10974879.74k 10624166.57k

四核处理器，单核 3 G/s 多核 10 G/s


AMD Ryzen 7 4700U

openssl speed -evp aes-256-xts
type 16 bytes 64 bytes 256 bytes 1024 bytes 8192 bytes 16384 bytes
aes-256-xts 515543.39k 1919414.38k 4367495.42k 6155646.63k 6991994.88k 7083595.09k

openssl speed -evp aes-256-xts -multi 8
evp 3404665.32k 12602658.88k 27869853.10k 36364921.17k 41717743.62k 41641061.03k

八核处理器，单核 7 G/s，多核 40 G/s

https://www.geekbench.com/doc/geekbench5-cpu-workloads.pdf
这里有说 geekbench 也直接用 AES 指令，说了用 4k block，说了 256 bits AES

我更怀疑 geekbench 的代码有问题了

https://browser.geekbench.com/v5/cpu/compare/4653108?baseline=4648107
https://browser.geekbench.com/v5/cpu/compare/4642178?baseline=4648107

下面单项的第一个 AES-XTS 的单核和多核性能

苹果是 4.59 G/s 和 16.7 G/s
5950X 是 7.15 G/s 和 12.4 G/s
i9-9880H 是 1.82 G/s 和 8.41 G/s

3 个处理器都是 8 核的，最快的 16.7 G/s 肯定没到内存带宽。

为什么 5950X 的单核比 9880H 快那么多？
为什么 5950X 的多核速度还不到单核的 2 倍？

这数字要说是瞎编的我都信。

在一个文件写到死

这个问题好办，学会手写 Makefile 就解决了。

找一个求职者写过的东西，最好是有点技术含量的，从写这个东西的目的开始，问技术细节和每一个技术决策的理由或者权衡。
当然要能这样问问题并且能聊得下去，对面试官的要求也很高。已经高到很少见的水平了。

@FlyingShark

你没有明白我的意思，我只是在名词解释。
我没说实现有后门，我也没说算法有后门，我也没说实现没有后门，我也没说算法没有后门。

重点是 RSA 和 RSA Security 这两个词，这是雷锋和雷锋塔的关系。
你不能说 RSA 怎么怎么样，要说 RSA Security，否则会带很强的误导性。

@FlyingShark
这里的 RSA 是 RSA Security，是一家公司。
这家公司是发明 RSA 算法那三个人初创的。

NSA 的事情和 RSA 算法缺陷毫无关系。

@v2410117

如果你连改文件内容都需要来发帖子问，改 ELF 然后还要能跑属于你不可能完成的事情，放弃吧。

https://blog.0patch.com/2017/11/did-microsoft-just-manually-patch-their.html
这是微软做过然后能上新闻的操作。

@Yc1992
我本来想说的就是这一段。

When a coroutine blocks, such as by calling a blocking system call, the run-time automatically moves other coroutines on the same operating system thread to a different, runnable thread so they won't be blocked.

这里说的不是把多个 coroutine 放到同一个线程上来跑。是说如果有一个 coroutine 阻塞住了一个 thread，就把其它的 coroutine 放到别的线程上跑。

然后有一句话，The programmer sees none of this, which is the point. The result, which we call goroutines, ...

所以总结一下就是，有一个协程，它 block 住了（比如在 python 的 async function 里面写了一句 time.sleep ），这样其它的协程就不能跑了对吧，那我们写一个高级一点的 runtime，把能跑的协程放到其它 thread 上跑。
并且把这些过程都隐藏起来，什么 yield 之类的东西都没有了，都是 runtime 里面的事情。

所以说这是一个基于 coroutine 的想法，或者说是一个经过了大改的 coroutine，还专门说了这个东西叫 goroutine 不叫 coroutine 了。

所以还是上一条回复里面说的，它改完了就不是 coroutine 了。

@Balthild
@hronro

https://en.wikipedia.org/wiki/Coroutine#Comparison_with_threads
协程，coroutine，co 是 cooperatively，合作协作的意思。
相对的概念是 preemptively，抢占

这是这个 coroutine 原本的意思。

在一个 stackful coroutine 的实现上加上抢占式调度，那当然可以做。
但做出来的东西就不叫 coroutine 了。

@v2webdev
用整数的话，32 位不够，那就要用 64 位的，占 8 bytes
那个字符串是 14 个数字，14 bytes

如果用定长的字符串，也就是不需要额外存长度，也不需要在结尾补一个 0，那就是差 6 bytes

@Yc1992
如果你去看 Go 的官方文档，里面明确说了这东西不是 coroutine，当然它也不是 thread，所以才起了个新名字叫 goroutine

大家常说它是协程，是因为它和协程很像，在 io 上也用 epoll, kqueue, iocp 这些系统调用，并且它也确实在 io 操作上 yield 了，老版本上的调度器还不是抢占式的。

但首先新的调试器已经是抢占式的了，这就不符合协程的定义。然后你对比一下实现的细节，显然现在的 goroutine 和 thread 更接近。

别人怎么说并不重要，你得去看实际的东西。

本来就可以这么用，如果你要深究，就保存时间这件事情上，每个方法都会有缺点。

首先字符串就是任意长度的整数，没什么区别。

日期时间的存法很多，比如
1. 用 unix timestamp，缺点是人类不能一眼看出来那是哪天。
2. 用数据库内置的 datetime 类型，但 MySQL 的 datetime 有奇怪的行为还不能带时区。
3. 用楼主说的这种，存字符串类型。
4. 用楼主说的这种，存整数类型。

4 比 3 省 6 个 byte 的空间。
但是这个格式一定要从字符串转换过来，用的时候也必然要转回字符串，所以 3 比 4 节省一点 cpu 。

实际上 3 和 4 的差别是无关紧要的事情，没人在乎 6 个 byte，也没人在乎那一点点 cpu 。
但 1 和 2 的缺点是确实存在的。