如何对 0，0，0，0 进行运算得到 24？第1页

han-dong-ran 网友的相关建议:

这个题目应该换一个问法：

【如何一本正经地把0无中生有地变成非零？】

yang-zhi-da-e-79 网友的相关建议:

24岁，是学生。

众所周知野兽先辈的专用数字（大嘘）是114514

∵0+0+0+0=0

∴(1+1)X4-5+1-4=0

所以0=0=野兽先辈

Q.E.D

mian-hua-tang-90-75 网友的相关建议:

太多了

这是个大坑（

比较普通难看一点的

用了阶乘但是看起来逼格还挺高的

指正下面 @Pecco 的回答（定积分的位置错了应该在最外圈，下面所有积分的常数项均为0）：

又由于可以简写为（至少我的那本AP Calculus AB教程上写着可以）于是我还能

不用阶乘的

如果连三角都不要的话……

因为很多特殊函数当自变量为0时值相等（如、、等），所以用上面的很多函数还能组合出很多个满足条件的式子

破千了！？

随手整的一个活居然就破千了

然后我认真答的都没人看（你有认真答的吗啊喂

这些函数都是wiki和wa里面找的，我日常生活中能用到的也就那几个椭圆积分、GammaBeta、几个对数三角相关的和exp，所以其实上面有超过90%的东西我都不懂（捂脸

我数学也不算很好，肯定不如那些系统接受过高中教育的学生，只是好高骛远地看点学点就拿来装那啥了，基本上是现学现卖

所以就一菜鸡，受宠若惊

感谢大家的支持！

sithferia 网友的相关建议:

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

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

PandoraEartha 网友的相关建议:

现在是智能化时代, 我们也要跟上时代潮流.

我们用一下神经网络啊!

题主要我们做什么呢? 哦, 要通过计算出 .

如果我们用神经网络来理解, 就是输入值, 就是输出. 也可以理解为是输入, 是标签.

那么我们要做的就是搭建一个神经网络, 并且利用 , 进行训练, 达到下一次输入的时候能够输出的目的.

在这篇回答中, 我就不用TensorFlow和pytorch了. 我直接纯代码手撸神经网络.

神经网络的基本单位是神经元, 而神经元的定义如下.

一个神经网络当然不止有一个神经元, 我们要将神经元相互连接在一起, 连接成网, 才能形成神经网络. 现在, 我们的输入数据是维的, 我们就可以用个神经元接受输入数据, 再用一个神经元处理这个神经元的输出值. 那么, 我们的神经网络就有两层一共个神经元. 不直观? 没关系, 我画成图就好理解了.

可以看到, 蓝色的神经元用来接收输入值, 而红色的神经元则连接蓝色的神经元, 经过处理之后, 输出.

数学公式和网络结构最终都必须转化为代码才能运行, 那我们一起看看代码是怎样写的吧.

首先, 我们必须导入numpy和matplotlib分别用于矩阵运算和画图.

再次说明, 本回答不使用TensorFlow和pytorch, 直接纯代码手撸神经网络.

本回答神经元最外层函数为 , 该函数定义如下.

各个神经元定义如下

损失函数

数学定义:

分别是预测值和实际值.

对于本问题来说, 输入的值为 , 期望输出的值是 .

输入数据的纬度是维, 所以每个神经元里面就有个权重和一个偏置 .

我们将权重和偏置在最开始都设置为随机. 学习率设置为

这些初始条件设置完毕后, 我们就要开始训练我们的神经网络了.

训练神经网络主要用的是后向传播算法(back propagation, BP). 简单来说就是将神经网络输出端的信息传到神经网络中, 不断改变神经网络中各个神经元的参数, 从而达到输出值逼近期望值的目的.

如下图, 假设我们目前在点, 我们要去点. 在点的时候我们发现我们偏左上, 所以我们调整参数往右下, 到了点我们又发现我们偏右上, 所以我们往左下. 这样经过迭代, 当我们与期望距离很近的时候, 我们就认为我们达到了目的.

现在的问题是, 我们怎么知道我们到底应该怎么样调整参数呢?

我们回到损失函数来,

我们最终的目标就是不断调整神经元的各个参数, 让不断趋于 . 前面提到过, 输入的数据经过了各个神经元的处理,才得到预测值 , 最终才经过的计算得到 .

所以, 损失函数实际上是一个多元函数, 包含了输入值和所有神经元的各个参数.

对于本回答来说.

而如果我们能知道关于某一个参数的变化率, 我们用这个参数的本来的值, 减去关于这个参数的变化率, 得到新的参数, 再计算 , 那不就能让越来越小吗?

如图所示. ,

所以相比来说更接近

对的时候来说也是一样的.

OK, 所以我们就是要求损失函数对各个参数的导数, 然后调整各个参数, 最终达到非常接近的目的.

但是损失函数是多元函数, 怎么求对某个参数的导数呢? 或者说, 偏导数.

不要害怕, 我们有链式求导法则.以为例

写成代码就如下所示

先计算各个神经元的输出值

计算对各个权重的偏导数

计算对各个偏置的偏导数

后向传播产生新的参数

最后输出结果并作和训练次数的图像.

当然, 我们这里要做一点处理, 因为神经元函数值域是而我们的期望输出是 , 所以我们还要把最末端神经元计算的值乘以否则永远不收敛.

看看效果?

       19.702617741927355 20.254113271234427 20.700706136192625 21.06579717407228 21.367445959829567 21.619376132124025 21.831984183087897 22.013174567809795 22.16900036515601 22.30413870271793 22.422238927524152 22.526176863827246 22.618241021078944 22.7002697882441 22.773753301121523 22.839909733334885 22.899742947462975 22.954086455284454 23.00363723747152 23.048981987430523 23.090617646382366 23.128967600026236 23.164394550893938 23.197210823077867 23.22768666852371 23.2560570064326 23.282526925464925 23.307276202486516 23.33046303453142 23.352227137463142 23.372692331893496 23.391968711650176 23.410154470564727 23.42733744817691 23.4435964430821 23.45900233330992 23.473619035734377 23.48750433063899 23.500710572861763 23.51328530716934 23.525271802461454 23.536709516934394 23.547634504318136 23.558079769653943 23.56807558172565 23.57764974814158 23.5868278581397 23.595633497421144 23.60408843867667 23.612212810935382 23.620025250415175 23.62754303517605 23.63478220555764 23.641757672111474 23.64848331250844 23.654972058705958 23.66123597549189 23.66728633137895 23.673133662700224 23.67878783165053 23.684258078926998 23.689553071543163 23.69468094632256 23.699649349518197 23.70446547295263 23.70913608702834 23.71366757091846 23.718065940213698 23.722336872270787 23.726485729481364 23.730517580656684 23.734437220703047 23.738249188744444 23.74195778483297 23.745567085373125 23.7490809573736 23.752503071628666 23.755836914921517 23.759085801332798 23.76225288272954 23.76534115850287 23.768353484616014 23.771292582018972 23.77416104448054 23.776961345884136 23.77969584702962 23.78236680197942 23.78497636398425 23.787526591020193 23.790019450966653 23.792456826451836 23.79484051939034 23.79717225523538 23.79945368696622 23.80168639882987 23.803871909854387 23.806011677149883 23.808107099011966 23.81015951784123 23.812170222891346 23.814140452857355 23.816071398314797 23.817964204019702 23.819819971078427 23.821639758995914 23.823424587610212 23.825175438920542 23.82689325881556 23.82857895870825 23.830233417083125 23.831857480961272 23.8334519672881 23.835017664248728 23.83655533251513 23.838065706429262 23.839549495125922 23.841007383598868 23.8424400337135 23.84384808516924 23.8452321564144 23.84659284551637 23.8479307309895 23.849246372583178 23.85054031203223 23.851813073771726 23.853065165618226 23.85429707941912 23.855509291671957 23.856702264115288 23.85787644429248 23.85903226609004 23.86017015025171 23.861290504869597 23.862393725853533 23.863480197379783 23.864550292320146 23.86560437265243 23.866642789853252 23.867665885274008 23.86867399050091 23.86966742769977 23.870646509946408 23.871611541543245 23.87256281832282 23.87350062793889 23.874425250145556 23.8753369570652 23.87623601344554 23.87712267690642 23.87799719817685 23.878859821322592 23.879710783964942 23.880550317490837 23.88137864725496 23.88219599277396 23.88300256791331 23.883798581067055 23.88458423533073 23.885359728667808 23.886125254069945 23.886880999711295 23.887627149097064 23.888363881206715 23.889091370631885 23.889809787709346 23.890519298649153 23.89122006565822 23.89191224705949 23.892595997406907 23.89327146759632 23.893938804972514 23.89459815343254 23.89524965352543 23.895893442548527 23.896529654640496 23.897158420871172 23.897779869328378 23.898394125201825 23.899001310864186 23.899601545949505 23.900194947428986 24.0

不错不错, 真的计算出了.

太棒了, 太棒了.

同时, 也可以看到, 随着训练次数的增加, 最终收敛到(灰常灰常)接近

实际上, 从任意数字计算出都是可以的.

那么, 如果我们将神经网络封装成一个函数.

我们就可以从 (或任何矩阵)计算出 (或任何矩阵).

       #coding:UTF-8 import numpy import matplotlib.pyplot  def sigmoid(x):     return 1/(1+numpy.exp(-x))  def neure1(inputs,weights,bias):     return sigmoid(numpy.dot(inputs,weights)+bias)  def neure2(inputs,weights,bias):     return sigmoid(numpy.dot(inputs,weights)+bias)  def neure3(inputs,weights,bias):     return sigmoid(numpy.dot(inputs,weights)+bias)  def neure4(inputs,weights,bias):     return sigmoid(numpy.dot(inputs,weights)+bias)  def neure5(inputs,weights,bias):     return sigmoid(numpy.dot(inputs,weights)+bias)  def MSE(predicted,expected):     return (predicted-expected)*(predicted-expected)  inputs=numpy.array([0,0,0,0]) weights=numpy.random.rand(5,4) bias=numpy.random.rand(1,5) learningTime=0 lossArray=numpy.array([]) predictedArray=numpy.array([]) expected=24 learningRate=0.01  while True:     # values after neurels     valueNeure1=neure1(inputs,weights[0,:],bias[0,0])     valueNeure2=neure2(inputs,weights[1,:],bias[0,1])     valueNeure3=neure3(inputs,weights[2,:],bias[0,2])     valueNeure4=neure4(inputs,weights[3,:],bias[0,3])     valueNeures=numpy.array([valueNeure1,valueNeure2,valueNeure3,valueNeure4])     predicted=neure5(valueNeures,weights[4,:],bias[0,4])       # Partial Derivative of MSE to weights     partialDerivative_MSE_weight00=2*(predicted-expected)*weights[4,0]*predicted*(1-predicted)*inputs[0]*valueNeure1*(1-valueNeure1)     partialDerivative_MSE_weight01=2*(predicted-expected)*weights[4,0]*predicted*(1-predicted)*inputs[1]*valueNeure1*(1-valueNeure1)     partialDerivative_MSE_weight02=2*(predicted-expected)*weights[4,0]*predicted*(1-predicted)*inputs[2]*valueNeure1*(1-valueNeure1)     partialDerivative_MSE_weight03=2*(predicted-expected)*weights[4,0]*predicted*(1-predicted)*inputs[3]*valueNeure1*(1-valueNeure1)      partialDerivative_MSE_weight10=2*(predicted-expected)*weights[4,1]*predicted*(1-predicted)*inputs[0]*valueNeure2*(1-valueNeure2)     partialDerivative_MSE_weight11=2*(predicted-expected)*weights[4,1]*predicted*(1-predicted)*inputs[1]*valueNeure2*(1-valueNeure2)     partialDerivative_MSE_weight12=2*(predicted-expected)*weights[4,1]*predicted*(1-predicted)*inputs[2]*valueNeure2*(1-valueNeure2)     partialDerivative_MSE_weight13=2*(predicted-expected)*weights[4,1]*predicted*(1-predicted)*inputs[3]*valueNeure2*(1-valueNeure2)      partialDerivative_MSE_weight20=2*(predicted-expected)*weights[4,2]*predicted*(1-predicted)*inputs[0]*valueNeure3*(1-valueNeure3)     partialDerivative_MSE_weight21=2*(predicted-expected)*weights[4,2]*predicted*(1-predicted)*inputs[1]*valueNeure3*(1-valueNeure3)     partialDerivative_MSE_weight22=2*(predicted-expected)*weights[4,2]*predicted*(1-predicted)*inputs[2]*valueNeure3*(1-valueNeure3)     partialDerivative_MSE_weight23=2*(predicted-expected)*weights[4,2]*predicted*(1-predicted)*inputs[3]*valueNeure3*(1-valueNeure3)      partialDerivative_MSE_weight30=2*(predicted-expected)*weights[4,3]*predicted*(1-predicted)*inputs[0]*valueNeure4*(1-valueNeure4)     partialDerivative_MSE_weight31=2*(predicted-expected)*weights[4,3]*predicted*(1-predicted)*inputs[1]*valueNeure4*(1-valueNeure4)     partialDerivative_MSE_weight32=2*(predicted-expected)*weights[4,3]*predicted*(1-predicted)*inputs[2]*valueNeure4*(1-valueNeure4)     partialDerivative_MSE_weight33=2*(predicted-expected)*weights[4,3]*predicted*(1-predicted)*inputs[3]*valueNeure4*(1-valueNeure4)      partialDerivative_MSE_weight40=2*(predicted-expected)*valueNeure1*predicted*(1-predicted)     partialDerivative_MSE_weight41=2*(predicted-expected)*valueNeure2*predicted*(1-predicted)     partialDerivative_MSE_weight42=2*(predicted-expected)*valueNeure3*predicted*(1-predicted)     partialDerivative_MSE_weight43=2*(predicted-expected)*valueNeure4*predicted*(1-predicted)        # Partial Derivative of MSE to bias     partialDerivative_MSE_bias0=2*(predicted-expected)*weights[4,0]*predicted*(1-predicted)*valueNeure1*(1-valueNeure1)     partialDerivative_MSE_bias1=2*(predicted-expected)*weights[4,1]*predicted*(1-predicted)*valueNeure2*(1-valueNeure2)     partialDerivative_MSE_bias2=2*(predicted-expected)*weights[4,2]*predicted*(1-predicted)*valueNeure3*(1-valueNeure3)     partialDerivative_MSE_bias3=2*(predicted-expected)*weights[4,3]*predicted*(1-predicted)*valueNeure4*(1-valueNeure4)      partialDerivative_MSE_bias4=2*(predicted-expected)*predicted*(1-predicted)       # Backfoward     weights[0,0]=weights[0,0]-learningRate*partialDerivative_MSE_weight00     weights[0,1]=weights[0,1]-learningRate*partialDerivative_MSE_weight01     weights[0,2]=weights[0,2]-learningRate*partialDerivative_MSE_weight02     weights[0,3]=weights[0,3]-learningRate*partialDerivative_MSE_weight03     weights[1,0]=weights[1,0]-learningRate*partialDerivative_MSE_weight10     weights[1,1]=weights[1,1]-learningRate*partialDerivative_MSE_weight11     weights[1,2]=weights[1,2]-learningRate*partialDerivative_MSE_weight12     weights[1,3]=weights[1,3]-learningRate*partialDerivative_MSE_weight13     weights[2,0]=weights[2,0]-learningRate*partialDerivative_MSE_weight20     weights[2,1]=weights[2,1]-learningRate*partialDerivative_MSE_weight21     weights[2,2]=weights[2,2]-learningRate*partialDerivative_MSE_weight22     weights[2,3]=weights[2,3]-learningRate*partialDerivative_MSE_weight23     weights[3,0]=weights[3,0]-learningRate*partialDerivative_MSE_weight30     weights[3,1]=weights[3,1]-learningRate*partialDerivative_MSE_weight31     weights[3,2]=weights[3,2]-learningRate*partialDerivative_MSE_weight32     weights[3,3]=weights[3,3]-learningRate*partialDerivative_MSE_weight33     weights[4,0]=weights[4,0]-learningRate*partialDerivative_MSE_weight40     weights[4,1]=weights[4,1]-learningRate*partialDerivative_MSE_weight41     weights[4,2]=weights[4,2]-learningRate*partialDerivative_MSE_weight42     weights[4,3]=weights[4,3]-learningRate*partialDerivative_MSE_weight43      bias[0,0]=bias[0,0]-learningRate*partialDerivative_MSE_bias0     bias[0,1]=bias[0,1]-learningRate*partialDerivative_MSE_bias1     bias[0,2]=bias[0,2]-learningRate*partialDerivative_MSE_bias2     bias[0,3]=bias[0,3]-learningRate*partialDerivative_MSE_bias3     bias[0,4]=bias[0,4]-learningRate*partialDerivative_MSE_bias4       # Result output     learningTime+=1     predicted=predicted*expected     loss=MSE(predicted,expected)     lossArray=numpy.append(lossArray,loss)     predictedArray=numpy.append(predictedArray,predicted)     print(predicted)     if loss<=0.01:         print(numpy.rint(predicted))         x=numpy.arange(learningTime+1)         matplotlib.pyplot.plot(x[1:len(x)],lossArray,color='r')         matplotlib.pyplot.xlabel('Training Times')         matplotlib.pyplot.ylabel('MSE')         matplotlib.pyplot.show()         break

mai-wen-xue-67 网友的相关建议:

((0++)++)++)++....... = 24

根本用不完 4 个零啊。

好吧。

0+0+0+ ((0++)++)++)++....... ++= 24

你们都用上函数和 AI 了，俺用 ++ 应该不犯规吧。

dong-qi-jun-42 网友的相关建议:

首先先理解阶乘。

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很容易凑出24，方法如下：

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

＝（1+1+1+1）！

＝4！

＝1*2*3*4

＝24

shen-tu-de-hui-85 网友的相关建议:

其实从编程的角度，这种设计是需要严格禁止的。

换句话说：外表相似但实质表现不同的函数，我们需要把它的接口或者名称有意做得不同，避免误用。

所以：这个商品的设计师，它肯定不懂编程。

如果是我，可能会刻意的改变USB插座的位置布局，让它看起来长得不一样。——至少改变一下USB插口的颜色。

老插线板名义上是 5V2A 的 10W 插线板，实际上是单口输出最大2A，多口同时输出的情况下，它的实际表现大约是 5V1A，也就是苹果那个万年诟病充电头的水平。——换句话说，旧插线板的USB接口，几乎是没有什么用处的鸡肋。

新插线板，号称单口27W，多口的情况下肯定会缩水，但我猜测至少QC3.0快充是可以用的。相比旧板子应该说是从协议层面有了很大进步。一个典型的例子是接无线充电器不需要浪费充电头了。

解释一下：小米目前的无线充是 30W，需要30W的充电头，但商城只有 18W 跟 65W 的充电头出售，小米商城根本没有适配无线充的 30W 充电头。如果插这个接线板，大概能当 27W 用吧？

chao-wang-86-46 网友的相关建议:

你的感觉没错，确实容易产生这样的感觉。因为紧致性（简称紧性）的定义本身是与实数连续性没什么关系的（我更愿意称这里的“连续性”为完备性，因为我总感觉连续性是用来描述映射的，完备性更科学一点）。

首先，什么是紧性？就是任意开覆盖都有有限子覆盖。怎么理解呢？实际上，紧性就意味着一种“有限性”。它仿佛条条框框的约束，把一个集合的性质约束得很“有限”，这就是紧。具体来说，就是：紧集必是有界闭集。也即，如果一个集合是紧的，那么首先它不能无界，其次不能开。无界和开有一种共性：没有边界（boundary），也就是没有了“紧”的束缚。反例当然很容易举，随处可查。通过阅读反例你大概可以更理解到我的意思，也可以明白为什么这样定义紧性。

那么，这又与实数的完备性有什么关系呢？实数的完备性指出的是，在实数集中，有界闭集都是紧的，结合上述文字，也即这二者等价。仅以为例，我们来回想一下这个定理的证明过程，大致是这样的：利用反证法，对一个有界闭区间，将其无限细分，且每次都存在细分的区间都不能被有限开集覆盖（否则矛盾），最终由闭区间套定理得到一个聚点，它的开邻域可以覆盖无限细分的那个区间，矛盾。这里哪用到了完备性呢？闭区间套定理。

怎样直观理解这个证明的想法？实际上我们可以倒过来看。一个孤立点当然是紧的，可以说它的一切都被限制（约束）了。由于实数的完备性，每个孤立点之间没有“空隙”，因此，它们可以共有这种紧性，也就是说，可以把这种紧性“连起来”，从而整体上也表现出紧性。反之，若我们考虑不完备的空间，那么在“连接”的过程中就会出现连接处“连不上了”的情形，也就是连接处没有边界，从而破坏了约束（紧性）。这在证明中就体现为，每个有界闭区间都可以化归到它的一个聚点上去处理，如果全空间不完备，恐怕就不能如此操作了。

简言之， 的完备性保证了紧性的“不变性”。反过来也成立，可以想一想如何用有限覆盖定理去证明其他的完备性定理。

讲得直观，缺乏严谨性，词不达意，望有所帮助。

plel 网友的相关建议:

这是我看到的最准确的总结。

总的来说，就是中国的高考相对公平，所以性价比极高，所以其他活动都可以适当让步。

如何对 0，0，0，0 进行运算得到 24？的其他答案点击这里

如何对 0，0，0，0 进行运算得到 24？第1页

比较普通难看一点的

用了阶乘但是看起来逼格还挺高的

不用阶乘的

如果连三角都不要的话……

相关话题

前一个讨论

下一个讨论

相关的话题

如何对 0，0，0，0 进行运算得到 24？ 第1页

比较普通难看一点的

用了阶乘但是看起来逼格还挺高的

不用阶乘的

如果连三角都不要的话……

相关话题

前一个讨论

下一个讨论

相关的话题

如何对 0，0，0，0 进行运算得到 24？第1页