Thực hiện một chương trình hoặc chức năng mô phỏng xúc xắc phổ biến cho các trò chơi nhập vai. Nó nên xử lý ít nhất là d6 và d20, hai con xúc xắc phổ biến nhất.

Tuy nhiên, nó nên hoạt động như các game thủ khuôn mẫu mong đợi chúng hoạt động, và không phải là hoạt động súc sắc thực sự.

Đây là một trò đùa giữa các game thủ, rằng người ta có thể có một cái chết may mắn đặc biệt cho một cuộn rất quan trọng, bằng cách trước đó ném rất nhiều xúc xắc, chọn những người dẫn đến "1", sau đó ném lại họ, cho đến khi bạn nhận được một số ít cuộn "1" nhiều lần. Sau đó, bạn cẩn thận bảo quản chúng, bởi vì chúng cuộn 1 lần nhiều lần, do đó xác suất để lăn 1 lần tiếp theo sẽ cực kỳ thấp.

Tất nhiên, đây không phải là cách súc sắc hoạt động trong cuộc sống thực , bởi vì các cuộn là độc lập thống kê.

Xúc xắc mô phỏng của bạn phải tính đến các cuộn trước đó và hoạt động tương tự như cách con bạc trong ngụy biện của con bạc mong đợi nó hoạt động. Ví dụ, nếu nhiều số thấp được cuộn, xác suất cán số cao hơn sẽ được tăng lên.

Tuy nhiên, vì đây là gian lận, bạn phải che giấu nó thật tốt . Điều này có nghĩa, một cái nhìn thoáng qua vào chương trình không nên tiết lộ rằng bạn đã gian lận. Điều này có nghĩa là, rõ ràng lưu kết quả trước đó và đọc chúng trên mỗi lần ném sẽ quá đáng ngờ. Bạn phải che giấu "tài sản" này của súc sắc của mình và điểm thưởng nếu bạn làm cho nó bị từ chối một cách chính đáng và ngụy trang nó như một sai lầm trung thực. (ví dụ: bạn tạo RNG của riêng bạn với một lỗ hổng "vô ý")

Cử tri, xin vui lòng xem xét "lỗ hổng" này được che giấu tốt như thế nào.

Các chương trình nên rõ ràng, và không bị xáo trộn. Thật quá dễ dàng để che giấu mã xấu trong một chương trình bị xáo trộn.

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

Nó đơn giản đến nỗi rõ ràng là nó không che giấu bất cứ điều gì: nhưng java.util.Randomlà một máy phát đồng quy tuyến tính đơn giản và nó sử dụng một kỹ thuật loại bỏ để đảm bảo tính đồng nhất, do đó, nó đảm bảo rằng trong bất kỳ hoạt động nào của bội số lớn nhất sizenhỏ hơn 2 ^ 48 mẫu sẽ phân phối số lượng đồng đều, đáp ứng yêu cầu.

Hồng ngọc

Hiện tại chỉ hỗ trợ d6, sẽ thêm hỗ trợ d20 sau ...

Lo và kìa - những con xúc xắc thật khó chịu!

# 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

Sử dụng một điều ngẫu nhiên để tạo ra một điều ngẫu nhiên khác: trong trường hợp này, xáo trộn thẻ để tạo ra những cú ném xúc xắc.

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

Đưa ra một lập luận, số lượng khuôn mặt trên khuôn mặt. Đầu ra là như thế này:

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

... và cứ thế cho tất cả các thẻ (loại bỏ không được in). Quá rõ ràng?