Das sind meine Glückswürfel [geschlossen]

10

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.

vsz
quelle
3
Wie gut versteckt reden wir? IMO, alles, was über das Äquivalent der Sprache hinausgeht, getRandomBetween(1,d)würde mich veranlassen, tiefer in die Sprache zu schauen.
Geobits
@Geobits: Ein sehr schönes Beispiel für die Lösung von hinterhältigen Problemen finden Sie hier: codegolf.stackexchange.com/questions/19569/… Ich meine, Sie können alles tun, wenn Sie es gut genug rechtfertigen. Natürlich kann die Rechtfertigung eine sein große Lüge.
vsz
Godmaydamnit, Java hat nicht genug Macken für hinterhältige Sachen ...
masterX244
Siehe auch
Neil
4
Ich stimme dafür, diese Frage als nicht zum Thema gehörend zu schließen, da hinterhältige Herausforderungen jetzt nicht zum Thema gehören und diese Frage irgendwie unter das Radar gerutscht ist.
Mego

Antworten:

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

Peter Taylor
quelle
Ich kann nicht hinter die Erklärung kommen, wie java.util.random funktioniert
masterX244
Das Verwerfen, java.util.Randomdas ausgeführt wird, hat sehr wenig mit dem Verhalten dieser Antwort zu tun. Wirklich, worauf diese Antwort beruht, ist die Tatsache, dass sie wie jedes RNG java.util.Randomeinen Punkt hat, und wenn Sie eine Anzahl von Zahlen in der Reihenfolge des Zeitraums generieren, brechen seine statistischen Eigenschaften zusammen. Das ist nicht sehr interessant; Das gleiche würde sogar mit einem kryptografisch sicheren RNG wie Blum Blum Shub passieren, wenn Sie es lange genug laufen lassen.
user2357112 unterstützt Monica
@ user2357112, das Verwerfen ist relevant, da die Frage Einheitlichkeit erfordert, keine kleine Tendenz zu kleineren Zahlen. Meiner Meinung nach verkörpert diese Antwort Hinterhältigkeit: Die bewusste Verwendung einer Standardbibliothek auf eine Weise, die auf den ersten Blick transparent korrekt erscheint, sie jedoch tatsächlich außerhalb ihrer Entwurfsparameter nimmt.
Peter Taylor
Ziemlich jedes RNG macht jedoch das Verwerfen. Es ist nichts Besonderes. Sie hätten diese Antwort mit buchstäblich jedem Pseudozufallszahlengenerator verwenden können, denn wenn ein RNG 1) eine Periode hat und 2) mehr als eine andere Zahl erzeugen kann, ist im Rahmen einer einzelnen Periode umso mehr eine Zahl aufgetaucht Im Vergleich zu anderen Zahlen wird es durch ein einfaches Zählargument bis zur nächsten Periode weniger angezeigt.
user2357112 unterstützt Monica
Die Analyse in dieser Antwort erfordert in der Größenordnung von 2 ^ 48 Rollen, damit ein Effekt sichtbar wird. Wenn Sie eine differenziertere Analyse verwendet hätten, die zeigt, dass die Verwendung eines LCG dazu führt, dass messbare statistische Anomalien innerhalb einer Reihe von Rollen auftreten, die in einem Tabletop-Spiel plausibel auftreten würden, wäre dies möglicherweise eine gute Antwort. Wenn Sie über Billionen von Brötchen sprechen, ist es einfach nicht sehr hinterhältig.
user2357112 unterstützt Monica
0

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])
...
David Herrmann
quelle
Ich würde hinzufügen, dass ein "Abbruch" Ruby 2 "erfordert, wenn RUBY_VERSION <" 2 "'irgendwo drin ist, als ob Sie es auf früheren Versionen ausführen, es verdirbt den Trick
bazzargh
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?

Bazzargh
quelle