Erstellen Sie ein Programm, das genau 50% der Zeit anhält . Sei originell. Die Frage mit der höchsten Abstimmung gewinnt. Mit genau meine ich, dass bei jedem Lauf eine 50% ige Chance besteht, dass es zum Stillstand kommt.

Perl

fork || do {sleep(1) while(1)}

Jedes Mal, wenn Sie dieses Programm ausführen, wird es angehalten und nicht angehalten.

JavaScript

Alternativen anhalten und nicht anhalten. (hält beim ersten Lauf an, bleibt beim zweiten nicht stehen, ...)

var h = localStorage.halt;
while (h) localStorage.halt = false;
localStorage.halt = true;

Python

import random
p=.3078458
while random.random()>=p:p/=2

Jedes Mal um die Schleife bricht sie mit exponentiell abnehmender Wahrscheinlichkeit. Die Chance, niemals zu brechen, ist das Produkt (1-p) (1-p / 2) (1-p / 4) ... das ~ 1/2 ist. (Obligatorischer Kommentar, dass Gleitkomma nicht genau ist.)

GolfScript

2rand{.}do

Ich weiß, dass dies keine Code-Golf- Herausforderung ist, aber ich habe es trotzdem gespielt. :) :)

Alternativ ist hier eine GolfScript-Implementierung der Lösung von Keith Randall :

2{2*.rand}do

Theoretisch hat dies eine Wahrscheinlichkeit von genau 1/4 + 1/8 + 1/16 + ... = 1/2 des Anhaltens. In der Praxis wird es jedoch immer irgendwann keinen Speicher mehr geben und anhalten, da der Nenner immer länger wird.

Rubin

n = 2*rand(1...49)+1; divisors = (1...100).select{|x|n % x == 0}.count until divisors == 2
print n

Es gibt genau 24 ungerade Primzahlen zwischen 0 und 100, wobei die größte 97 ist. Dieser Algorithmus wählt eine zufällige ungerade Zahl innerhalb des Bereichs und wiederholt sich, bis eine Primzahl gefunden wird:

Diese spezielle Implementierung weist zwei Fehler auf:

• Es wird ein exklusiver Bereich verwendet, was bedeutet, dass 99 niemals getestet wird, was bedeutet, dass es nur 48 mögliche Werte gibt n, von denen 24 Primzahlen sind.
• Während nbei jeder Iteration neu gezeichnet werden sollte, wird nur der Primalitätstest in der Schleife ausgeführt. Wenn es zuerst nicht gelingt, wird es erneut versucht - aber mit der gleichen Nummer.

Ich wollte dieses Golf spielen:

Befunge - 5 Zeichen

?><
@

(Ich bin nicht sicher, ob dies tatsächlich funktioniert, da ich keinen befunge Compiler bei mir habe)

BASH

#!/bin/bash
set -e
sed -i 's/true\;/false\;/' $0
while false; do echo -n ''; done;
sed -i 's/false\;/true\;/' $0

Nur ein lustiges selbstmodifizierendes Skript.

Hinweis: Die leere Zeichenfolge in Anführungszeichen dient echo -n ''nur der Übersichtlichkeit. Sie können ohne Funktionsverlust entfernt werden.

Geometry Dash 2.2 Editor Glitch - 2 Objekte

Erläuterung:

Der zufällige Auslöser schaltet zufällig die Gruppen-ID 1 oder 2 mit einer 50% igen Chance um (deaktiviert sie).

Das lila Pad befindet sich im umgekehrten Modus (dh wenn der Würfel ihn berührt, bewegt sich der Würfel rückwärts, was für immer und ewig nach links geht.).

Da das lila Pad die Gruppen-ID 2 hat, besteht eine 50% ige Chance, dass es deaktiviert wird, was bedeutet, dass der Würfel es bis zum Ende des Levels passieren kann, was zum Stillstand kommt.

So reproduzieren Sie dies:

Das lila Pad befindet sich im umgekehrten Modus und hat die Gruppen-ID 1.

Innerhalb des zufälligen Auslösers.

C.

#include <unistd.h>
main() { while (getpid()&2); }

Etwas verschleierte Lösung:

Haskell

import Control.Monad
import Control.Monad.Random         -- package MonadRandom
import Control.Monad.Trans.Maybe
import Data.Numbers.Primes          -- package primes

-- | Continue the computation with a given probability.
contWithProb :: (MonadRandom m, MonadPlus m) => Double -> m ()
contWithProb x = getRandomR (0, 1) >>= guard . (<= x)

loop :: MonadRandom m => MaybeT m ()
loop = contWithProb (pi^2/12) >> mapM_ (contWithProb . f) primes
  where
    f p = 1 - (fromIntegral p)^^(-2)

main = evalRandIO . runMaybeT $ loop

Python

Die gleiche Lösung in Python ausgedrückt:

import itertools as it
import random as rnd
from math import pi

# An infinite prime number generator
# Copied from http://stackoverflow.com/a/3796442/1333025
def primes():
    D = {  }
    yield 2
    for q in it.islice(it.count(3), 0, None, 2):
        p = D.pop(q, None)
        if p is None:
            D[q*q] = q
            yield q
        else:
            # old code here:
            # x = p + q
            # while x in D or not (x&1):
            #     x += p
            # changed into:
            x = q + 2*p
            while x in D:
                x += 2*p
            D[x] = p

def contWithProb(p):
    if rnd.random() >= p:
        raise Exception()

if __name__ == "__main__":
    rnd.seed()
    contWithProb(pi**2 / 12)
    for p in primes():
        contWithProb(1 - p**(-2))

Erläuterung

Diese Lösung nutzt die Tatsache, dass das unendliche Produkt Π (1-p ^ (- 2)) gegen 6 / π ^ 2 konvergiert . Dies liegt daran, dass ζ (2) = Π (1 / (1-p ^ (- 2))) gegen π ^ 2/6 konvergiert .

INTERCAL , 59 Bytes

DO %50 (1) NEXT
DO COME FROM COMING FROM
(1) PLEASE GIVE UP

Probieren Sie es online aus!

COME FROM COMING FROM macht eine Endlosschleife, aber es besteht eine 50% ige Chance, zum Ende des Programms zu springen.

TI-Basic

:Lbl 1:If round(rand):Pause:Goto 1

C.

int main() {
    char i;
    while(i&1);
}

Python, 48

import random
a=random.randrange(2)
while a:pass

Perl

BEGIN {
    # Do the following block 50% of time.
    if (int rand 2) {
        # Create a function that doubles values.
        *double = sub {
            2 * shift;
        };
    }
}
double / 3 while 1; # Calculates double divided using /

Kein Code Golf, also könnte ich unlesbaren Code vermeiden (weil das, was er tut, wichtiger ist). Während der Kompilierungsphase wird zufällig eine Funktion deklariert. Wenn es deklariert wird, doublewird ein regulärer Ausdruck als Argument abgerufen. Wenn es nicht deklariert wird, doubleist es ein Barwort, und Perl teilt es 3endlos durch. Dies missbraucht Perls Bareword-Analyse, um Parser dazu zu bringen, denselben Code auf zwei verschiedene Arten zu analysieren.

<> <, 5 Bytes und ein wunderschönes 2x2 Quadrat

x;
><

xsendet den Befehlszeiger in eine zufällige Richtung; Wenn es nach links oder rechts sendet, wird die IP getroffen; und beenden. Wenn es nach oben oder unten geht, bleibt die IP in der Endlosschleife stecken ><und wird zwischen den beiden hin und her gesendet.

Java

import java.io.*;

public class HaltNoHalt {
    public static void main(String[] args) throws Exception {
        RandomAccessFile f = new RandomAccessFile("HaltNoHalt.java", "rw");
        f.seek(372);
        int b = f.read();
        f.seek(372);
        f.write(b ^ 1);
        Runtime.getRuntime().exec("javac HaltNoHalt.java");

        while ((args.length & 1) == 1);
    }
}

Diese Selbst ändert den Code zu wechseln die == 1zu == 0und zurück, es ist Lauf jedes Mal. Speichern Sie den Code nur mit Zeilenumbrüchen, da sonst der Versatz falsch ist.

Dies args.lengthdient nur dazu, Compiler-Optimierungen zu verhindern.

Genau 50% der Zeit?

OBJ-C

- (void)applicationDidFinishLaunching:(NSNotification*)aNotification {
    BOOL haltedLastRun = [(NSNumber*)[[NSUserDefaults standardUserDefaults] objectForKey:@"halted"] boolValue];
    if (!haltedLastRun) {
        [[NSUserDefaults standardUserDefaults] setObject:[NSNumber numberWithBool:YES] forKey:@"halted"];
        [[NSApplication sharedApplication] terminate:nil];
    }
}

Haskell

Läuft in zwei Intervallen mit einer Länge von jeweils 1 Sekunde (ausgewählt, da 1 Sekunde die SI-Einheit für die Zeit ist). Hält innerhalb von 50% der Intervalle an. 50% der laufenden Sekunden werden nicht angehalten, die anderen 50%. Funktioniert nur in GHC.

import Control.Concurrent (threadDelay)
main = threadDelay 1990000

Shell-Skript

Dieses Skript blockiert .md5sum-Dateien in den aktuellen und untergeordneten Verzeichnissen.

#!/bin/sh
echo *.md5sum|xargs -n1|head -n1|xargs test -e && exec rm *.md5sum
while ! find . -name '*.md5sum' -print0 |xargs -0r grep 00000000000000
do {
    find . -type f -print|sed -e 's!^\(.*\)$!md5sum "\1" > "\1".md5sum!e'
}
done

GTB

[@r;p;]

Ich weiß, dass dies kein Code-Golf ist, aber ich habe mich trotzdem dazu entschlossen, Golf zu spielen.

C ++

#include <fstream>
main () {
    int c;
    std::fstream fs;
    fs.open ("myfile.txt", std::fstream::in);
    fs>>c;
    fs.close ();
    fs.open ("myfile.txt", std::fstream::out);
    fs<<c+1;
    fs.close ();
    while (c%2);
    return 0;
}

Jeder Lauf wird angehalten, wenn der vorherige Lauf dies nicht getan hat.

Windows-Befehlsskript

Dieses Skript hängt Code an sich selbst an, der letztendlich bei jedem Lauf 'x' wechselt.

call :last
if %x%==1 (
    echo>>%0 set x=0
    exit /b 0
) else (
    echo>>%0 set x=1
)
:nohalt
goto :nohalt
:last
set x=1
[newline here]

Java

import java.util.Random;

class Halt50 {
    public static void main(String[] args){
        if(new Random().nextInt(2)==0)for(;;);
    }
}

Math ++

_($rand*2)+2>$
2>$
1

Python 2 , 54 Bytes

import time;H=[time.time()%2]
for h in H:H+=[h]*int(h)

Probieren Sie es online aus!

Das Halteverhalten ist abhängig von der aktuellen Zeit.