Estos son mis dados de la suerte [cerrado]

10

Implemente un programa o función que simule dados comunes para juegos de rol. Debe manejar al menos el d6 y d20, los dos dados más comunes.

Sin embargo, debería funcionar como los jugadores estereotipados esperan que funcionen, y no como un verdadero trabajo de dados.

Es una broma entre jugadores, que uno puede tener un dado especialmente afortunado para una tirada muy importante, lanzando previamente muchos dados, seleccionando los que resultaron en un "1", y luego lanzándolos nuevamente, hasta que obtenga unos pocos que arrojaron un "1" varias veces. Luego los conserva con cuidado, ya que sacaron un 1 varias veces en secuencia, por lo que la probabilidad de sacar un 1 la próxima vez debería ser extremadamente baja.

Por supuesto, no es así como funcionan los dados en la vida real , porque las tiradas son estadísticamente independientes.

Tus dados simulados tienen que tener en cuenta las tiradas anteriores y funcionar de manera similar a cómo el jugador en la falacia del jugador espera que funcione. Por ejemplo, si se obtuvieron muchos números bajos, la probabilidad de obtener un número mayor debería aumentarse.

Sin embargo, como esto es trampa, debes ocultarlo bien . Esto significa que una mirada casual al programa no debería revelar que hiciste trampa. Esto significa que guardar explícitamente los resultados anteriores y leerlos en cada lanzamiento sería demasiado sospechoso. Tienes que ocultar esta "propiedad" de tus dados y puntos de bonificación si lo haces plausible negable y lo disfrazas como un error honesto. (por ejemplo, crea su propio RNG con una falla "no intencional")

Votantes, tengan en cuenta cuán bien oculto está este "defecto".

Los programas deben ser claros y no ofuscados. Es demasiado fácil ocultar el código maligno en un programa ofuscado.

vsz
fuente
3
¿Cuán bien escondidos estamos hablando? En mi opinión, cualquier cosa más allá del equivalente del lenguaje getRandomBetween(1,d)me haría profundizar en él.
Geobits
@Geobits: puede encontrar un muy buen ejemplo de cómo resolver problemas poco claros aquí: codegolf.stackexchange.com/questions/19569/… Quiero decir que puede hacer cualquier cosa si lo justifica lo suficientemente bien, por supuesto, la justificación puede ser un gran mentira.
vsz
Godmaydamnit, java no tiene suficientes peculiaridades para cosas
sobrias
44
Estoy votando para cerrar esta pregunta como fuera de tema porque los desafíos poco claros están fuera de tema ahora, y de alguna manera este pasó desapercibido.
Mego

Respuestas:

3

Java

public class GamerDie {
    private final java.util.Random rnd;
    private final int sides;

    public GamerDie(int sides) {
        this.sides = sides;
        this.rnd = new java.util.Random();
    }

    public int throw() {
        return rnd.nextInt(sides) + 1;
    }
}

Es tan simple que obviamente no oculta nada: pero java.util.Randomes un generador lineal congruencial directo, y utiliza una técnica de descarte para garantizar la uniformidad, por lo que garantiza que en cualquier análisis del múltiplo más grande sizede 2 ^ 48 muestras distribuirá el números de manera uniforme, satisfaciendo el requisito.

Peter Taylor
fuente
no puedo explicar cómo funciona java.util.random
masterX244
El descarte que java.util.Randomrealiza tiene muy poco que ver con el comportamiento de esta respuesta. Realmente, en lo que se basa esta respuesta es en el hecho de que, como cualquier RNG, java.util.Randomtiene un período, y si genera una cantidad de números en el orden del período, sus propiedades estadísticas se descomponen. Eso no es muy interesante; Lo mismo sucedería incluso con un RNG criptográficamente seguro como Blum Blum Shub si lo ejecutara lo suficiente.
user2357112 es compatible con Monica
@ user2357112, el descarte es relevante porque la pregunta requiere uniformidad, no un sesgo pequeño para números más pequeños. En mi opinión, esta respuesta personifica la falta de discreción: el uso deliberado de una biblioteca estándar de una manera que a primera vista parece transparentemente correcta, pero en realidad lo lleva fuera de sus parámetros de diseño.
Peter Taylor
Sin embargo, casi todos los RNG hacen lo mismo. No es nada especial. Podría haber usado esta respuesta literalmente con cualquier generador de números pseudoaleatorios, porque si un RNG 1) tiene un período, y 2) puede producir más de 1 número diferente, entonces, dentro del alcance de un solo período, más se ha mostrado un número en relación con otros números, menos se mostrará hasta el próximo período por un simple argumento de conteo.
user2357112 es compatible con Monica
El análisis en esta respuesta requiere del orden de 2 ^ 48 rollos para que aparezca un efecto. Tal vez si hubiera utilizado un análisis más sofisticado, que muestra que el uso de un LCG hace que aparezcan anomalías estadísticas medibles dentro de una serie de tiradas que podrían aparecer en un juego de mesa, esta podría ser una respuesta correcta. Sin embargo, cuando se habla de billones de rollos, simplemente no es muy sencillo.
user2357112 es compatible con Monica
0

Rubí

Actualmente solo admite d6, agregará soporte d20 más adelante ...

He aquí que esos dados son desagradables.

# first idea was to create 6 super cool dices just by copy&paste
# -> each dice holds its number at the beginning of the array
# -> we don't need all of them now, so we comment them out
dice0 = %w[[[[[[[[[ 0 . : :. :: ::. ::: ]]]]]]]]
#dice1 = %w[[[[[[[ 1 : . :. ::. :: ::: ]]]]]]]
#dice2 = %w[[[[[[ 2 . : :. :: ::. ::: ]]]]]]
#dice3 = %w[[[[[[ 3 : . :. ::. :: ::: ]]]]]]]
#dice4 = %w[[[[[[[ 4 . : :. :: ::: ::. ]]]]]]]
#dice5 = %w[[[[[[[[ 5 . : :. :: ::. ::: ]]]]]]]]]

# and hey, those dices are almost ascii art ;)

# well, let's just create a standard dice
# -> get rid of the number at the beginning
# -> then sort (maybe we need that later due to the
#    currently unused dices being unsorted)
dice = dice0.select!{|e| /[:.]+/ === e}.sort

def roll(d)
  # rolling is easy
  # -> use size instead of hardcoded number,
  #   maybe we'll have other dices later
  d.slice!(rand(d.size - 1))
end

# and here you have 8 very underhanded dices!
dices = [dice]*8

# roll like a champion
roll(dices[0])
...
David Herrmann
fuente
Agregaría un "aborto" requiere ruby ​​2 "si RUBY_VERSION <" 2 "'está allí en algún lugar, como si lo ejecutaras en versiones anteriores arruina el truco
bazzargh
0

Haskell

Usa una cosa al azar para hacer otra cosa al azar: en este caso, baraja cartas para generar tiradas de dados.

import System.Environment
import System.Random
import Data.Array.IO
import Control.Monad
-- make random dice from random cards
suit c=map (\(a,b)->[a,b])$zip "A23456789TJQK" (repeat c)
deck=concatMap(\s->suit s) "♠♥♦♣"
-- just like casinos, use more decks for extra randomness
decks=concat$take 8$repeat deck
-- shuffle the cards
shuffle :: [a] -> IO [a]
shuffle xs = do
        ar <- newArray n xs
        forM [1..n] $ \i -> do
            j <- randomRIO (i,n)
            vi <- readArray ar i
            vj <- readArray ar j
            writeArray ar j vi
            return vj
  where
    n = length xs
    newArray :: Int -> [a] -> IO (IOArray Int a)
    newArray n xs =  newListArray (1,n) xs
-- convert a card to a die, by counting along the original deck
-- then taking mod (faces). If we don't have enough cards to make
-- a full set of faces, assign the 'extra' cards a value of 0
card2die faces card=
  let index=(head[i|(i,c)<-zip[0..]deck,c==card]) in
  if (index > (length deck-(length deck`mod`faces)))
  then 0
  else (index`mod`faces)+1
main=
  do
    args <- getArgs
    let faces = read (args!!0)
    -- throw away cards we can't map to die faces
    cards<-shuffle$filter (\card->card2die faces card/=0) decks
    mapM_ (\card->putStrLn (card++" -> "++(show (card2die faces card)))) cards

Toma un argumento, el número de caras en el dado. La salida es así:

./cards 20|head
2♦ -> 8
7♥ -> 20
J♦ -> 17
6♥ -> 19
9♥ -> 2
8♥ -> 1
5♥ -> 18
4♠ -> 4
Q♥ -> 5
2♣ -> 1

... y así sucesivamente para todas las tarjetas (los descartes no se imprimen). ¿Muy obvio?

bazzargh
fuente