不确定的行为杀死了我的猫[关闭]


82

不确定的行为杀死了我的猫

众所周知,不确定的行为会杀死猫[需要引用]
但是可以吗?

你的任务

  1. 编写一个调用未定义行为的程序。
  2. 描述一种情况,该情况从上述程序的运行开始,由于前面提到的UB ,导致Felis catus在您拥有时终止其寿命。
  3. 估计方案​​中每个阶段的概率。
  4. 计算该程序一次运行会杀死猫的总概率。

规则

  1. 这是一场,因此,如果可以的话,请发挥创意。
  2. 这是与编程相关的挑战,因此事件链应该主要在计算机内部,而不是在真实世界中(当然,如果那是猫的所在,那么必须到达真实世界)。
  3. 如果您选择的语言没有未定义的行为,请使用类似的语言。
  4. 出示答案时,不会对动物造成伤害。

计分

投票数加上方案的总概率(不能超过1)。

在C中的示例:

main(){printf();}

场景:

  1. printf从堆栈中调用垃圾-未定义行为。机率:100%。
  2. 第一个参数恰好是字符串Your cat is ugly!。概率:(1/256)17 =(1.148 * 10 -37)%。
  3. 看到消息后,您拿起枪射击猫。机率:3%。
  4. 猫死了。机率:93%。

总概率:(3.202 * 10 -39)%。


50
1)引发未定义的行为2)仅仅受到以下事实的启发:您可以调用未定义的行为,并过着幸福的生活3)猫死了。总机率:100%
Geobits,2014年

5
@Oberon我会杀了我自己,如果我不能拿出一个单一的方式规划了这么久之后创建UB。这样猫就不再属于我了。调用UB使我活着,因此“ ...因此,在拥有所有权的情况下结束了生命……”。解析FTW不明确。
Geobits 2014年

8
如果有人重新解释该cat命令以杀死该命令或类似的东西,我会感到更开心。
keshlam 2014年

5
-1我爱猫。为什么是猫?为什么不杀害害虫?
VX 2014年

22
如果要吃猫,Python是一种解决方案。
Nicolas Barbulesco 2014年

Answers:


113

C

该问题的大多数答案都误解了该问题,因为它正在杀死catUNIX系统上的进程。这是一个程序,该程序可能导致该问题特定的Felis Cattus物种的生物生命形态灭绝。

该示例在Windows上运行,但是通过替换iexplore -k为启动已安装的Web浏览器的命令,可以轻松地将其移植到大多数UNIX操作系统。

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

int main() {
    char i; // uninitialised
    printf("Redirecting you to a website which will inform you how to properly feed your cat.");
    if (i != 42) {
         system("iexplore -k https://pets.stackexchange.com/questions/tagged/cats+diet");
    } else {
         system("iexplore -k https://cooking.stackexchange.com/questions/tagged/chocolate");
    }
    return 0;
}

该程序假装向用户提供有关猫食的建议。

它将启动Internet Explorer,并将用户定向到pets stackexchange,其中列出了许多有关如何养猫的有用问题。然而,有,低(1/256)的机会,这将用户发送到烹饪stackexchange而不是列出的技巧如何准备含有巧克力,餐具剧毒的。更糟糕的是,它将以信息亭模式(全屏)启动Internet Explorer,该模式将隐藏地址栏,并且对于那些不懂技术的用户来说很难摆脱。

这种聪明的诡计会诱使用户相信猫的巧克力是适合自己的饮食,从而诱使用户喂猫的巧克力,从而导致他们无意中杀死了它。


3
文笔比刀剑更有力!:)
Pieter Witvoet 2014年

12
这似乎是迄今为止迄今为止唯一有可能实际杀死猫的解决方案。我被迫投票,尽管我真诚地希望没人能真正付诸实践。
2014年

43
Internet Explorer可能会自行杀死猫。
迈克尔·汉普顿2014年

4
您是否可以通过概率分析逐步添加杀死猫的场景(如示例中所示)?实际上,这不是一个有效的答案。
ugoren 2014年

3
使用Internet Explorer在ME中引起未定义的行为。抱歉,不得不这么说。
tomsmeding

88

重击

据此INT_MIN % -1可能会或可能不会未定义(什么???),因此可能会对使用c / c ++实现的任何语言造成麻烦。

#!/bin/bash

cat <<< $((2**63%-1))

cat如果家长将杀死早期bash进程崩溃,这可能会或可能不会发生。

在我的VM上,我得到以下输出:

$ ./schroedinger.sh
./schroedinger.sh: line 3:  7805 Floating point exception(core dumped) cat <<< $((2**63/-1))
$ 

(我不太了解这个问题的评分,但是无论如何,这里都可以)

计算$((2**63%-1))。崩溃总是发生在bash 4.2.25上,但似乎仅在某些3.x版本上挂起。更多的不确定性。我可以告诉您确切的概率,但是由于海森堡不确定性原理,我会掉进一个黑洞。或者其他的东西。因此,我认为我们可以肯定地说它们的机率约为42%。


4
@ klingt.net:它被称为“ Here Strings”-更加可谷歌搜索……这是echo $((-2**63/-1)) | cat
VX

14
+1用于使用real cat
Alvin Wong

1
@mardavi INT_MAX = 2^63 - 1。如果将1加到INT_MAX,则64位数字空间将环绕并得到INT_MIN。换句话说,在带符号的64位整数运算中,2^63 == -2^63。我本可以使用-2**63,但最好选择不使用的简洁性-,因为在这种情况下,模块化算法是相同的。
Digital Trauma 2014年


1
您是否可以通过概率分析逐步添加杀死猫的场景(如示例中所示)?实际上,这不是一个有效的答案。
ugoren 2014年

40

C(序列点)

deadcat.c:

#include <stdio.h>
int main()
{
    int i=3;
    int k=0;
    k=i+(++i);
    if (k==7)
        printf("The cat is fine. k=i+(++i) =%d\n",k);
    else
        printf("Urgent Notice: Your cat has rabies. k=i+(++i) =%d\n",k);
}

执行(或不执行):

$ clang -w deadcat.c -o deadcat; ./deadcat
The cat is fine. k=i+(++i) =7
$ gcc deadcat.c -o deadcat; ./deadcat
Urgent Notice: Your cat has rabies. k=i+(++i) =8

情景和概率

假设运行此程序的人中有5%使用clang来编译C代码(相比之下,使用gcc时使用90%,使用其他C编译器时则为5%):

得到“猫很好”的可能性。= .050
 收到“紧急通知:您的猫患有狂犬病”的可能性。= .950

 将其放下即可对“您的猫患有狂犬病”做出反应的概率= .040
 忽略通知的概率= .900
 将猫带到兽医处进行治疗的可能性= .060

 猫生存的总概率:.05 + .95 *(.90 + .06)= .962
 猫死的总概率:.95 * .04 = .038
 检查:猫存活或死亡的总概率:= 1.000

说明:

k = i +(++ i)访问并更改序列点之间的“ i”。概率不能由程序确定。这取决于用户选择的编译器。“未定义”不一定表示“随机”。

参见https://stackoverflow.com/questions/4176328/undefined-behavior-and-sequence-points


4
+1用于演示不同编译器的行为。
ntoskrnl 2014年

1
优化级别也可能会改变行为
棘手怪胎2014年

1
@ratchet怪胎:是的,但是我无法通过这个特殊问题来证明这一点。我在多个gcc版本(从gcc-4.2.3到gcc-4.8.2,以及cc-5.0)上的Sun操作系统上尝试了-O0,-O1,-O2和-O3,但所有这些都杀死了这只猫。
Glenn Randers-Pehrson

2
您是否可以通过概率分析逐步添加杀死猫的场景(如示例中所示)?实际上,这不是一个有效的答案。
ugoren 2014年

1
我以为所有被带到兽医那里接受治疗的猫都会活下来。其中一些人可能会死于传染性猫病或兽医不当行为。可能会改变最终概率,例如.96 / .04
Glenn Randers-Pehrson

37

C

背景故事

我的妻子从家里继承了一只猫。不幸的是,我对动物过敏。这只猫已经过了它的鼎盛时期,甚至在我们得到它之前就应该被安乐死,但是由于它的感性价值,她无法摆脱它。我制定了一个计划来结束自己的痛苦。

我们本来打算放个长假,但她不想在兽医办公室上猫。她担心它会生病或受到虐待。我创建了一个自动猫喂食器,以便我们可以将其留在家中。我用C语言编写了微控制器的固件。其中包含的文件main与下面的代码相似。

但是,我的妻子也是一名程序员,并且知道我对这只猫的感受,因此她坚持要进行代码审查,然后才同意将其放在家里无人看管。她有一些担忧,包括:

  • main 没有符合标准的签名(用于托管实施)
  • main 不返回值
  • tempTm用于未初始化,因为malloc被调用代替calloc
  • 的返回值malloc不应该转换
  • 微控制器时间可能不准确或滚动(类似于Y2K或Unix时间2038问题)
  • elapsedTime变量可能不具有足够的范围

这令人信服,但她最终同意,这些问题并非出于各种原因(对于我们的航班已经来晚了,这并没有什么害处)。由于没有时间进行实时测试,因此她批准了代码,我们去了度假。几周后我们回来时,的猫的痛苦结束了(尽管结果我现在有很多了)。

†完全虚拟的场景,无需担心。


#include <time.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

//#include "feedcat.h"
// contains extern void FeedCat(struct tm *);
// implemented in feedcat.c
// stub included here for demonstration only
#include <stdio.h>
// passed by pointer to avoid putting large structure on stack (which is very limited)
void FeedCat(struct tm *amPm)
{
    if(amPm->tm_hour >= 12)
        printf("Feeding cat dinner portion\n");
    else
        printf("Feeding cat breakfast portion\n");
}

// fallback value calculated based on MCU clock rate and average CPI
const uintmax_t FALLBACK_COUNTER_LIMIT = UINTMAX_MAX;

int main (void (*irqVector)(void))
{
    // small stack variables
    // seconds since last feed
    int elapsedTime = 0;
    // fallback fail-safe counter
    uintmax_t loopIterationsSinceFeed = 0;
    // last time cat was fed
    time_t lastFeedingTime;
    // current time
    time_t nowTime;

    // large struct on the heap
    // stores converted calendar time to help determine how much food to
    // dispense (morning vs. evening)
    struct tm * tempTm = (struct tm *)malloc(sizeof(struct tm));

    // assume the cat hasn't been fed for a long time (in case, for instance,
    // the feeder lost power), so make sure it's fed the first time through
    lastFeedingTime = (size_t)(-1);

    while(1)
    {
        // increment fallback counter to protect in case of time loss
        // or other anomaly
        loopIterationsSinceFeed++;

        // get current time, write into to nowTime 
        time(&nowTime);

        // calculate time since last feeding
        elapsedTime = (int)difftime(nowTime, lastFeedingTime);

        // get calendar time, write into tempTm since localtime uses an
        // internal static variable
        memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));

        // feed the cat if 12 hours have elapsed or if our fallback
        // counter reaches the limit
        if(  elapsedTime >= 12*60*60 || 
             loopIterationsSinceFeed >= FALLBACK_COUNTER_LIMIT)
        {
            // dispense food
            FeedCat(tempTm);

            // update last feeding time
            time(&lastFeedingTime);

            // reset fallback counter
            loopIterationsSinceFeed = 0;
        }
    }
}

未定义的行为:

对于那些不想麻烦自己找到UB的人:

这段代码中肯定存在特定于本地的,未指定的和实现定义的行为,但是所有这些都应该正常工作。问题出在以下几行代码中:

struct tm * tempTm //... //... memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));
memcpy覆盖tempTM指针而不是它指向的对象,从而破坏了堆栈。除其他内容外,这还将覆盖elapsedTimeloopIterationsSinceFeed。这是我打印出值的示例运行:

pre-smash : elapsedTime=1394210441 loopIterationsSinceFeed=1 post-smash : elapsedTime=65 loopIterationsSinceFeed=0


杀死猫的可能性:

  • 给定约束的执行环境和构建链,始终会发生未定义的行为。
  • 同样,未定义的行为始终会阻止猫进给器按预期方式工作(或者允许其按预期方式“工作”)。
  • 如果喂食器不起作用,则极有可能猫会死。这不是一只能自食其力的猫,我没能要求邻居照看它。

我估计那只猫死的概率为0.995


&是memcpy中的(第一个)吧?
2014年

@Score_Under是的,让我编辑一下答案。我尝试了其他方法来利用未定义的行为,但是大多数方法都更加明显。
2014年

1
+1杀死猫,不是cat
凯文(Kevin)

31

重击

经典版

cat & # This is your cat.
pkill -$RANDOM cat

具有杀死范围内所有猫的优势。

请注意,该过程将立即停止,因此,通过单次调用pkill结束该过程的唯一方法是发送SIGKILL(9)。

因此:

p(SUCCESS) = p(RANDOM == 9) = 0.0275 %


量子版

schroedinger=/dev/null             # We'll need this guy.
heisenberg=/dev/urandom            # Also needed, for uncertainty principle.
cat $heisenberg > $schroedinger &  # Steal cat from Heisenberg and give it to Schrödinger.
felix=$!                           # Name cat for future references.
exec 2> $schroedinger              # Send all results to Schrödinger.
kill -SIGSTOP $felix               # Catch Felix and put him into a box.
if (($RANDOM & 1))                 # Flip a coin.
then kill $felix                   # Heads: Kill! Kill! Kill!
fi                                 # By now, Felix can be thought of as both alive and dead.
read -sn 1                         # Wait for somebody to open the box.
kill -SIGCONT $felix               # Let him open it.
if ps p $felix > $schroedinger     # Let Schrödinger check on Felix.
then echo The cat is alive.        # Hooray for tails!
else echo The cat is dead.         # At least, now we know.
fi                                 # This concludes the experiment.
kill -SIGKILL $felix               # Felix is no longer required.

实验期间杀死猫的可能性:50%


+1,但可能性比我想的要大。SIGINT(2),SIGQUIT(3),SIGABRT(6),SIGPIPE(13)和SIGTERM(15)至少在这里将其杀死。
l0b0

@ l0b0:不会,至少不是立即。cat &尝试从终端读取,但无法读取。如果您随后发送SIGCONT(18),则您提到的任何信号(以及更多信号)都将起作用。另外,我同意,挂断终止猫是一样杀死它,但中断它似乎并不令人满意...:P
丹尼斯

3
未定义行为正在使用已指定undefined的语言功能。也就是说,语言设计者故意使一些句法构造行为未定义,以使实现更容易,或者表明该构造不应在任何有效程序中使用。未定义行为通常与随机数生成无关,并且这里没有使用未定义行为。
OregonTrail 2014年

@OregonTrail:规则说如果您选择的语言没有未定义的行为,请使用类似的语言。Bash没有未定义的行为,因此我使用了随机数。
丹尼斯

3
在bash的环境中有很多未定义的行为可以使用。例如,@ DigitalTrauma Bash的printf的答案还使用系统的printf,该行为具有许多未定义的行为。
OregonTrail 2014年

17

C

请注意,这仅适用于linux。

main() {
  FILE *f = fopen("skynet", "w");
  srand(time(0));
  while(rand() != rand())
    fputc(rand()%256, f);
  fclose(f);
  system("chmod +x skynet");
  system("./skynet");
}
  1. 将随机数据写入文件并调用它(100%)
  2. 随机数据恰好是天网的源代码(1x10 ^ -999999999999999999999999999999999999999999999999999999999999,aprox。)
  3. 猫死于世界末日(99.999%)

总概率:1x10 ^ -999999999999999999999999999999999999999999999999999999999999999


嗯,天网是什么?
Sarge Borsch 2014年

20
未定义的行为在哪里?
ugoren 2014年


1
@ugoren我认为运行包含随机内容的文件并没有真正定义。
2014年

2
@ 11684,如果内容恰好是天网的代码,则天网的程序员知道他们在做什么,就没有未定义的行为。
ugoren 2014年

15

C ++

您的猫既死又活,直到您好奇为止。然后,您意识到猫死了的可能性为0.5。

#ifdef WIN32
#pragma warning(disable: 4700)
#endif
#include <random>
#include <iostream>
#include <vector>
#include <climits>
#include <memory>
class Cat
{
public:
    enum class State {DEAD, ALIVE};
    Cat()
    {
        int x; // Uninitialized Variable on Stack
        if (x % 2 == 0) // Is the Uninitialized Variable even? 50-50
        {
            m_dead = State::DEAD;

        }
        else
        {
            m_dead = State::ALIVE;
        }
    };
    operator State() //Check if your Cat is Dead / Alive
    {
        if (m_dead == State::DEAD)
        {
            delete this; //Boom Cat is dead
            std::cout<<"Your Curiosity killed your Cat"<<std::endl;
            return false;
        }
        return m_dead;
    }
private:
    State m_dead;
};

class Schrödinger
{
public:
    Schrödinger(size_t size):m_size(size)
    {
        for(size_t i = 0; i < size; i++)
        {
            cats.push_back(new Cat());
        }
    }
    ~Schrödinger()
    {
    }
    void Curiosity()
    {
        std::default_random_engine generator;
        std::uniform_int_distribution<int> distribution(0,m_size);
        if(*cats[distribution(generator)] == Cat::State::ALIVE)
        {
            std::cout<<"You Cat is alive and still kicking" <<std::endl;
        }
    }
private:
    std::vector<Cat *> cats;
    size_t m_size;
};
int main()
{
    int size;    
    std::cout<<"How Big is Your Example Space ?";
    std::cin>>size;
    Schrödinger your(size);
    your.Curiosity();
    return 0;

}

你能访问this->m_dead之后delete this
Bryan Chen

@BryanChen:缺少回报。谢谢您指出:-)
Abhijit)

ö在C ++中似乎不是有效的符号。也许用替换它oe
Ruslan 2014年

13

C

在Linux上运行。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void f(char x) {
    if(sleep(1)==x) system("killall cat");
}
int main() {
    char x; // uninitialised
    system("cat /dev/urandom &");
    f(x);
    return 0;
}

杀死猫的概率:1/256(sleep(1)返回0,因此如果x它为零,它将被杀死。)

作为奖励,它可以杀死当前在系统上运行的所有猫。


如果您如此讨厌猫,我向您介绍:

猫C(重击)

echo "Hello World"|cat|cat|cat

基于以下事实:在《人类C(第一序列)》中,all的所有三只狗都死了,而three的三分之二都死了,我估计杀死一只猫的概率是5/6。


Cat Centipede真的很有趣
Sarge Borsch 2014年

猫cent应该是“实际的”答案。
Ismael Miguel

@Ismael Miguel您可能是对的,我删除了C代码。起初这只是个玩笑,但后来我意识到我可以重新措辞以使其成为实际答案。
ace_HongKong独立

您可以保留您的C代码,我对此一无所获。我只是认为bash版本更适合作为答案。
Ismael Miguel 2014年

@Ismael Miguel Nah,无论如何,C代码还是很愚蠢
ace_HongKongIndependence 2014年

9

的JavaScript

~"cat".localeCompare("dead")
  ? "Cat is dead"
  : "Cat is fine"

执行:

  • Chrome:结果"Cat is fine"
  • Firefox:结果"Cat is dead"

说明:

15.5.4.9 String.prototype.locale比较(that)

实现定义的方式比较两个字符串

引用Glenn Randers-Pehrson的观点,该程序无法确定该概率;这取决于用户对浏览器的选择。


在FF 27上无法复制。您正在测试哪个版本?
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 2014年

-1:未定义行为与实现定义行为完全不同。
whitequark 2014年

2
@whitequark不,不是。这是一个定义的函数,结果不确定。未定义行为。
乔治·赖斯2014年

1
@whitequark我在这里看不到任何C。就JavaScript而言,JavaScript 是否具有未定义的行为似乎认为实现定义的行为是可以通过的。
乔治·里斯

1
@whitequark没有其他人感到困惑。一句话就是一句话,我不需要委员会来告诉我这意味着什么。
乔治·赖斯2014年

9
int foo() {}

void main() {
    int x = foo();
}

读取应该返回值的函数值会导致未定义的行为。现在,很明显,[需要引用]:“每次达到不确定的行为,上帝就会杀死一只小猫。” 由此得出结论:

  • 您达到不确定行为的机率-100%
  • 上帝杀了你的小猫的概率-1/200000000 看看为什么
  • 所以概率是0.0000005%

可以轻松地循环扩展以消灭世界上所有的猫。


5
您的概率太高了100倍(2亿只猫,而不是2百万只猫)。
ugoren 2014年

我以百分比表示。:)
彼得

1
它以百分比表示,但仍然高出100倍。
ugoren 2014年

您是对的,显然我不再能阅读数字了。
彼得

这是不正确的。仅当调用方尝试使用返回值时才调用UB。否则,使用非void返回类型的函数结束是完全合法且定义明确的。
R.,

5

Java(垃圾回收)

尽管代码可以调用System.gc(),但不能确保垃圾收集器将收集所有未使用的对象。因此,对于以下代码,无法确定猫是否会被杀死。

public class KillTheCat {
    public static void main(String[] args) throws InterruptedException {
        KillTheCat cat = new KillTheCat();
        cat = null;
        System.gc();
        System.out.println("Cat is still alive.");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Cat has been killed.");
        System.exit(0);
    }
}

无法计算概率。

请注意,如果在sysout之后和System.exit(0)之前的GC线程中有上下文切换,则猫仍然有可能“复活”,但我不愿覆盖它以使概念更简单。


1
不好 所编写的代码几乎总是同时打印两个代码。最好在行System.out.close()后添加System.out.println("Cat is still alive.");
durron597 2014年

据我了解,“几乎总是”与问题的不可预测性相匹配。
user3001267

5

有人想过要真正杀死(a)cat吗?

[ $[ $RANDOM % 6 ] == 0 ] && rm /bin/cat || echo Meow

cat死亡几率

为了概率...我想我们需要区分一些情况:

  1. Windows用户:可能无法执行。cat即将死去的机会s非常低,可以安全地假定为零。如果安装了Cygwin,他将被视为Unix用户。
  2. 没有root特权的Unix用户:杀死catwill失败。
  3. 以root特权运行的Unix用户:虽然每个调用只会cat以1/6的机会杀死s,但他很可能会重复执行该操作,直到发生意外情况为止。在不失一般性的前提下,我cat想肯定会死的。

总体概率取决于用户的混合方式,并且难以确定。但是我们可以肯定地说:Windows是小猫的安全场所。

测试是否遵守规则

出示答案时,不会对动物造成伤害。

这没有杀死动物,答案得到了美国人道主义协会的认可

$ file `which cat`
/bin/cat: Mach-O 64-bit executable x86_64

清楚地证明那cat不是动物(只要file不知道任何类型的隐藏文件类型继承)。


5

C

如果猫的名字太长,它就会死。gets导致猫死亡以及其他问题。

#include <stdio.h>
#include <stdbool.h>

/* Stores instances of cats. */
struct cat {
    /* 6 bytes are more than enough. */
    char name[6];

    /* Stores whether your cat is dead. */
    bool dead;
};

int main(void) {
    /* This is your cat. */
    struct cat your_cat;
    /* It lives. */
    your_cat.dead = false;
    /* Determine its name. */
    printf("Your cat name: ");
    gets(your_cat.name);

    /* Output the cat state. */
    const char *state = your_cat.dead ? "dead" : "alive";
    printf("Your cat, %s, is %s.\n", your_cat.name, state);

    return your_cat.dead;
}

4

哈斯克尔

import Acme.Missiles
import System.IO.Unsafe
main = print (unsafePerformIO launchMissiles, undefined)

在这里,我们适用unsafePerformIO具有可观察到的副作用的动作。这始终是不确定的行为,至少效果的顺序也是如此。因此,该程序将首先在尝试评估时崩溃undefined(具有讽刺意味的是,它不是未定义的行为:它绝不能产生允许该程序继续进行其他操作的值),或者实际上会导致严重的国际化。副作用。在这种情况下,生存机会仅为0.001%

因此,杀死猫的概率为49.9995%。


3

ue

由于问题允许一种语言,只要其效果相似,就不会有不确定的行为,因此我选择Thue是因为它的不确定性,即当有多个规则可应用于当前规则时选择执行哪个规则州。

该程序将被送入微波炉的控制器中,在其中是我的猫。微波炉的门是关闭的,并用一条拉链结扎好。程序的输出将决定微波炉是否开始对猫进行微波处理。

  • 如果输出为0,我们将开始实验长期暴露微波对活的哺乳动物(目前尚未充分研究)的影响。
  • 如果输出为1,我们将对猫刚刚失去9条生命之一并将其放出这一事实感到满意。

i::=~0
i::=~1
::=
i

杀死猫的概率取决于解释器的实现方式,但可以说是50%。那么,猫死的概率为0.5


不确定性并不意味着非定义
Score_Under


这个问题要求不确定的行为,这涉及利用将要编译和运行的语言的行为,但是没有具体说明它应该实际做什么。例如,将事情挂在钩子上Math.random()并不是不确定的行为,只是不可预测的行为。
Score_Under2014年

1
@Score_Under:问题中3. If you choose a language that doesn't have undefined behavior, use something similar.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1

爪哇

根据规范 java.util.Date将具有不确定的行为。因此,请尝试您的运气:

import java.util.Date;

public class App3
{
    public static void main (String args[])
    {
        String aliveOrDead;
        Date d = new Date(-1000,-1000,-1000);
        aliveOrDead = (d.getTime()<0)? "dead" : "alive";
        System.out.println("The cat is:" +aliveOrDead );
    }
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.