Cree un programa que se detenga exactamente el 50% del tiempo. Ser original. La pregunta más votada gana. Con exactamente quiero decir que en cada carrera hay un 50% de posibilidades de que se detenga.

Perl

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

Cada vez que ejecuta este programa, se detiene y no se detiene.

JavaScript

Alternativas deteniéndose y no deteniéndose. (se detiene en la primera carrera, no se detiene en la segunda, ...)

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

Pitón

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

Cada vez alrededor del ciclo se rompe con una probabilidad exponencialmente decreciente. La posibilidad de que nunca se rompa es el producto (1-p) (1-p / 2) (1-p / 4) ... que es ~ 1/2. (El comentario obligatorio sobre el punto flotante no es exacto).

GolfScript

2rand{.}do

Sé que esto no es un desafío de código de golf , pero lo jugué de todos modos. :)

Alternativamente, aquí hay una implementación de GolfScript de la solución de Keith Randall :

2{2*.rand}do

En teoría, esto tendrá exactamente 1/4 + 1/8 + 1/16 + ... = 1/2 probabilidad de detenerse. En la práctica, sin embargo, siempre se quedará sin memoria y se detendrá, porque el denominador se vuelve cada vez más largo.

Rubí

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

Hay exactamente 24 números primos impares entre 0..100, el más grande es 97. Este algoritmo elige un número impar aleatorio dentro del rango y se repite hasta que encuentra un número primo:

Esta implementación particular tiene dos errores:

• se utiliza un rango exclusivo, lo que significa que 99 nunca se prueba, lo que significa que solo hay 48 valores posibles n, de los cuales 24 son primos.
• aunque nestaba destinado a ser redibujado en cada iteración, solo la prueba de primalidad se ejecuta en el bucle. Si al principio no tiene éxito, lo intentará nuevamente, pero con el mismo número.

Tenía ganas de jugar al golf:

Befunge - 5 caracteres

?><
@

(No estoy seguro de si esto realmente funciona ya que no tengo un compilador befunge)

GOLPETAZO

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

Solo un divertido script auto modificable.

Nota: las cadenas entre comillas vacías echo -n ''son solo para mayor claridad. Se pueden eliminar sin pérdida de funcionalidad.

Geometry Dash 2.2 Glitch Editor - 2 objetos

Explicación:

El disparador aleatorio alterna aleatoriamente (deshabilita) la ID de grupo 1 o 2 con una probabilidad del 50%.

La almohadilla púrpura está en modo inverso (lo que significa que si el cubo lo toca, el cubo se mueve hacia atrás, lo que va hacia la izquierda para siempre).

Dado que la almohadilla púrpura tiene ID de grupo 2, tiene un 50% de posibilidades de desactivarse, lo que significa que el cubo puede pasar a través de ella hasta el final del nivel, lo que se detendrá.

Cómo reproducir esto:

La almohadilla púrpura está en modo inverso y tiene ID de grupo 1.

Dentro del disparador aleatorio.

C

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

Solución algo ofuscada:

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

Pitón

La misma solución expresada en Python:

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

Explicación

Esta solución hace uso del hecho de que el producto infinito Π (1-p ^ (- 2)) converge a 6 / π ^ 2 . Esto se debe a que ζ (2) = Π (1 / (1-p ^ (- 2))) converge a π ^ 2/6 .

INTERCAL , 59 bytes

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

Pruébalo en línea!

COME FROM COMING FROM realiza un bucle sin fin, pero hay un 50% de posibilidades de saltar al final del programa.

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 /

No codifico el golf, por lo que podría evitar el código ilegible (porque lo que hace es más importante). Declara aleatoriamente una función durante la fase de compilación. Si se declara, doubleobtiene expresión regular como argumento. Si no se declara, doublees una palabra simple, y Perl lo divide 3sin cesar. Esto abusa del análisis de palabras simples de Perl, para que el analizador analice el mismo código de dos maneras diferentes.

<> <, 5 bytes y un hermoso cuadrado de 2x2

x;
><

xenvía el puntero de instrucciones en una dirección aleatoria; Si envía izquierda o derecha, la IP golpeará; y terminar. Si sube o baja, la IP se atascará en el ><bucle infinito y se enviará de ida y vuelta entre los dos.

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

Esto auto modifica el código para alternar el == 1 a== 0 ida y vuelta, cada vez que es dirigido. Guarde el código solo con líneas nuevas o el desplazamiento será incorrecto.

Esto args.lengthes solo para evitar optimizaciones del compilador.

Exactamente 50% del tiempo?

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

Se ejecuta durante dos intervalos, cada uno de 1 segundo de duración (elegido porque 1 segundo es la unidad SI por tiempo). Se detiene dentro del 50% de los intervalos. Entonces, el 50% de los segundos de funcionamiento no se detendrá, el otro 50% lo hará. Funciona solo en GHC.

import Control.Concurrent (threadDelay)
main = threadDelay 1990000

Shell Script

este script bloqueará los archivos .md5sum en los directorios actuales y secundarios.

#!/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;]

Sé que esto no es golf de código, pero decidí jugarlo de todos modos.

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

Cada ejecución se detendrá si la ejecución anterior no lo hizo.

Script de comandos de Windows

Este script agregará código a sí mismo, que en última instancia alterna 'x' en cada ejecución.

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)

Pruébalo en línea!

El comportamiento de detención depende del tiempo actual.