实现一个程序或函数，以模拟角色扮演游戏的普通骰子。它至少应处理最常见的两个骰子d6和d20。

但是，它应该像定型游戏玩家期望的那样工作，而不是像真正的骰子那样工作。

这是玩家之间的一个玩笑，一个人可以为非常非常重要的掷骰而特别幸运地掷骰子，方法是预先掷出很多骰子，选择那些结果为“ 1”的骰子，然后再次掷出它们，直到获得一些将其多次滚动为“ 1”。然后，您要仔细保存它们，因为它们顺序滚动了1次，因此下次滚动1的可能性应该非常低。

当然，这不是骰子在现实生活中的工作方式，因为掷骰在统计上是独立的。

您模拟的骰子必须考虑先前的掷骰，并且其工作方式与赌徒谬论中的赌徒期望其运作的方式类似。例如，如果滚动了很多低数字，则应该增加滚动更高数字的可能性。

但是，由于这是作弊行为，因此必须将其隐藏起来。这意味着，随意浏览该程序不应显示出您被骗。这意味着，显式地保存先前的结果并在每次抛出时都读取它们将太可疑。您必须隐藏骰子的这种“属性”，如果您将其合理化，并且将其伪装成诚实的错误，则可以隐藏奖励积分。（例如，您制作带有“意外”缺陷的RNG）

选民们，请考虑一下这个“缺陷”的隐藏程度。

程序应清晰无误。在经过混淆的程序中隐藏邪恶的代码太容易了。

爪哇

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

它是如此简单，以至于显然没有隐藏任何东西：但是它java.util.Random是一个简单的线性同余生成器，并且它使用了丢弃技术来确保均匀性，因此它保证了在size小于2 ^ 48个样本的最大倍数的任何运行中，它将分布编号均匀，满足要求。

红宝石

目前仅支持d6，稍后会添加d20支持。

瞧瞧-这些骰子真讨厌！

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

哈斯克尔

用一个随机的东西做另一个随机的东西：在这种情况下，洗牌可以产生骰子投掷。

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

接受一个论点，即模具上的面数。输出是这样的：

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

...等等，所有卡（未打印丢弃卡）。太明显了吗？