พฤติกรรมที่ไม่ได้กำหนดฆ่าแมวของฉัน

เป็นที่รู้จักกันดีว่าพฤติกรรมที่ไม่ได้กำหนดไว้สามารถฆ่าแมวของคุณ[อ้างจำเป็น]
แต่มันได้ไหม

งานของคุณ

1. เขียนโปรแกรมที่เรียกใช้พฤติกรรมที่ไม่ได้กำหนด
2. อธิบายสถานการณ์ที่เริ่มต้นด้วยโปรแกรมข้างต้นที่กำลังทำงานอยู่ส่งผลให้Felis catusจบชีวิตในขณะที่คุณเป็นเจ้าของซึ่งเป็นผลมาจาก UB ที่กล่าวถึงข้างต้น
3. ประเมินความน่าจะเป็นสำหรับแต่ละขั้นตอนในสถานการณ์
4. คำนวณความน่าจะเป็นทั้งหมดที่การรันโปรแกรมครั้งเดียวจะฆ่าแมวของคุณ

กฎระเบียบ

1. นี่คือการประกวดความนิยมดังนั้นจงสร้างสรรค์ถ้าคุณทำได้
2. นี่เป็นความท้าทายที่เกี่ยวข้องกับการเขียนโปรแกรมดังนั้นกลุ่มของเหตุการณ์ควรอยู่ในคอมพิวเตอร์เป็นส่วนใหญ่ไม่ใช่ในโลกแห่งความเป็นจริง (แน่นอนถ้าต้องไปถึงโลกแห่งความเป็นจริงหากนั่นคือที่ที่แมวของคุณอยู่)
3. หากคุณเลือกภาษาที่ไม่มีพฤติกรรมที่ไม่ได้กำหนดให้ใช้สิ่งที่คล้ายกัน
4. ไม่มีสัตว์ใดที่จะได้รับอันตรายจากการผลิตคำตอบของคุณ

เกณฑ์การให้คะแนน

จำนวนการลงคะแนนบวกความน่าจะเป็นรวมของสถานการณ์ (ซึ่งต้องไม่เกิน 1)

ตัวอย่างใน C:

main(){printf();}

สถานการณ์:

1. printfเรียกว่าด้วยขยะจากกอง - พฤติกรรมที่ไม่ได้กำหนด ความน่าจะเป็น: 100%
2. Your cat is ugly!พารามิเตอร์ตัวแรกที่เกิดขึ้นจะเป็นสตริง ความน่าจะเป็น: (1/256) ¹⁷ = (1.148 * 10 ^-37 )%
3. เมื่อเห็นข้อความคุณก็หยิบปืนขึ้นมาแล้วยิงแมวของคุณ ความน่าจะเป็น: 3%
4. แมวตาย ความน่าจะเป็น: 93%

ความน่าจะเป็นทั้งหมด: (3.202 * 10 ^-39 )%

C

คำตอบส่วนใหญ่สำหรับคำถามนี้ตีความคำถามผิด ๆ ว่ามันกำลังฆ่าcatกระบวนการในระบบ UNIX นี่คือโปรแกรมที่สามารถทำให้เกิดการตายของสิ่งมีชีวิตทางชีวภาพของสปีชีส์ Felis Cattus ตามที่ระบุไว้ในคำถาม

ตัวอย่างนี้ทำงานบน Windows แต่สามารถย้ายไปยังระบบปฏิบัติการ UNIX ส่วนใหญ่ได้อย่างง่ายดายโดยแทนที่iexplore -kด้วยคำสั่งเพื่อเรียกใช้เว็บเบราว์เซอร์ที่ติดตั้ง

#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 และนำผู้ใช้ไปยังสัตว์เลี้ยง stackexchange ที่แสดงรายการคำถามที่เป็นประโยชน์มากมายเกี่ยวกับวิธีการเลี้ยงแมว มี แต่ต่ำ (1/256) โอกาสที่จะส่งผู้ใช้ในการปรุงอาหาร stackexchangeแทนเคล็ดลับในรายการวิธีการเตรียมอาหารที่มีช็อคโกแลต, ซึ่งเป็นพิษกับแมว เพื่อทำให้เรื่องแย่ลงมันจะเปิดตัว Internet explorer ในโหมดคีออสก์ (แบบเต็มหน้าจอ) ซึ่งซ่อนแถบที่อยู่และยากต่อการหลบหนีจากผู้ใช้ที่ไม่ใช้เทคโนโลยี

เล่ห์เหลี่ยมอันชาญฉลาดนี้จะเกลี้ยกล่อมผู้ใช้ในการให้อาหารแมวช็อคโกแลตของพวกเขาเชื่อว่ามันเป็นอาหารที่เหมาะสมสำหรับมันจึงทำให้พวกเขาฆ่าโดยไม่ได้ตั้งใจ

ทุบตี

ตามนี้ , 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%

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

สถานการณ์และความน่าจะเป็น

สมมติว่าห้าเปอร์เซ็นต์ของคนที่ใช้โปรแกรมนี้ใช้เสียงดังกราวสำหรับการรวบรวมรหัส C (เทียบกับ 90 เปอร์เซ็นต์โดยใช้ gcc และ 5 เปอร์เซ็นต์โดยใช้ตัวแปลภาษา C อื่น ๆ ):

ความน่าจะเป็นที่จะได้รับ = .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

C

backstory

ภรรยาของฉันสืบทอดแมวจากครอบครัว ^†น่าเสียดายที่ฉันแพ้สัตว์มาก แมวผ่านตัวมันไปได้ดีและควรจะได้รับการกำจัดแม้แต่ก่อนที่เราจะได้รับมัน แต่เธอไม่สามารถพาตัวเองไปกำจัดมันได้เนื่องจากคุณค่าทางอารมณ์ของมัน ผมมีแผนจะจบของฉันทุกข์

พวกเราไปพักผ่อนในช่วงวันหยุดยาว แต่เธอไม่ต้องการให้แมวไปที่สำนักงานสัตวแพทย์ เธอเป็นห่วงว่าจะทำสัญญาเจ็บป่วยหรือถูกทำร้าย ฉันสร้างเครื่องป้อนแมวอัตโนมัติเพื่อให้เราสามารถทิ้งไว้ที่บ้าน ฉันเขียนเฟิร์มแวร์ของไมโครคอนโทรลเลอร์ใน C. ไฟล์ที่มีmainลักษณะคล้ายกับรหัสด้านล่าง

อย่างไรก็ตามภรรยาของฉันยังเป็นโปรแกรมเมอร์และรู้จักความรู้สึกของฉันที่มีต่อแมวดังนั้นเธอจึงยืนยันในการตรวจสอบโค้ดก่อนที่จะตกลงที่จะทิ้งมันไว้ที่บ้านโดยไม่ต้องดูแล เธอมีความกังวลหลายประการรวมถึง:

• main ไม่มีลายเซ็นที่เป็นไปตามมาตรฐาน (สำหรับการใช้งานโฮสต์)
• main ไม่ส่งคืนค่า
• tempTmถูกใช้โดยไม่กำหนดค่าเริ่มต้นเนื่องจากmallocถูกเรียกใช้แทนcalloc
• mallocไม่ควรทิ้งค่าส่งคืนของ
• เวลาของไมโครคอนโทรลเลอร์อาจไม่ถูกต้องหรือคลี่คลาย (คล้ายกับปัญหา Y2K หรือ Unix เวลา 2038)
• elapsedTimeตัวแปรอาจจะไม่ได้มีช่วงที่เพียงพอ

มันน่าเชื่อถือมาก แต่ในที่สุดเธอก็เห็นด้วยว่าสิ่งเหล่านี้ไม่ได้มีปัญหาด้วยเหตุผลหลายประการ เนื่องจากไม่มีเวลาสำหรับการทดสอบสดเธอจึงอนุมัติรหัสและเราไปเที่ยวพักผ่อน เมื่อเรากลับมาไม่กี่สัปดาห์ต่อมาฉันทุกข์ยากของแมวได้มากกว่า (แม้ว่าจะเป็นผลให้ฉันได้ในขณะนี้มีปริมาณมากขึ้น)

^{scenario สถานการณ์สมมติทั้งหมดโดยสิ้นเชิงไม่ต้องกังวล}

รหัส

#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ตัวชี้แทนวัตถุที่ชี้ไปที่ยอดเยี่ยมกองซ้อน นี้เขียนทับนอกเหนือไปจากสิ่งอื่น ๆและelapsedTime loopIterationsSinceFeedนี่คือตัวอย่างการรันที่ฉันพิมพ์ค่า:

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

ความน่าจะเป็นในการฆ่าแมว:

• ด้วยสภาพแวดล้อมการทำงานที่ จำกัด และการสร้างลูกโซ่พฤติกรรมที่ไม่ได้กำหนดจะเกิดขึ้นเสมอ
• พฤติกรรมที่ไม่ได้กำหนดจะป้องกันไม่ให้ตัวป้อน cat ทำงานตามที่ตั้งใจไว้เสมอ (หรืออนุญาตให้ "ทำงาน" ตามที่ตั้งใจ)
• หากตัวป้อนไม่ทำงานก็มีโอกาสมากที่แมวจะตาย นี่ไม่ใช่แมวที่สามารถดูแลตัวเองได้และฉันก็ไม่ได้ขอให้เพื่อนบ้านมองดูมัน

ผมประเมินว่าแมวตายด้วยความน่า0.995

ทุบตี

รุ่นคลาสสิค

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%

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. ข้อมูลแบบสุ่มเกิดขึ้นเป็นซอร์สโค้ดสำหรับ skynet (1x10 ^ -9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999,
3. แมวตายในวันโลกาวินาศที่เกิดขึ้น (99.999%)

ความน่าจะเป็นทั้งหมด: 1x10 ^ -999999999999999999999999999999999999999999999999999999999999999999999999999999, aprox

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;

}

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เป็นศูนย์)

เป็นโบนัสมันจะฆ่าแมวทุกตัวที่กำลังวิ่งอยู่ในระบบ

ถ้าคุณเกลียดแมวมากฉันก็ขอให้คุณ:

The Cat Centipede (Bash)

echo "Hello World"|cat|cat|cat

จากความจริงที่ว่าในHuman Human Centipede (First Sequence)สุนัขสามตัวของตะขาบสุนัขนั้นตายและสองในสามของมนุษย์ตะขาบตาย

JavaScript

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

การดำเนินการ:

• Chrome:ผลลัพธ์ใน"Cat is fine"
• Firefox:ผลลัพธ์ใน"Cat is dead"

คำอธิบาย:

15.5.4.9 String.prototype.localeCompare (ที่)

ทั้งสองสายจะถูกเปรียบเทียบในการดำเนินงานที่กำหนดไว้แฟชั่น

การอ้างถึงเกล็นแรนเดอร์ส - เพอร์สันโปรแกรมน่าจะไม่สามารถวัดได้ มันขึ้นอยู่กับทางเลือกของเบราว์เซอร์ซึ่งทำโดยผู้ใช้

int foo() {}

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

การอ่านค่าของฟังก์ชั่นควรจะส่งกลับค่าผลลัพธ์ในพฤติกรรมที่ไม่ได้กำหนด ตอนนี้ก็เป็นที่เห็นได้ชัด^{[อ้างจำเป็น]}ว่า "เวลาที่คุณถึงพฤติกรรมที่ไม่ได้กำหนดทุกพระเจ้าฆ่าคิตตี้." ใช้สิ่งนี้เราสรุป:

• ความน่าจะเป็นที่คุณเข้าถึงพฤติกรรมที่ไม่ได้กำหนด - 100%
• ความน่าจะเป็นคือคิตตี้ของคุณที่พระเจ้าฆ่า - 1/200,000 000 ดูว่าทำไม
• ความน่าจะเป็นคือ 0.0000005%

สามารถยืดได้อย่างง่ายดายโดยการวนซ้ำเพื่อกำจัดแมวทั้งหมดในโลก

Java (ชุดรวบรวมขยะ)

แม้ว่ารหัสสามารถเรียกใช้ System.gc () ไม่ได้ทำให้แน่ใจว่า Garbage Collector จะรวบรวมวัตถุที่ไม่ได้ใช้ทั้งหมด ดังนั้นสำหรับรหัสต่อไปนี้มันไม่แน่นอนถ้าแมวจะถูกฆ่าหรือไม่

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);
    }
}

ไม่สามารถคำนวณความน่าจะเป็นได้

โปรดทราบว่ายังมีโอกาสที่แมวจะ "ฟื้นคืนชีพ" หากมีการสลับบริบทในเธรด GC หลังจาก sysout และก่อน System.exit (0) แต่ฉันไม่ต้องการปิดมันเพื่อให้แนวคิดง่ายขึ้น

มีใครที่คิดจะฆ่า (ก) จริงcatหรือ

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

ความน่าจะเป็นของการcatตาย

สำหรับความน่าจะเป็น ... ฉันคิดว่าเราจำเป็นต้องแยกแยะบางกรณี:

1. ผู้ใช้ Windows : อาจไม่สามารถเรียกใช้งานได้ โอกาสในการตายcatของ s ต่ำมากสามารถสันนิษฐานได้ว่าปลอดภัยเป็นศูนย์ หากเขาติดตั้ง Cygwin ไว้เขาจะนับว่าเป็นผู้ใช้ระบบยูนิกซ์
2. ผู้ใช้ Unix รันโดยไม่มีสิทธิ์รูท : การสังหารcatจะล้มเหลว
3. ผู้ใช้ Unix ที่ทำงานด้วยสิทธิ์พิเศษ : ในขณะที่การโทรแต่ละครั้งจะฆ่าเพียงแค่catโอกาส 1/6 เท่านั้นเขาอาจจะทำซ้ำจนกว่าจะมีสิ่งที่ไม่คาดคิดเกิดขึ้น ฉันcatจะถือว่าตายอย่างแน่นอน

ความน่าจะเป็นโดยรวมนั้นขึ้นอยู่กับว่าผู้ใช้มีการผสมกันอย่างไรและยากต่อการตัดสิน แต่เราสามารถพูดได้อย่างแน่นอนว่า Windows เป็นสถานที่ที่ปลอดภัยสำหรับลูกแมว

การทดสอบการเชื่อฟังกฎ

ไม่มีสัตว์ใดที่จะได้รับอันตรายจากการผลิตคำตอบของคุณ

นี้ไม่ได้ฆ่าสัตว์, คำตอบคือได้รับการอนุมัติจากอเมริกันมีน้ำใจ

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

พิสูจน์ได้อย่างชัดเจนว่าcatไม่ใช่สัตว์ (ตราบfileใดที่ไม่รู้การสืบทอดประเภทไฟล์ที่ซ่อนอยู่)

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;
}

Haskell

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

ที่นี่เรานำไปใช้unsafePerformIOในการดำเนินการที่มีการสังเกตผลข้างเคียง นั่นเป็นพฤติกรรมที่ไม่ได้กำหนดเสมอไปอย่างน้อยก็ลำดับของเอฟเฟกต์ ดังนั้นโปรแกรมจะหยุดทำงานเป็นครั้งแรกในการพยายามที่จะประเมินผลundefined(อย่างหนึ่ง, แดกดัน, ไม่ใช่พฤติกรรมที่ไม่ได้กำหนด: มันจะต้องไม่ยอมให้คุณค่าที่จะทำให้โปรแกรมดำเนินการกับสิ่งอื่น), หรือในความเป็นจริง ผลข้างเคียง. ในกรณีที่มีโอกาสอยู่รอดเพียง 0.001%

ความน่าจะเป็นในการฆ่าแมว: 49.9995%

Thue

เนื่องจากคำถามทำให้ภาษาที่ไม่ได้มีพฤติกรรมที่ไม่ได้กำหนดตราบใดที่ผลคล้ายกันฉันเลือก Thue สำหรับการตัดสินใจในการเลือกกฎที่จะดำเนินการเมื่อมีมากกว่า 1 กฎที่สามารถใช้กับปัจจุบันได้ สถานะ.

โปรแกรมจะถูกป้อนเข้าสู่คอนโทรลเลอร์สำหรับเตาไมโครเวฟซึ่งภายในนั้นเป็นแมวของฉัน ประตูเตาอบไมโครเวฟปิดและเสริมด้วยซิป ผลลัพธ์ของโปรแกรมจะเป็นตัวตัดสินว่าเตาไมโครเวฟจะเริ่มแมวไมโครเวฟหรือไม่

• หากผลลัพธ์เป็น 0 เราจะเริ่มการทดลองเกี่ยวกับผลกระทบของการได้รับไมโครเวฟเป็นเวลานานต่อสัตว์เลี้ยงลูกด้วยนมที่มีชีวิต
• หากผลลัพธ์คือ 1 เราจะพอใจกับความจริงที่ว่าแมวเพิ่งสูญเสียหนึ่งใน 9 ชีวิตของมันและปล่อยมันออกไป

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

ความน่าจะเป็นที่จะฆ่าแมวนั้นขึ้นอยู่กับการใช้ล่าม แต่สมมติว่า 50% จากนั้นน่าจะเป็นที่แมวจะตายคือ0.5

ชวา

ตามสเป็ค 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 );
    }
}