समय-आधार के बिना यादृच्छिक [बंद]

Question

कंप्यूटर बिना आधार के यादृच्छिक संख्याएँ नहीं बनाते हैं, जैसा कि सबसे अधिक संभावना है, समय यादृच्छिकता का सार्वभौमिक आधार है।

मैं चाहता हूं कि आप एक ऐसा कोड बनाएं जो इन नियमों के साथ यादृच्छिक संख्या बनाता है:

• कार्यक्रम के किसी भी बिंदु पर समय को आधार नहीं होने दिया जाता है।
• पूर्वनिर्धारित यादृच्छिक / छद्म यादृच्छिक कार्यों की अनुमति नहीं है।
• उत्पन्न संख्या किसी भी सीमा के भीतर हो सकती है। कम से कम दो अलग-अलग पूर्णांक: डी
• नंबर गूँज रहे हैं।

Comments

यह स्पष्ट नहीं है कि आपके द्वारा उत्पन्न "संख्या किसी भी सीमा के भीतर हो सकती है" से क्या मतलब है। क्या आपको लगता है कि रेंज चुनने के लिए कोडर स्वतंत्र है? या कि वे किसी भी रेंज उपयोगकर्ता अनुरोध का समर्थन करना चाहिए? ये दोनों समस्याग्रस्त हैं। यदि उपयोगकर्ता एक सीमा का अनुरोध करता है, तो क्या होगा यदि वे डेटा प्रकारों में निर्मित सीमा के बाहर संख्या का अनुरोध करते हैं? और अगर कोडर चुनने के लिए स्वतंत्र है, तो मैं 1 और 1. के बीच पूर्णांक चुनता हूं: डी

— जोनाथन वान मैटर

कोड-गोल्फ होना चाहिए था ...

— मुकुल कुमार

मैंने इस सवाल को लोकप्रियता-सवाल के रूप में शुरू किया, क्या कोड-गोल्फ इसके लिए बेहतर होगा?

— दादन

@ डैनियल हाँ, लेकिन इस सवाल को लोकप्रियता-सवाल बनने दें और नए नियम (यादृच्छिक पीढ़ी पर) के साथ कोड गोल्फ के साथ एक नया प्रश्न पोस्ट करें जो मज़ेदार होगा

— मुकुल कुमार

एक बीज के रूप में इंटरनेट का उपयोग करते हुए ऐसा लगता है कि धोखा नहीं है?

— डीन मैकग्रेगर

Answer 1

जावास्क्रिप्ट

वह मजेदार था!

arr = []
index = 0

function init(seed) {
    index = 0
    arr[0] = seed
    for (var i = 1; i < 624; i ++) {
        arr[i] = (1812433253 * (arr[i-1] ^ (arr[i-1] >>> 30)) + i) | 0
    }
 }

function getNumber() {
    if (index == 0) generateNumbers()

    var y = arr[index]
    y ^= (y >>> 11)
    y ^= ((y << 7) & 2636928640)
    y ^= ((y << 15) & 4022730752)
    y ^= (y >>> 18)

    index = (index + 1) % 624
    return y
}

function generateNumbers() {
    for (var i = 0; i < 624; i ++) {
        var y = (arr[i] & 0x80000000) + (arr[(i+1) % 624] & 0x7fffffff)
        arr[i] = arr[(i + 397) % 624] ^ (y >>> 1)
        if (y % 2 != 0) arr[i] ^= 2567483615
    }
}

// let's get our seed now from the SE API
var x = new XMLHttpRequest()
x.open('GET', 'http://api.stackexchange.com/2.2/answers?pagesize=10&order=desc&sort=activity&site=stackoverflow&filter=!Sri2UzKb5mTfr.XgjE', false)
x.send(null)
// we've got the answer data, now just add up all the numbers.
// only 4 digits at a time to prevent too big of a number.
var seed = 0
var numbers = x.responseText.match(/\d{0,4}/g)
for (var i = 0; i < numbers.length; i++) seed += +numbers[i]

init(seed)
for (var i = 0; i < 10; i++) console.log(getNumber())

मैंने जेएस में मेरसेन ट्विस्टर लिखा। फिर, मुझे एहसास हुआ कि मुझे कहीं से एक बीज प्राप्त करना था।

इसलिए, मैंने फैसला किया कि मैं इसे स्टैक एक्सचेंज एपीआई से प्राप्त करूंगा! (मैं प्रयोग कर सकता हूँlocalStorage एक काउंटर का और वृद्धि , लेकिन यह कोई मजेदार नहीं है।) इसलिए, मैंने 10 सबसे हाल ही में सक्रिय जवाबों को पकड़ा, और फिर मैंने प्रतिक्रिया में सिर्फ 4 या उससे कम लगातार अंक लिए और उन्हें जोड़ा।

ये बीज हमेशा अलग होते हैं, क्योंकि स्टैक ओवरफ्लो लगातार अद्यतन हो रहा है (और मेरा कोटा नीचे जा रहा है!) संख्याओं में उत्तर आईडी, प्रश्न आईडी, स्कोर, अप / डाउनवोट काउंट्स, मालिक प्रतिनिधि / आईडी और आवरण डेटा (कोटा और इस तरह) शामिल हैं। )। एक रन पर मुझे 256845, फिर 270495, और फिर 256048, आदि मिला।

यह कंसोल में 10 यादृच्छिक 32-बिट दो-पूरक संख्याओं को लॉग करता है। नमूना उत्पादन:

247701962
-601555287
1363363842
-1184801866
1761791937
-163544156
2021774189
2140443959
1764173996
-1176627822

Answer 2

जावा

import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;

/**
 *
 * @author Quincunx
 */
public class NoTimeRandom extends Random {

    private AtomicLong seed;

    public NoTimeRandom() {
        byte[] ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        int seed1 = 1;
        for (byte b : ba) {
            seed1 += b;
        }

        ba = (new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()
                + new String[0].toString() + new String[0].toString()).getBytes();
        long seed2 = 1;
        for (byte b : ba) {
            seed2 += b;
        }

        seed = new AtomicLong(seed1 ^ seed2);
    }

    @Override
    protected int next(int bits) {
        long oldseed, newseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            newseed = (oldseed * 25214903917L + 11) & 281474976710655L;
        } while (!seed.compareAndSet(oldseed, newseed));

        return (int) (newseed >>> (48 - bits));
    }

    public static void main(String[] args) {
        Random r = new NoTimeRandom();

        for (int i = 0; i < 5; i++) {
            System.out.println(r.nextInt());
        }
    }

}

जादू में है public NoTimeRandom()। तार के लिए डाली गई सारणियाँ नए प्रोग्रामर को भ्रमित कर सकती हैं, क्योंकि संख्याएँ यादृच्छिक हैं। नमूना (के लिए ) char[]: विधि से नकल कर रहा है ।[[e-mail]

नमूना उत्पादन:

134277366
467041052
-555611140
-1741034686
1420784423

---

आइए इस rng की प्रभावशीलता का परीक्षण करें:

में मेरा उत्तर के लिए एक बेल कर्व लगभग , डेटा पीढ़ी मैं प्रयोग किया जाता है एक अच्छा RNG पर निर्भर करता है। आइए इसे इसे अँगूठी के रूप में चलाते हैं। आउटपुट:

जैसा मैंने सोचा था। यह एक सुंदर घटिया है।

Answer 3

सी

-पिथ्रेड फ्लैग (या जो भी आपका कंपाइलर उपयोग करता है) के साथ कंपाइल करें।

#include <stdio.h>
#include <pthread.h>

#define m (unsigned long)2147483647
#define q (unsigned long)127773
#define a (unsigned int)16807
#define r (unsigned int)2836 

static unsigned long seed;
pthread_t t[20];
int lo, hi, done;

void *pseudorandom(void *id)
{
    while(done)
    {
        int test;
        hi = seed/q;
        lo = seed%q;
        test = a * lo - r * hi;
        if (test > 0) seed = test;
        else seed = test + m;
    }
}

main()
{
     int i;
     seed = 54321;
     done = 1;

     for(i = 0; i < 20; i++) 
     {
          pthread_create(&(t[i]), NULL, &pseudorandom, NULL);
     }

     for (i = 0; i < 10; i++) 
     {
          printf("%lu\n", seed);
     }

     done = 0;
}

मुझे यकीन नहीं है कि यह "समय की अनुमति नहीं है" मानक के आधार पर योग्य है या नहीं, क्योंकि यह मूल रूप से अनुसूचक का उपयोग धागा सुरक्षा के जानबूझकर अनदेखी करके एन्ट्रापी के स्रोत के रूप में कर रहा है। यह एक कठिन कोडित प्रारंभिक बीज के साथ एक काफी बुनियादी psuedo- यादृच्छिक समारोह ( Lehmer यादृच्छिक संख्या जनरेटर ) का उपयोग करके काम करता है । इसके बाद 20 सूत्र शुरू होते हैं जो सभी लेहमर गणना को चर के साझा समूह के साथ चलाते हैं।

काफी अच्छी तरह से काम करने के लिए लगता है, यहाँ लगातार रन के एक जोड़े हैं:

comintern ~ $ ./a.out
821551271
198866223
670412515
4292256
561301260
1256197345
959764614
874838892
1375885882
1788849800
comintern ~ $ ./a.out
2067099631
953349057
1736873858
267798474
941322622
564797842
157852857
1263164394
399068484
2077423336

संपादित करें: यह थोड़ा और अधिक सोचा और महसूस किया कि यह समय बिल्कुल भी आधारित नहीं है। यहां तक ​​कि पूरी तरह से नियतात्मक अनुसूचक के साथ, एन्ट्रॉपी समय स्लाइस से नहीं आ रहा है - यह सिस्टम पर सभी चल रही प्रक्रियाओं के लोडिंग से आ रहा है।

EDIT 2 @Quincunx से कुछ प्रेरणा लेने के बाद एक घंटी वक्र पोस्ट कर रहा है, मैंने 12MB यादृच्छिकता को एक फ़ाइल में डंप किया और इसे CAcert पर अपलोड किया । यह सभी डेडहार्ड परीक्षणों में विफल रहा, लेकिन ईएनटी परीक्षण (केवल संभावित रूप से नियतात्मक) पर 8 में से एक सम्मानित 7.999573 को देखा । उत्सुकता से, थ्रेड काउंट को दोगुना करने से यह खराब हो गया।

Answer 4

सी

यह प्रयोग करके https://stackoverflow.com/questions से बीज लेकर 0-255 रेंज में एक यादृच्छिक संख्या उत्पन्न करता है wget।

#include <stdio.h>
main()
{
    FILE *file;
    unsigned char c,x;
    system("wget -O - https://stackoverflow.com/questions > quest.html");
    file = fopen ("quest.html", "r");
    while(c=fgetc(file) != EOF) x+=c;
    fclose(file);
    printf("%d",x);
}

नमूना रन:

C:\Users\izabera>random
--2014-03-02 16:15:28--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85775 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,775      40.3K/s   in 2.1s

2014-03-02 16:15:31 (40.3 KB/s) - `-' saved [85775/85775]

15 /* <=================== THIS IS THE RANDOM NUMBER */
C:\Users\izabera>random
--2014-03-02 16:15:36--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85836 (84K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,836      50.0K/s   in 1.7s

2014-03-02 16:15:38 (50.0 KB/s) - `-' saved [85836/85836]

76
C:\Users\izabera>random
--2014-03-02 16:15:56--  https://stackoverflow.com/questions
Resolving stackoverflow.com... 198.252.206.140
Connecting to stackoverflow.com|198.252.206.140|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 85244 (83K) [text/html]
Saving to: `STDOUT'

100%[======================================>] 85,244      36.0K/s   in 2.3s

2014-03-02 16:15:59 (36.0 KB/s) - `-' saved [85244/85244]

144

Answer 5

सी ++

#include<iostream>
int main()
{
    int *ptr=new int,i=0;
    for(;i<5;i++)
    {
        std::cout<<*(ptr+i)<<'\n';
    }
    return 0;
}  

उत्पादन

किसी भी 5 यादृच्छिक संख्या

तीन नमूने

Comments

1, 2 और 5 वां बहुत करीब हैं, सभी 3 उदाहरणों में एक ही पैटर्न दोहराया गया है। यादृच्छिक संख्या जनरेटर से अपेक्षित आउटपुट नहीं।

— इजाबेरा

@izabera जब रैंडम नंबर जेनरेट करने की बात आती है ... सब कुछ आपके कंप्यूटर (RAM और प्रोसेसर) पर निर्भर करता है, तो शायद वर्तमान में 'ptr' में 'नए int' द्वारा दिया गया पता इस्तेमाल किया जा रहा है! आपने इस कोड को चलाने का प्रयास किया है?

— मुकुल कुमार

मुझे थोड़ा बदलाव करने दीजिए

— मुकुल कुमार

मैंने इसे अभी आज़माया है, मेरी मशीन पर ऐसा लगता है कि मुझे हमेशा ऐसी चीज़ें मिलती हैं 11230576, 0, 11206992, 0, 2053725299, जो अभी भी मुझे यादृच्छिक नहीं लगती हैं।

— इजाबेरा

इसे आइडोन

— izabera

Answer 6

पर्ल

इंटरनेट पर बीज पाने के साथ यह सब क्या बकवास है? मुझे धोखा देने जैसा लगता है ;-) मैं इसके बजाय एक क्रिप्टोग्राफ़िक हैश फ़ंक्शन को अपना बीज देना पसंद करता हूं, और 0 से 2 ^ 160-1 की सीमा में आउटपुट देना पसंद करता हूं:

use Digest::SHA1 qw(sha1);
use bigint;
sub r {
  $_ = \3;
  /^.*x([0-9a-f]+).$/;
  hex((unpack "H*", sha1 "some_salt".$1.$$)[0])
}
print join " ", r'

जब भी आपके पास अनिश्चित गुणवत्ता, इसे नियमित रूप से वितरित करने का एक तरीका है (लेकिन इसकी गुणवत्ता में वृद्धि नहीं होती है!) तो इसे SHA1 या MD5 की पसंद में पाइप करना है, जैसा कि मैंने यहां किया है। प्री-हैश बीजों के लिए, मैंने पिड और यादृच्छिक संदर्भ के पते का उपयोग किया है। आप निश्चित रूप से अधिक एन्ट्रापी के लिए अन्य इनपुट जोड़ सकते हैं, उदाहरण के लिए x86 पर आप टीएससी का उपयोग कर सकते हैं - (लेकिन पर्ल में असेंबली कोड को थोड़ा सा सहन करना है, इसलिए मैंने इसे छोड़ दिया है)।

यदि आप अगले कंप्यूटर पर लड़के की तुलना में अलग आउटपुट चाहते हैं, तो अपनी पसंद का एक स्ट्रिंग होने के लिए "some_salt" को समायोजित करें। या इसे पूरी तरह से छोड़ दें यदि आप एक न्यूनतावादी हैं =)

Comments

मुझे लगता है कि एक मानक पुस्तकालय में अपने नाम के लायक कोई भी क्रिप्टोग्राफिक फ़ंक्शन आंतरिक रूप से सुरक्षित रूप से सुरक्षित आरएनजी का उपयोग करता है।

— duci9y

मैं इस बारे में निश्चित नहीं हूं। डाइजेस्ट :: एमडी 5 / डाइजेस्ट :: एसएचए 1 पूरी तरह से निर्धारक, पुन: प्रयोज्य उत्पादन का उत्पादन करता है, तो इसके लिए एक यादृच्छिक संख्या की क्या आवश्यकता है?

— skibrianski

माफ़ करना! मैंने सिर्फ आपके उत्तर पर उड़ान भरी और सोचा कि आप एक पचाने के बजाय एक कुंजी पैदा कर रहे हैं।

— duci9y

Answer 7

जावा

मेरा समाधान कक्षा के hashCode()तरीके का दुरुपयोग करता है Object।

class G22640 {
    static class Rand {
        public int nextInt() {
            return new Object().hashCode();
        }
    }

    public static void main(String args[]) {
        Rand r = new Rand();
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt());
        }
    }
}

नमूना उत्पादन:

31859448
22101035
11593610
4580332
25736626
32157998
3804398
32440180
19905449
2772678

---

अन्य जवाब के समाधान की अनियमितता का प्रदर्शन से प्रेरित है, मैं के बीच 16 बिट वापस जाने के लिए मेरी समाधान बदल intद्वारा लौटाए गए Object.hashCode()।

import java.io.*;

class G22640 {
    static class Rand {
        public short nextShort() {
            return (short) ((new Object().hashCode() >> 8) & 0xFFFF);
        }
    }

    public static void main(String args[]) throws IOException {
        Rand r = new Rand();

        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextShort());
        }

        // generateToFile("random_22640.txt");
    }

    private static void generateToFile(String fileName) throws IOException {
        Rand r = new Rand();
        BufferedOutputStream o = new BufferedOutputStream(new FileOutputStream(fileName));

        for (int i = 0; i < 10000000; i++) {
            int a = r.nextShort();
            for (int j = 0; j < 2; j++) {
                o.write(a & 0xFF);
                a >>= 8;
            }
        }

        o.flush();
        o.close();
    }
}

मैंने 19 एमबी की फ़ाइल (10 ^{7 से} मिलकर short) बनाई और इसे CACert में जमा किया । यहाँ परिणाम का स्क्रीनशॉट दिया गया है (इसे अच्छा दिखने के लिए संपादित किया गया है, लेकिन संख्या इसे छोड़ दी गई है):

मैं परिणाम पर आश्चर्यचकित था, क्योंकि यह एंट्रॉपी टेस्ट में 7.999991 देखता है और सभी 7 डायहार्ड टेस्ट पास करता है (?)।

Answer 8

उपयोगकर्ता माउस चाल के साथ जावास्क्रिप्ट उत्पन्न करना

var ranArr=[];
var random=0;
var first=second=0;
function generateR(event) {
ranArr.push(parseFloat(event.clientX+document.body.scrollLeft))
ranArr.push(parseFloat(event.clientY+document.body.scrollTop));
var len=ranArr.length;

for(var i=0;i<len;i++) {
    if(i<len/2) {

    first+=ranArr[i];
    } else {
    second += ranArr[i];
    }
}
third = second/first;
third = third+"";
console.log(third.substr(5));
}
document.onmousemove=function(event){generateR(event)};

अंतिम पांच कॉपी किए गए डेटा:
9637090187003
7828470680762
6045869361238
4220720695015
2422653391073

Answer 9

बैश, रेंज: 0 से 1 के बीच की इनट्स

echo -n & echo "$! % 2" | bc

Comments

तो आपका मतलब है कि यह केवल 0 या 1 चुनता है?

हां। पूरा करना चाहिए "संख्या उत्पन्न किसी भी सीमा के भीतर हो सकता है। कम से कम दो अलग-अलग पूर्णांक: डी", क्या यह नहीं होना चाहिए?

— केब

मुझे ऐसा लगता हैं। क्या आपको लगता है कि आप इसे बड़ी रेंज तक बढ़ा सकते हैं?

बस echo -n & echo $!करेंगे, लेकिन एक बहुत खराब आरएनजी हो। आप किसी अन्य संख्या के साथ 2 को भी बदल सकते हैं, लेकिन जितनी बड़ी संख्या होगी, उतना ही बुरा "यादृच्छिकता" हो जाता है।

— केबा

समझा। स्पष्टीकरण के लिए धन्यवाद।

Answer 10

माणिक

दुर्भाग्य से केवल मैक। हम soxमाइक्रोफ़ोन से बाइट्स खींचने के लिए उपयोग करते हैं (एक स्ट्रिंग के रूप में, अहम ...), इसे अंत में स्थिति हेडर प्राप्त करने के लिए उल्टा करें (* खांसी *), इसे काट लें, हेडर को काट लें, चंक्स का एमडी 5 लें। , हैश से नॉन-न्यूमेरिक वर्णों को हटाएं, शेष लार्जर पूर्णांक को एक साथ जोड़ें, एक छड़ी0. सामने की तरफ , फ्लोट में कनवर्ट करें, किया।

अंतराल पर अलग-अलग लंबाई की झांकियां बनाता है 0..1।

require 'open3'
require 'digest'

class InsecureRandom
  def self.random_number
    n = self.get_bytes
    .map! { |r| Digest::MD5.hexdigest(r) }
    .map! { |r| r.gsub(/[a-z]/, '') }
    .map!(&:to_i)
    .reduce(0,:+)

    "0.#{n}".to_f
  end

  private
  def self.get_bytes
    Open3.popen3('sox -d -q -e unsigned-integer -p') do |_, stdout, _|
      stdout.read(20000).reverse.split('\\').to_a.take(20)
    end
  end
end

randomish = Array.new(20) { InsecureRandom.random_number }
puts randomish
# >> 0.2333530765409607
# >> 0.17754047429753905
# >> 0.936039801228352
# >> 0.2781141892158962
# >> 0.6243140263525706
# >> 0.1583419168189452
# >> 0.2173713056635174
# >> 0.930577106355
# >> 0.11215268787922089
# >> 0.13292311877287152
# >> 0.14791818448435443
# >> 0.4864648362730452
# >> 0.5133193113765809
# >> 0.3076637743531015
# >> 0.16060112015793476
# >> 0.7294970251624926
# >> 0.18945368886946876
# >> 0.9970215825154781
# >> 0.13775531752383308
# >> 0.5794383903900283

Answer 11

सी

प्रक्रिया आईडी का उपयोग करके यादृच्छिक उत्पन्न करना।

#include <unistd.h>
#include <stdio.h>

int     main(void)
{
    int out;
    out *= out *= out = getpid();
    printf("%d\n", out % 1024);
    return (0);
}

नमूना उत्पादन:

-767
0
769
-1008
337
-768
369
-752
-415
0
-863
784
-463
256
657

Answer 12

स्पिन

अगर यह था कोड गोल्फ, मैं जीत जाऊंगा!

byte a
?a@

Answer 13

अजगर

पाइथन की सुगमता कभी विस्मित करना बंद नहीं करती। चूंकि imgur की यादृच्छिक छवि का उपयोग करना स्पष्ट रूप से मान्य नहीं है, इसलिए मैंने यादृच्छिकता का एक बड़ा स्रोत उपयोग किया है: stackoverflow की चैट!

   import urllib.request

def getrand():
    req = urllib.request.Request("http://chat.stackoverflow.com/")
    response = urllib.request.urlopen(req)
    the_page = str(response.read())

    x = 1
    for char in the_page:
        x = (3*x + ord(char) + 1)%2**32

    print(x)

5 परीक्षण:

3258789746
1899058937
3811869909
274739242
1292809118

वास्तव में यादृच्छिक नहीं है, लेकिन फिर इनमें से कोई भी नहीं है।

Comments

मुझे लगता है कि नियम 2 whatever.com/random

— यूरल्स की

अन्य प्रश्नों के @izabera 2 ने इसका इस्तेमाल किया?

— क्यूर

नहीं, आप बेतरतीब ढंग से उत्पन्न सामग्री का उपयोग कर रहे हैं। अन्य उत्तर केवल बीज प्राप्त करने के लिए कुछ गैर-यादृच्छिक वेबपेज तक पहुंचते हैं और फिर एक यादृच्छिक संख्या प्रिंट करते हैं।

— इजाबेरा

@izabera मैंने अपना यादृच्छिक स्रोत बदल दिया है। अब आप इसके बारे में क्या सोचते हैं?

— क्यूर

अब यह ठीक है: D

— izabera

Answer 14

पर्ल

मैंने बहुत से उत्तर देखे, जो HTTP अनुरोध करते थे, जो मुझे बेकार लगता है क्योंकि कवर के तहत तार पर यादृच्छिक संख्याओं को पारित किया जा रहा है। इसलिए मैंने निचले स्तर पर एक को स्वाइप करने के लिए कुछ कोड लिखने का फैसला किया:

use IO::Socket::INET;
print ((sockaddr_in(getsockname(IO::Socket::INET->new(
    PeerAddr => "google.com", PeerPort => 80, Proto => "tcp"
))))[0]);

सैद्धांतिक रूप से 0. 0.65535 सीमा में यादृच्छिक पोर्ट देता है। व्यवहार में, ऐसे कई पोर्ट हैं जिन्हें आपने कभी नहीं देखा होगा, इसलिए वितरण एकदम सही है। लेकिन यह है, AFAICT न्यूनतम काम है जो आप एक दूरस्थ मेजबान से कुछ एन्ट्रापी प्राप्त करने के लिए कर सकते हैं जिसमें एक पोर्ट खुला है।

पुनश्च - त्रुटि से निपटने पाठक के लिए एक अभ्यास के रूप में छोड़ दिया है ;-)

Answer 15

सी

// alternating two pure-RNG inspired by http://xkcd.com/221/
int getRandomNumber()
{
   static int dice_roll = 0;
   dice_roll++;
   if ((dice_roll % 2) == 1)
   {
      return 4;
   } 
   else
   {
      return 5;
   } 
}

int main(int argc, char **argv)
{
    printf("%d\n%d\n", getRandomNumber(), getRandomNumber())
    return 0;
}