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.

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.

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

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?