---

分享一种不使用阶乘和余弦的邪道演算法。

数字字元0 的ASCII码为48，那么有

---

1：阶乘

(0!+0!+0!+0!)!=24
「！」表示阶乘
n！＝1×2×3×4×……×（n-1）×n
!是阶乘 因为0!=1
(0!+0!+0!+0!)! =(1+1+1+1)! =4! =4*3*2*1 =24

2：脑经急转弯

00:00=24点

3：三角函数+阶乘

(cos0+cos0+cos0+cos0)!=24
cos0=1 同理 1/cos0=sec0=1
(sec0+sec0+sec0+sec0)!=24

---

首先先理解阶乘。

n！＝1*2*3*.....*n

好比5！＝1*2*3*4*5＝120

理解了阶乘之后，那么0！等于多少呢？

按照规定，0！＝1。可能有人会觉得1！＝1，0！也等于1不合理，但实际上这个规定是合理的。

首先n！＝1*2*3*....*n＝（n-1）！*n

从这点来代入计算，

1！＝（1-1）！*1＝0！*1＝1

易知0！＝1

当然，0！＝1不是因为这个而规定成这样的。我只是想提及一下这个规定不是想像中的不合理。至于到底为什么要规定成这样，可以参照一下知乎另一个问题下的答案。

关于0!=1 ??

www.zhihu.com

前面这些都懂了的话，利用阶乘，四个0很容易凑出24，方法如下：

（0！+0！+0！+0！）！

＝（1+1+1+1）！

＝4！

＝1*2*3*4

＝24

---

只用一个0就可以得到24。

黎曼猜想基于黎曼 函数(Riemann Zeta Function)：

, 例如 , 黎曼猜想是说解析延拓后的 函数的非平凡零点的实部一定是 。

我们容易得到

。

使用Maple验证结果等于24。

---

首先，按照正规的24点规则（只用四则运算）肯定是无解的。所以，需要把24点规则扩展一下：允许使用初等函数，且不得显式引入其他常数。（比如根号视为显式引入了1/2，倒数视为引入了-1，取0次方视为引入了0，等等）。

对于0,0,0,0这个特例：

有：

...

所以：

同时，我们可以适当扩展一下，

注意到：

...

定义：

并定义母函数：

则： 是关于 的初级函数。

且:

及：

对任意4个自然数m,n,o,p，有万能公式：

---

来个不一样的：

---

题主没说是什么运算（不过至少加减乘除是可以用的吧）。

我们可以打开Python，写下一行代码

len(0+++++0+++++0+++++0+++++)

你会发现结果是24（狗头）

---

写一个憨批的解：

其中 ?x? 代表对x向上取整

验证：

思路：

考虑到

以及

---

我写个C语言的：

0 * 0 / ( 0 + 0 )

总有菜鸟评论「你这样会超出范围的」，补上截图，堵住他们的嘴

别再发错误的评论了，好好学习去吧，这里是知乎

---

我除了阶乘外,只用两个最基本的数论函数:

表示 的正约数个数

表示 的正约数之和

考虑

完了.

---

二更：其他的答案都是看作四个0做运算，现在我们来试试直接对0,0,0,0这个整体来

[0,0,0,0].length=4

一步到位，都不用把四个0拆开来

---

("0"+"0"+"0"+"0").length=4

4!=24

可惜js不能方便的算阶乘

---

不正经回答，构建一个BP神经网路，包含3层隐藏层，结构图如下所示：

然后尝试用这个网路去解决一个回归问题，选一个什么问题好呢？为了让这个模型有点实际意义，考虑到这个需求作为脑筋急转弯的正解是00:00 = 24点，那就让它通过4位时间码去回归按小时换算的时间值吧……例如，在理想状态下，输入向量[1, 0, 3, 0]，模型会输出10.5，而输入向量[0, 0, 0, 0]，模型会输出24，从而满足需求。

下面就是构造数据集。首先列出从00:00到23:59的时间码数据和对应的标注，并人为规定时间码中的0点对应于标注中的24点。对时间码进行训练集和验证集的分割，并对训练集进行数据增强，将样本容量扩充到50000。最后在ground truth上加上了高斯杂讯。

import random
import numpy as np

# 生成从00:00到23:59之间的所有时间码
tc = set((
(i // 10, i % 10, j // 10, j % 10), # 时间码
i + j / 60 if i &> 0 else 24 + j / 60) # 标注
for i in range(24) for j in range(60))
# 划分训练集与验证集
tc_train = random.sample(tc, int(len(tc) * 0.8)) # 80%的时间码为训练集
tc_val = tc - set(tc_train) # 20%的时间码为测试集
# 数据增强
train_count = 50000
X_train, Y_train = [], []
for i in range(train_count):
t = random.choice(tc_train)
X_train.append(t[0])
Y_train.append(t[1])
X_train = np.array(X_train)
Y_train += np.random.normal(0, 1e-2, (train_count,)) # 添加杂讯
X_val = np.array([list(t[0]) for t in tc_val])
Y_val = np.array([t[1] for t in tc_val])

接著使用Keras构建模型。话题又回到了模型结构上，我原本以为这是个线性回归问题，但是由于0点的特殊性（0点被映射到24，而1-23点都不变）破坏了线性关系，所以必须合理地增加模型深度。由于ground truth的值域是 ，于是采用ReLU作为激活函数，并用小正数进行参数初始化。这次超参数调了挺多次，因为很容易踩坑：

import keras
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from keras.initializers import RandomUniform

# 构建神经网路模型
ki = RandomUniform(minval=0, maxval=0.05) # 初始化器
model = Sequential()
model.add(Dense(4, input_shape=(4,), activation=relu, use_bias=True, kernel_initializer=ki, bias_initializer=zeros))
model.add(Dense(4, activation=relu, use_bias=True, kernel_initializer=ki, bias_initializer=zeros))
model.add(Dense(4, activation=relu, use_bias=True, kernel_initializer=ki, bias_initializer=zeros))
model.add(Dense(1, activation=relu, use_bias=True, kernel_initializer=ki, bias_initializer=zeros))
model.compile(loss=mse, optimizer=SGD(lr=1e-4, momentum=0, nesterov=True)) # 损失函数和优化器
model.summary()

然后用做好的数据集训练模型200轮，并输出loss曲线图，发现收敛还是比较迅速。在使用了适合回归问题的均方误差loss的情况下，验证集在我电脑上跑出的损失为0.0057，基本满足泛化要求。

# 训练
model.fit(X_train, Y_train, validation_data=(X_val, Y_val), epochs=200, batch_size=64)

然后就是最终的测试，把[0, 0, 0, 0]放入模型进行预测：

# 最终测试
sample = [0, 0, 0, 0]
print(f(0, 0, 0, 0) =, round(model.predict(np.array([sample]))[0][0]))

收工！

---

0000 四个环拼起来就是奥迪车标

一辆入门奥迪A4大约二十四万

再更新一下

高赞不是说 0！=1 故而 0！+0！+0！+0！=4 进而 4！=24

试问 0！=1在程序中不就是0不等于1吗？！那设计程序的人为何不避开阶乘？？

---

事实上3个0就够用了，第4个0可以只走个场子。

(int)((char)0÷(cos(0)+cos(0))+0)==24

---

已经有答主提到了

（0！＋ 0！＋0！＋0！）！＝24

可以稍微扩展一下将此公式适用于任意四个常数。

对于任意常数A， A ＝0.

所以任意给四个数ABCD，我们可以用以下公式算出24.

（（A）！＋（B）！＋（C）！＋（D）！）！

＝24

妈妈再也不用担心我算不出24点了。

---

00:00=24点？

---

高中时玩腻了的东西，后来发展为：【仅限使用卡西欧学生计算器上的运算符、仅限使用除括弧外每个运算符最多1次、仅限使用1个0，来算24】

有兴趣的高中生朋友们可以在网课无聊的间隙试一下~！

经过当时的同学提醒，我们的最终进度应该是：

【新品卡西欧学生计算器、不使用任何0-9或A-F的数字键、除括弧外每个运算符最多使用一次，算24】，所以用Ans之类的作弊不算= =+

---

0+0+0+0!=24

为什么这么说呢

因为在许多语言中 != 是不等于的意思

---

大家都在正经回答

我来一个不正经的好了

抽代告诉我们运算的本质是集合到集合的映射

我们构造一个R*R*R*R到R的映射f

满足f(0,0,0,0)=24就行了

狗头

---

哪里违规了？2020/4/1重写

首先我们有：

import math
π = str(math.pi)

基本形态：

# π[len(ord({))] == 4
# 4! == 24

可以得到：

24 = π[len(ord({))] !

注： 指括弧内表达式可以重复n次。

例如n = 100时，表示为：

24 = 0 + 0 + 0 + 0 + π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[π[!(π[ π[len(ord({))] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] ])]] !

这又让我想起了JSFuck（见下面链接）

---

万能解：

有哪些变态的24点演算法？?

www.zhihu.com

---

推荐阅读：