Dado un mazo que consiste en N copias de cartas con valores enteros [ 1 , M ] para un total de N * M cartas, calcule la probabilidad de que una carta con el valor de 1 sea adyacente a una carta con el valor de 2 .
Su solución puede ser exacta o aproximada, y no necesita ser la misma para cada ejecución con las mismas entradas. La respuesta dada debe estar dentro de +/- 5% de la solución verdadera (salvo posibilidades realmente raras de que el RNG no esté a su favor). Su programa debe dar la respuesta en un tiempo razonable (digamos, menos de 10 minutos en cualquier hardware que tenga). Puede suponer que M y N son razonablemente pequeños y no se requiere verificación de errores.
El mazo no es cíclico, por lo que si la primera carta es un 1 y la última es un 2 , esto no cumple con los requisitos de adyacencia.
Como caso de prueba, para N = 4 y M = 13 (una baraja estándar de 52 cartas) la solución esperada es ~ 48.6%.
Aquí hay un ejemplo de implementación sin golf en Python + NumPy usando aleatorios aleatorios:
from __future__ import division
from numpy import *
def adjacent(N, M):
deck = array([i for i in range(1, M+1)]*N)
trials = 100000
count = 0
for i in range(trials):
random.shuffle(deck)
ores = (deck == 1)
tres = (deck == 2)
if(any(logical_and(ores[1:], tres[:-1])) or
any(logical_and(ores[:-1], tres[1:]))):
count += 1
return count/trials
La salida puede estar en cualquier forma que le resulte conveniente (valor de retorno de función, salida de terminal, archivo, etc.), y la entrada puede estar en cualquier forma que le parezca conveniente (parámetro de función, entrada de terminal, línea de comando arg, etc.)
Se aplican agujeros de bucle estándar.
Este es el código de golf, gana el código más corto (en bytes).
Tabla de clasificación
fuente
Respuestas:
Pyth,
2322 bytesEjecuta 10000 iteraciones. El número se puede cambiar sin costo de byte. La entrada está separada por una nueva línea. Toma alrededor de 9 segundos en mi computadora.
Demostración
fuente
MATL , 44
46bytesUtiliza la versión 3.1.0 del lenguaje, que es anterior a este desafío.
El cálculo se realiza con un bucle que dibuja 1000 realizaciones aleatorias. Tarda un par de segundos en ejecutarse. Se podría hacer más rápido de forma vectorizada. La entrada es de la forma
[N M]
.Versión anterior : genera un mazo de cartas al azar y lo verifica dos veces: primero en adelante y luego en retroceso.
Nueva versión : genera un mazo de cartas al azar y luego agrega una versión invertida con un
0
intermedio. De esa manera, la verificación se puede hacer solo una vez, en la dirección hacia adelante. Esto ahorra dos bytes.Ejemplo
Explicación
fuente
LabVIEW, 58 primitivas de LabVIEW
crea matrices de cartas y luego las baraja. Busque 1s y luego verifique las tarjetas adyacentes por 2s.
fuente
Pyth, 16 bytes
Demostración.
Esto sigue el
estrategia de programación. La suposición educada ganadora en este caso es
lo que más o menos dice que hay
N
posibilidades de caer en cubos, y la fracción de cubos válidos es2 / M
. Los cubos son ranuras ubicadas al lado de0
s, y las posibilidades son1
s.El error nunca parece superar el 3% (sorprendentemente), y parece converger al 0% a medida que los parámetros se hacen más grandes (como era de esperar).
La entrada está separada por una nueva línea.
Puede guardar un personaje si acepta el hecho claramente obvio de eso
False == 0
, y lo hace en suJE&>J1-1^-1c2JQ
lugar.fuente
MATL ,
4438 bytesEsto también usa MATL versión 3.1.0 , que es anterior a este desafío.
Nueva versión, gracias a Luis Mendo por guardar 4 bytes.
Versión anterior (44 bytes):
Explicación
Por ejemplo,
Nota (21/5/16): a partir de la versión 18.0.0 de MATL,
X+
se ha eliminado, peroY+
se puede utilizar en su lugar. Los cambios desde la versión 3.1.0 a MAT 18.0.0 media que esta respuesta se puede escribir en sólo 31 bytes,*xO1e4:"2:Gtb*Z@w\TT2&Y+1=ah]Ym
.fuente
[1 1]
enTTo
. Además, no necesitas la comaMathematica,
939291 bytesTodavía buscando una forma cerrada ...
fuente