Undefiniertes Verhalten hat meine Katze getötet

Es ist bekannt , dass nicht definiertes Verhalten Ihre Katze töten ^[Bearbeiten] .
Aber kann es?

Deine Aufgabe

1. Schreiben Sie ein Programm, das undefiniertes Verhalten aufruft.
2. Beschreiben Sie ein Szenario, das mit der Ausführung des oben genannten Programms beginnt und dazu führt, dass eine Felis-Katze aufgrund der oben genannten UB ihr Leben in Ihrem Besitz beendet.
3. Schätzen Sie die Wahrscheinlichkeit für jede Phase im Szenario.
4. Berechnen Sie die Gesamtwahrscheinlichkeit, mit der ein einzelner Programmlauf Ihre Katze töten würde.

Regeln

1. Dies ist ein Beliebtheitswettbewerb , also sei kreativ, wenn du kannst.
2. Dies ist eine programmierbezogene Herausforderung, daher sollte sich die Ereigniskette hauptsächlich im Computer und nicht in der realen Welt befinden (natürlich, wenn Sie die reale Welt erreichen müssen, wenn sich Ihre Katze dort befindet).
3. Wenn Sie eine Sprache auswählen, die kein undefiniertes Verhalten aufweist, verwenden Sie etwas Ähnliches.
4. Bei der Erstellung Ihrer Antwort dürfen keine Tiere verletzt werden.

Wertung

Stimmenanzahl plus die Gesamtwahrscheinlichkeit des Szenarios (die 1 nicht überschreiten darf).

Beispiel in C:

main(){printf();}

Szenario:

1. printfmit Müll aus dem Stapel aufgerufen - undefiniertes Verhalten. Wahrscheinlichkeit: 100%.
2. Der erste Parameter ist zufällig die Zeichenfolge Your cat is ugly!. Wahrscheinlichkeit: (1/256) ¹⁷ = (1,148 × 10 ^–37 )%.
3. Wenn Sie die Nachricht sehen, nehmen Sie Ihre Waffe und schießen auf Ihre Katze. Wahrscheinlichkeit: 3%.
4. Die Katze stirbt. Wahrscheinlichkeit: 93%.

Gesamtwahrscheinlichkeit: (3.202 * 10 ^-39 )%.

C

Die meisten Antworten auf diese Frage haben die Frage dahingehend falsch interpretiert, dass der catProzess auf einem UNIX-System abgebrochen wurde. Hier ist ein Programm, das den Tod einer biologischen Lebensform der Art Felis Cattus nach der Fragestellung verursachen kann.

Dieses Beispiel wird unter Windows ausgeführt, kann jedoch problemlos auf die meisten UNIX-Betriebssysteme portiert werden, indem iexplore -kder Befehl zum Starten eines installierten Webbrowsers verwendet wird.

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

Dieses Programm gibt vor, dem Benutzer Ratschläge zur Katzennahrung zu geben.

Der Internet Explorer wird gestartet und der Benutzer wird zum Austausch von Haustieren weitergeleitet. Dort werden viele hilfreiche Fragen zum Füttern von Katzen aufgelistet . Es besteht jedoch eine geringe Wahrscheinlichkeit (1/256), dass der Benutzer zum Stapelaustausch geschickt wird, statt Tipps zur Zubereitung von Schoko-Gerichten aufzulisten, die für Katzen hochgiftig sind . Erschwerend kommt hinzu, dass der Internet Explorer im Kiosk-Modus (Vollbildmodus) gestartet wird, der die Adressleiste verbirgt und für einen technisch nicht versierten Benutzer nur schwer zu umgehen ist.

Dieser clevere Trick wird den Benutzer dazu bringen, seine Katzenschokolade zu füttern, weil er glaubt, dass dies eine geeignete Diät ist, und sie veranlassen, sie versehentlich zu töten.

Bash

Nach diesem , INT_MIN % -1kann oder auch nicht undefiniert sein (was ???) , und könnte so verursachen Probleme für jede in C / C ++ implementiert Sprache.

#!/bin/bash

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

Der catwird vorzeitig beendet, wenn der übergeordnete bashProzess abstürzt, was passieren kann oder nicht.

Auf meiner VM bekomme ich folgende Ausgabe:

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

(Ich verstehe die Wertung für diese Frage nicht wirklich, aber hier geht es trotzdem.)

Berechnen $((2**63%-1)). Absturz tritt immer bei Bash 4.2.25 auf, scheint aber bei einigen 3.x-Versionen nur zu hängen. Mehr Unsicherheit. Ich könnte Ihnen die genaue Wahrscheinlichkeit sagen, aber aufgrund des Heisenburgschen Unsicherheitsprinzips würde ich dann ein Schwarzes Loch stürzen. Oder so. Ich denke, wir können mit Sicherheit sagen, dass die Wahrscheinlichkeit bei ungefähr 42% liegt.

C (Sequenzpunkt)

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

Ausführung (oder nicht):

$ 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

Szenario und Wahrscheinlichkeit

Angenommen, fünf Prozent der Benutzer, die dieses Programm ausführen, verwenden clang zum Kompilieren von C-Code (gegenüber 90 Prozent mit gcc und fünf Prozent mit anderen C-Compilern):

Wahrscheinlichkeit zu bekommen "Der Katze geht es gut." = 0,050
 Wahrscheinlichkeit, dass "Dringender Hinweis: Ihre Katze hat Tollwut." = 0,950

 Wahrscheinlichkeit, auf "Ihre Katze hat Tollwut" zu reagieren, indem Sie sie auf den Tisch legen = .040
 Wahrscheinlichkeit des Ignorierens des Hinweises = .900
 Wahrscheinlichkeit, dass die Katze zur Behandlung zum Tierarzt gebracht wird = .060

 Gesamtwahrscheinlichkeit des Katzenlebens: .05 + .95 * (.90 + .06) = .962
 Gesamtwahrscheinlichkeit des Katzensterbens: .95 * .04 = .038
 Kontrolle: Gesamtwahrscheinlichkeit des Lebens oder Sterbens der Katze: = 1.000

Erläuterung:

k = i + (++ i) greift auf "i" zwischen Sequenzpunkten zu und ändert es. Die Wahrscheinlichkeit ist vom Programm nicht bestimmbar; Dies hängt von der Auswahl des Compilers ab, der vom Benutzer vorgenommen wird. "Undefiniert" bedeutet nicht unbedingt "zufällig".

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

C

Hintergrundgeschichte

Meine Frau hat eine Katze von der Familie geerbt. ^† Ich bin leider sehr allergisch gegen Tiere. Die Katze war weit hinter ihrer Blüte und hätte eingeschläfert werden müssen, bevor wir sie bekamen, aber sie konnte sich aufgrund ihres sentimentalen Werts nicht dazu bringen, sie loszuwerden. Ich habe einen Plan entwickelt, um mein Leiden zu beenden .

Wir machten einen längeren Urlaub, aber sie wollte nicht in der Tierarztpraxis an Bord gehen. Sie war besorgt darüber, dass sie krank wurde oder misshandelt wurde. Ich habe eine automatische Katzenfütterung entwickelt, damit wir sie zu Hause lassen können. Ich habe die Firmware des Mikrocontrollers in C geschrieben. Die Datei mainsah ähnlich aus wie der folgende Code.

Meine Frau ist jedoch auch Programmiererin und kannte meine Gefühle gegenüber der Katze. Deshalb bestand sie auf einer Codeüberprüfung, bevor sie zustimmte, sie unbeaufsichtigt zu Hause zu lassen. Sie hatte mehrere Bedenken, darunter:

• main hat keine standardkonforme Signatur (für eine gehostete Implementierung)
• main gibt keinen Wert zurück
• tempTmwird nicht initialisiert verwendet, da mallocstatt aufgerufen wurdecalloc
• Der Rückgabewert von mallocsollte nicht umgewandelt werden
• Die Zeit des Mikrocontrollers ist möglicherweise ungenau oder überschlägt sich (ähnlich wie bei den Problemen mit der Y2K- oder Unix-Zeit 2038).
• Die elapsedTimeVariable verfügt möglicherweise nicht über einen ausreichenden Bereich

Es hat viel Überzeugungsarbeit gekostet, aber sie stimmte schließlich zu, dass dies aus verschiedenen Gründen keine Probleme darstellte (es hat nicht geschadet, dass wir bereits zu spät zu unserem Flug kamen). Da keine Zeit für Live-Tests war, genehmigte sie den Code und wir fuhren in den Urlaub. Als wir ein paar Wochen später zurückkehrten, war das Elend meiner Katze vorbei (obwohl ich jetzt viel mehr habe).

^{† Völlig fiktives Szenario, keine Sorge.}

Code

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

Undefiniertes Verhalten:

Für diejenigen, die sich nicht die Mühe machen wollen, die UB selbst zu finden:

In diesem Code ist definitiv ein lokalspezifisches, nicht angegebenes und implementierungsspezifisches Verhalten enthalten, das jedoch ordnungsgemäß funktionieren sollte. Das Problem liegt in den folgenden Codezeilen:

struct tm * tempTm //... //... memcpy(&tempTm, localtime(&nowTime), sizeof(struct tm));
memcpyÜberschreibt den tempTMZeiger anstelle des Objekts, auf das er zeigt, und zerschmettert den Stapel. Dies überschreibt, neben anderen Dingen, elapsedTimeund loopIterationsSinceFeed. Hier ist ein Beispiellauf, in dem ich die Werte ausgedruckt habe:

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

Wahrscheinlichkeit, die Katze zu töten:

• In Anbetracht der eingeschränkten Ausführungsumgebung und der Build-Kette tritt das undefinierte Verhalten immer auf.
• In ähnlicher Weise verhindert das undefinierte Verhalten immer, dass die Katzenfütterung wie beabsichtigt arbeitet (oder vielmehr, dass sie wie beabsichtigt "arbeitet").
• Wenn der Futterautomat nicht funktioniert, ist es sehr wahrscheinlich, dass die Katze stirbt. Dies ist keine Katze, die sich selbst verteidigen kann, und ich habe den Nachbarn nicht gebeten, nachzusehen.

Ich schätze, dass die Katze mit einer Wahrscheinlichkeit von 0,995 stirbt .

Bash

Klassische Version

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

Hat den Vorteil, alle Katzen in seiner Reichweite zu töten .

Beachten Sie, dass der Prozess sofort gestoppt wird. Die einzige Möglichkeit, ihn mit einem einzigen Aufruf von pkill zu beenden, besteht darin, SIGKILL (9) zu senden.

Deshalb:

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

Quantenversion

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.

Wahrscheinlichkeit, die Katze während des Versuchs zu töten: 50%

C

Beachten Sie, dass dies nur unter Linux funktioniert.

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. Schreibe zufällige Daten in eine Datei und rufe sie auf (100%)
2. Zufällige Daten sind zufällig der Quellcode von skynet (1x10 ^ -99999999999999999999999999999999999999999999999999999999999999999, ca.)
3. Katze stirbt am Tag des Jüngsten Gerichts (99,999%)

Gesamtwahrscheinlichkeit: 1x10 ^ -99999999999999999999999999999999999999999999999999999999999, Ca.

C ++

Ihre Katze ist tot und lebendig, bis Sie neugierig sind. Dann stellen Sie fest, dass Ihre Katze mit einer Wahrscheinlichkeit von 0,5 tot ist.

#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

Läuft unter 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;
}

Wahrscheinlichkeit der Tötung der Katze: (Die 1/256 sleep(1)0 zurück, so wird es , wenn getötet werden x. Null ist)

Als Bonus werden alle Katzen getötet, die derzeit auf Ihrem System laufen.

Wenn Sie Katzen so sehr hassen, präsentiere ich Ihnen:

Der Katzenhundertfüßer (Bash)

echo "Hello World"|cat|cat|cat

Basierend auf der Tatsache, dass in The Human Centipede (First Sequence) alle drei Hunde des Hundezentipeders starben und zwei von drei Menschen des menschlichen Hundezentipeders starben, schätze ich, dass die Wahrscheinlichkeit, eine Katze zu töten, 5/6 beträgt.

JavaScript

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

Ausführung:

• Chrome: Ergebnisse in"Cat is fine"
• Firefox: Ergebnisse in"Cat is dead"

Erläuterung:

15.5.4.9 String.prototype.localeCompare (that)

Die beiden Strings werden in einem Vergleich die Implementierung definiert fashion

Mit Glenn Randers-Pehrson lässt sich die Wahrscheinlichkeit nicht durch das Programm bestimmen. Dies hängt von der Auswahl des Browsers ab, der vom Benutzer vorgenommen wird.

int foo() {}

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

Das Lesen eines Funktionswerts, der einen Wert zurückgeben soll, führt zu undefiniertem Verhalten. Nun ist es offensichtlich, ^[Bearbeiten] , dass „Jedes Mal , wenn Sie nicht definiertes Verhalten erreichen, Gott ein Kätzchen tötet.“ Daraus schließen wir:

• Wahrscheinlichkeit, dass Sie undefiniertes Verhalten erreichen - 100%
• Wahrscheinlich ist es deine Miezekatze, die Gott getötet hat - 1/200 000 000 sehen warum
• Die Wahrscheinlichkeit ist also 0,0000005%.

Kann einfach durch eine Schleife erweitert werden, um alle Katzen auf der Welt auszurotten.

Java (Speicherbereinigung)

Obwohl Code System.gc () aufrufen kann, wird nicht sichergestellt, dass der Garbage Collector alle nicht verwendeten Objekte sammelt. Daher ist es für den folgenden Code nicht vorhersehbar, ob die Katze getötet wird oder nicht.

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

Die Wahrscheinlichkeit kann nicht berechnet werden.

Beachten Sie, dass es immer noch eine Chance gibt, dass die Katze "wiederbelebt" wird, wenn im GC-Thread nach sysout und vor System.exit (0) ein Kontextwechsel stattfindet. Ich habe es jedoch vorgezogen, ihn nicht zu behandeln, um das Konzept zu vereinfachen.

Hat jemand daran gedacht, wirklich (a) zu töten cat?

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

Probabilitiy von catSterben

Für die Wahrscheinlichkeit ... Ich denke, wir müssen einige Fälle unterscheiden:

1. Windows-Benutzer : Kann es wahrscheinlich nicht ausführen. Sterbewahrscheinlichkeit cats ist sehr gering, kann mit Sicherheit als Null angenommen werden. Wenn er Cygwin installiert hat, zählt er als Unix-Benutzer.
2. Unix-Benutzer, der ohne Root-Rechte läuft : Das Beenden catschlägt fehl.
3. Unix-Benutzer, der mit Root-Rechten läuft : Während jeder Aufruf nur cats mit einer Chance von 1/6 beendet, wird er ihn höchstwahrscheinlich wiederholen, bis etwas Unerwartetes eintritt. Ohne Verlust der Allgemeinheit gehe ich davon aus, catdass definitiv sterben wird.

Die Gesamtwahrscheinlichkeit hängt davon ab, wie die Benutzer gemischt sind, und ist schwer zu bestimmen. Aber wir können mit Sicherheit sagen: Windows ist ein sicherer Ort für Kätzchen.

Prüfen, ob die Regeln eingehalten werden

Bei der Erstellung Ihrer Antwort dürfen keine Tiere verletzt werden.

Dies hat keine Tiere getötet, die Antwort wird von der American Humane Association genehmigt .

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

beweist eindeutig, dass cates sich nicht um ein Tier handelt (solange filekeine Art von Vererbung von versteckten Dateitypen bekannt ist).

C

Wenn der Name Ihrer Katze zu lang ist, stirbt sie. getsverursacht Katzentod und andere Probleme.

#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)

Hier setzen wir unsafePerformIOauf eine Aktion , die beobachtbare Nebenwirkungen hat . Das ist immer undefiniertes Verhalten, zumindest die Reihenfolge der Effekte. Entweder stürzt das Programm beim Versuch einer Evaluierung zuerst ab undefined(ironischerweise handelt es sich nicht um ein undefiniertes Verhalten: Es darf niemals einen Wert ergeben, der es dem Programm ermöglicht, mit etwas anderem weiterzumachen), oder es wird tatsächlich die ernsthafte Internationale treffen Nebenwirkungen. In diesem Fall beträgt die Überlebenschance nur 0,001% .

Wahrscheinlichkeit, die Katze zu töten: 49,9995%.

Thue

Da die Frage eine Sprache zulässt, die kein undefiniertes Verhalten aufweist, solange der Effekt ähnlich ist, wähle ich Thue aufgrund ihres Nichtdeterminismus bei der Auswahl der auszuführenden Regel, wenn mehr als eine Regel für die aktuelle Regel angewendet werden kann Zustand.

Das Programm wird in die Steuerung für einen Mikrowellenherd eingespeist, in dem sich meine Katze befindet. Die Tür zum Mikrowellenherd ist geschlossen und mit einem Kabelbinder verstärkt. Die Ausgabe des Programms entscheidet, ob der Mikrowellenherd die Katze zum Mikrowellenherd macht oder nicht.

• Wenn die Ausgabe 0 ist, werden wir das Experiment über die Auswirkung der Langzeitbelichtung von Mikrowellen auf lebende Säugetiere starten (was derzeit nicht ausreichend erforscht ist).
• Wenn die Ausgabe 1 ist, sind wir nur mit der Tatsache zufrieden, dass die Katze gerade eines ihrer 9 Leben verloren hat und lassen es raus.

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

Die Wahrscheinlichkeit, die Katze zu töten, hängt von der Implementierung des Dolmetschers ab. Nehmen wir an, es sind 50%. Dann beträgt die Wahrscheinlichkeit, dass die Katze stirbt, 0,5 .

Java

Laut Spezifikation java.util.Date wird undefiniertes Verhalten haben. Also versuch dein Glück:

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