सरल छद्म-यादृच्छिक एल्गोरिदम

Question

मुझे एक छद्म-यादृच्छिक जनरेटर की आवश्यकता है जो इनपुट के रूप में एक संख्या लेता है और एक और संख्या चुड़ैल प्रतिलिपि बनाता है और यादृच्छिक प्रतीत होता है।

• प्रत्येक इनपुट संख्या ठीक एक उत्पादन संख्या के लिए मैच चाहिए और इसके विपरीत
• ही इनपुट संख्या हमेशा एक ही उत्पादन संख्या
• अनुक्रमिक इनपुट संख्या है कि एक साथ करीब हैं में परिणाम (। 1 और जैसे 2) का उत्पादन करना चाहिए पूरी तरह से अलग आउटपुट नंबर (उदाहरण 1 => 9783526, 2 => 283)

यह सही नहीं होना चाहिए, यह केवल यादृच्छिक लेकिन पुन: उत्पन्न परीक्षण डेटा बनाने के लिए है।

मैं सी # का उपयोग करता हूं।

---

मैंने कुछ समय पहले इस हास्यास्पद टुकड़े को लिखा था जिसने कुछ यादृच्छिक उत्पादन किया था।

public static long Scramble(long number, long max) 
    { 
    // some random values 
    long[] scramblers = { 3, 5, 7, 31, 343, 2348, 89897 }; 
    number += (max/7) + 6; 
    number %= max; 
    // shuffle according to divisibility 
    foreach (long scrambler in scramblers) 
    { 
     if (scrambler >= max/3) break; 
     number = ((number * scrambler) % max) 
     + ((number * scrambler)/max); 
    } 

    return number % max; 
    } 

मैं कुछ बेहतर, अधिक भरोसेमंद, किसी भी आकार के आकार (कोई अधिकतम तर्क) के साथ काम करना चाहता हूं।

क्या यह शायद सीआरसी एल्गोरिदम का उपयोग करके हल किया जा सकता है? या कुछ थोड़ा शफल सामान।

Answer 1

आप (शायद) यह आसानी से सी # में रैंडम वर्ग का उपयोग कर सकते हैं:

public int GetPseudoRandomNumber(int input) 
{ 
    Random random = new Random(input); 
    return random.Next(); 
} 

के बाद से आप स्पष्ट रूप से इनपुट के साथ रैंडम बोने रहे हैं, आप एक ही आउटपुट हर बार मिल जाएगा एक ही इनपुट मान दिया ।

Answer 2

मैं इस जवाब से माइक्रोसॉफ्ट कोड निकालने, जीएनयू कोड फ़ाइल एक बहुत लंबी है लेकिन मूल रूप से यह http://cs.uccs.edu/~cs591/bufferOverflow/glibc-2.2.4/stdlib/random_r.c से शामिल हैं:

int32_t val = state[0]; 
val = ((state[0] * 1103515245) + 12345) & 0x7fffffff; 
state[0] = val; 
*result = val; 

अपने उद्देश्य के लिए

, बीज राज्य है [0] तो यह होगा अधिक की तरह

int getRand(int val) 
{ 
    return ((val * 1103515245) + 12345) & 0x7fffffff; 
} 

Answer 3

देखने के पहले दो नियमों इनपुट की एक निश्चित या इनपुट-वरीयता प्राप्त क्रमचय सुझाव देते हैं, लेकिन तीसरे नियम एक और को बदलने की आवश्यकता है।

क्या उस परिवर्तन को मार्गदर्शन करने के लिए आउटपुट क्या होना चाहिए, इस पर कोई और प्रतिबंध है? - उदा। क्या आउटपुट वैल्यू का एक इनपुट सेट चुनने के लिए है?

केवल गाइड "किसी अधिकतम" है, तो मैं निम्नलिखित ...

1. पूरे इनपुट करने के लिए एक हैश एल्गोरिथ्म लागू करें पहली उत्पादन आइटम प्राप्त करने के लिए प्रयोग करेंगे। एक सीआरसी काम कर सकता है, लेकिन अधिक "यादृच्छिक" परिणामों के लिए, एक क्रिप्टो हैश एल्गोरिदम का उपयोग करें जैसे कि एमडी 5।

2. इनपुट पर अगली क्रमपरिवर्तन एल्गोरिदम (Google पर बहुत सारे लिंक) का उपयोग करें।

3. हैश-फिर-अगली-क्रमपरिवर्तन दोहराएं जब तक कि सभी आवश्यक आउटपुट नहीं मिल जाते।

अगले क्रमचय overkill हालांकि हो सकता है, तो आप शायद सिर्फ पहली इनपुट को बढ़ा सकता है (और शायद, अतिप्रवाह पर, दूसरे और इतने पर बढ़ाने के) हैश redoing से पहले।

क्रिप्टो-स्टाइल हैशिंग के लिए, आपको एक कुंजी की आवश्यकता होगी - बस शुरू करने से पहले इनपुट से कुछ प्राप्त करें।

Answer 4

एक टॉस्वार्थ जेनरेटर लागू करने के लिए आसान है और बहुत तेज़ है। (2 ** 31 - 1, क्योंकि शून्य एक नियत बिन्दु है) के बाद स्यूडोकोड कार्यान्वयन पूरा चक्र है:

def tausworthe(seed) 
    seed ^= seed >> 13 
    seed ^= seed << 18 
    return seed & 0x7fffffff 

मैं सी # पता नहीं है, लेकिन मैं इसे XOR है संभालने हूँ (^) और बिट शिफ्ट (<<, >>) सी

प्रारंभिक बीज मान सेट करें, और seed = tausworthe(seed) के साथ आवेदक के रूप में ऑपरेटर।