Implementieren Sie ein Programm oder eine Funktion, die gängige Würfel für Rollenspiele simuliert. Es sollte mindestens mit d6 und d20 umgehen, den beiden häufigsten Würfeln.

Es sollte jedoch so funktionieren, wie es stereotype Spieler erwarten, dass sie funktionieren, und nicht wie echte Würfel.

Es ist ein Scherz zwischen Spielern, dass man einen besonders glücklichen Würfel für einen sehr sehr wichtigen Wurf haben kann, indem man vorher viele Würfel wirft, diejenigen auswählt, die zu einer "1" geführt haben, und sie dann erneut wirft, bis man sie bekommt einige, die mehrmals eine "1" gewürfelt haben. Sie bewahren sie dann sorgfältig auf, da sie mehrmals hintereinander eine 1 gewürfelt haben. Daher sollte die Wahrscheinlichkeit, beim nächsten Mal eine 1 zu würfeln, äußerst gering sein.

Natürlich funktionieren Würfel im wirklichen Leben nicht so , weil die Würfe statistisch unabhängig sind.

Ihre simulierten Würfel müssen frühere Würfe berücksichtigen und ähnlich funktionieren, wie es der Spieler im Irrtum des Spielers erwartet. Wenn zum Beispiel viele niedrige Zahlen gewürfelt wurden, sollte die Wahrscheinlichkeit, eine höhere Zahl zu würfeln, erhöht werden.

Da dies jedoch Betrug ist, müssen Sie es gut verstecken . Dies bedeutet, dass ein gelegentlicher Blick auf das Programm nicht zeigen sollte, dass Sie betrogen haben. Dies bedeutet, dass es zu verdächtig wäre, die vorherigen Ergebnisse explizit zu speichern und sie bei jedem Wurf zu lesen. Sie müssen diese "Eigenschaft" Ihrer Würfel und Bonuspunkte verstecken, wenn Sie sie plausibel leugnen und als ehrlichen Fehler tarnen. (Zum Beispiel erstellen Sie Ihr eigenes RNG mit einem "unbeabsichtigten" Fehler.)

Wähler, bitte berücksichtigen Sie, wie gut dieser "Fehler" versteckt ist.

Die Programme sollten klar und nicht verschleiert sein. Es ist zu einfach, bösen Code in einem verschleierten Programm zu verstecken.

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 ist so einfach, dass es offensichtlich nichts verbirgt: Es java.util.Randomist ein einfacher linearer Kongruenzgenerator und verwendet eine Verwerfungstechnik, um die Gleichmäßigkeit sicherzustellen. So wird garantiert, dass in jedem Lauf des größten Vielfachen von sizeweniger als 2 ^ 48 Samples die verteilt wird Zahlen gleichmäßig, die Anforderung zu erfüllen.

Rubin

Derzeit unterstützt nur d6, wird später d20 Unterstützung hinzufügen ...

Und siehe da - diese Würfel sind böse!

# 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

Verwenden Sie eine zufällige Sache, um eine andere zufällige Sache zu machen: In diesem Fall mischen Sie Karten, um Würfelwürfe zu generieren.

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

Nimmt ein Argument, die Anzahl der Gesichter auf dem Würfel. Die Ausgabe ist wie folgt:

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

... und so weiter für alle Karten (Abwürfe werden nicht gedruckt). Zu offensichtlich?