ये मेरे भाग्यशाली पासे हैं [बंद]

Question

एक कार्यक्रम या फ़ंक्शन को लागू करें जो भूमिका निभाने वाले खेलों के लिए आम पासा का अनुकरण करता है। यह कम से कम d6 और d20, दो सबसे आम पासा संभालना चाहिए।

हालांकि, यह काम करना चाहिए क्योंकि स्टीरियोटाइपिकल गेमर्स उनसे काम करने की उम्मीद करते हैं, न कि असली पासा काम के रूप में।

यह गेमर्स के बीच एक मजाक है, कि एक बहुत ही महत्वपूर्ण रोल के लिए एक विशेष रूप से भाग्यशाली मृत्यु हो सकती है, पहले बहुत सारे पासे फेंककर, उन का चयन करके जिसके परिणामस्वरूप एक "1" हुआ, फिर उन्हें फेंक देना, जब तक आप नहीं मिलते कुछ जो कई बार "1" लुढ़का। फिर आप उन्हें सावधानीपूर्वक संरक्षित करते हैं, क्योंकि उन्होंने क्रम में 1 कई बार रोल किया है, इसलिए अगली बार 1 रोल करने की संभावना बेहद कम होनी चाहिए।

बेशक, यह नहीं है कि वास्तविक जीवन में पासा कैसे काम करता है , क्योंकि रोल सांख्यिकीय रूप से स्वतंत्र हैं।

आपके सिम्युलेटेड पासा को पिछले रोल को ध्यान में रखना होगा, और इसी तरह काम करना होगा कि कैसे जुआरी की पराजय में जुआरी को यह काम करने की उम्मीद है। उदाहरण के लिए, यदि बहुत कम संख्या में रोल किए गए थे, तो अधिक संख्या में रोल करने की संभावना बढ़नी चाहिए।

हालांकि, जैसा कि यह धोखा है, आपको इसे अच्छी तरह से छिपाना होगा । इसका मतलब है, कार्यक्रम पर एक आकस्मिक नज़र यह नहीं दर्शाती है कि आपने धोखा दिया है। इसका मतलब है, पिछले परिणामों को स्पष्ट रूप से सहेजना और उन्हें हर फेंक पर पढ़ना बहुत संदेहास्पद होगा। आपको अपने पासे की इस "संपत्ति" को छुपाना होगा, और बोनस अंक यदि आप इसे प्रशंसनीय अस्वीकार्य बनाते हैं और इसे एक ईमानदार गलती मानते हैं। (उदाहरण के लिए, आप "अनजाने" दोष के साथ अपना RNG बनाते हैं)

मतदाता, कृपया ध्यान रखें कि यह "दोष" कितना अच्छा है।

कार्यक्रम स्पष्ट होने चाहिए, न कि बाधित। एक अस्पष्ट कार्यक्रम में बुराई कोड छिपाना बहुत आसान है।

Comments

हम कितनी अच्छी तरह से छिपे हुए हैं? IMO, भाषा के समकक्ष से परे कुछ भी getRandomBetween(1,d)मुझे इसके बारे में गहराई से देखने का कारण बनेगा।

— जियोबिट्स

@Geobits: आप यहाँ बहुत कम उदाहरण दे सकते हैं कि यहाँ की समस्याओं को कैसे हल किया जाए: codegolf.stackexchange.com/questions/19569/ ... मेरा मतलब है कि आप कुछ भी कर सकते हैं यदि आप इसे अच्छी तरह से उचित ठहराते हैं, तो निश्चित रूप से, औचित्य हो सकता है बड़ा झूठ।

— vsz

Godmaydamnit, java doesnt पर्याप्त सामान के लिए quirks है ...

— MasterX244

सम्बंधित: thedailywtf.com/articles/introducing-the-lucky-deuce

— नील

मैं इस सवाल को ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि अंडरहैंड चुनौतियां अब ऑफ-टॉपिक हैं, और किसी तरह यह एक रडार के नीचे फिसल गया।

— मेगो

Answer 1

जावा

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एक सीधा रैखिक बधाई देने वाला जनरेटर है, और यह एकरूपता सुनिश्चित करने के लिए एक त्याग तकनीक का उपयोग करता है, इसलिए यह गारंटी देता है कि size2 ^ 48 सैंपल से छोटे के किसी भी भाग में यह 48 नमूनों को वितरित करेगा। समान रूप से संख्या, आवश्यकता को पूरा करती है।

Comments

खिचड़ी भाषा के बारे में समझाने के लिए कैसे java.util.random काम करता है

— MasterX244

java.util.Randomइस जवाब के व्यवहार के साथ प्रदर्शन करने वाले का त्याग बहुत कम है। वास्तव में, यह उत्तर जिस पर निर्भर करता है वह यह तथ्य है कि किसी भी आरएनजी की तरह, java.util.Randomएक अवधि होती है, और यदि आप अवधि के क्रम पर कई संख्याएं उत्पन्न करते हैं, तो इसके सांख्यिकीय गुण टूट जाते हैं। यह बहुत दिलचस्प नहीं है; यदि आप इसे लंबे समय तक चलाते हैं तो ब्लम ब्लम जैसे क्रिप्टोग्राफिक रूप से सुरक्षित आरएनजी के साथ भी यही होगा।

— user2357112

@ user2357112, त्याग प्रासंगिक है क्योंकि प्रश्न के लिए एकरूपता की आवश्यकता है, न कि छोटी संख्या के लिए छोटे पूर्वाग्रह की। मेरी राय में यह जवाब अंडरहैंडनेस का प्रतीक है: एक मानक पुस्तकालय का जानबूझकर उपयोग एक तरह से जो पहली नज़र में पारदर्शी रूप से सही लगता है, लेकिन वास्तव में इसे इसके डिजाइन मापदंडों के बाहर ले जाता है।

— पीटर टेलर

बहुत ज्यादा हर RNG को खारिज कर देता है, हालांकि। यह कुछ खास नहीं है। आप इस उत्तर का उपयोग शाब्दिक रूप से किसी भी छद्म आयामी संख्या जनरेटर के साथ कर सकते थे, क्योंकि यदि एक आरएनजी 1) की अवधि होती है, और 2) 1 से अधिक विभिन्न संख्याओं का उत्पादन कर सकती है, तो एक एकल अवधि के दायरे में, एक संख्या अधिक दिखाई गई है। अन्य संख्याओं के सापेक्ष, कम यह एक साधारण गिनती तर्क द्वारा अगली अवधि तक दिखाई देगा।

— user2357112

इस उत्तर में विश्लेषण को दिखाने के लिए एक प्रभाव के लिए 2 ^ 48 रोल के आदेश पर आवश्यकता होती है। हो सकता है कि यदि आपने एक अधिक परिष्कृत विश्लेषण का उपयोग किया था, तो यह दर्शाता है कि LCG के उपयोग से औसत दर्जे की विसंगतियों का पता चलता है, जो कई रोल में दिखाई देंगे, जो कि एक टेबलटॉप गेम में दिखाई देंगे, यह एक ठीक जवाब हो सकता है। जब आप अरबों-खरबों के रोल के बारे में बात कर रहे हैं, हालांकि, यह बहुत कम नहीं है।

— user2357112 मोनिका

Answer 2

माणिक

वर्तमान में केवल 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])
...

Comments

मैं "abort" को माणिक 2 की आवश्यकता है अगर कहीं में RUBY_VERSION <"2" है, तो जैसे कि आप इसे पहले के संस्करणों पर चलाते हैं, यह चाल को बिगाड़ देता है

— bazzargh

Answer 3

हास्केल

एक और यादृच्छिक चीज़ बनाने के लिए एक यादृच्छिक चीज़ का उपयोग करें: इस मामले में, पासा फेंकने के लिए कार्ड को फेरबदल करें।

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

... और इसी तरह सभी कार्डों के लिए (डिस्क्रिप्शन नहीं छपे हैं)। बहुत स्पष्ट?