Змагання:

Утворіть випадкову послідовність чисел. Єдиним входом повинна бути довжина послідовності.

Додаткові Інтернет-точки для чисто функціональних рішень.

^{Примітка. Це запитання щодо кодування . Будь ласка, не сприймайте питання та / або відповіді серйозно. Більше інформації тут .}

Пітон

Візьміть випадкову статтю у Вікіпедії та візьміть послідовність символів html довжини num та отримайте їх числові значення

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)

Усі програми з інших відповідей генеруватимуть лише так звані «псевдовипадкові числа», які можуть виглядати випадковими для нетренованого ока, але насправді слідують деякій схемі.

Наступна програма генерує фактичні випадкові числа, перетворюючи комп'ютер у детектор частинок для фонового випромінювання. Оскільки це ґрунтується на квантових ефектах, це насправді випадково і неможливо передбачити. А для бонусу програма насправді працює швидше, якщо запустити комп’ютер у космос. І так, це все круто, як це звучить.

С

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

Спойлер:

Ця програма генерує два однакових пам'яті, а потім чекає, скільки часу потрібно, щоб фонове випромінювання змінило один з них. Потім час очікування повертається у вигляді випадкового числа, яке було б експоненціально розподілене, якби не цілі переповнення. Такі події, які є більш імовірними в космосі, є актуальною проблемою космонавтики, яку вирішують радіаційним зміцненням . Отже, кожне твердження у вступі до певної міри вірно, окрім частини про прохолоду.

На жаль, така подія, що вибиває комп'ютер чи принаймні програму, скоріше, ніж впливає саме на ці дві частини пам'яті. Крім того , це може зайняти деякий час ... І, нарешті, як зазначив kinokijuf, радіаційний фон зовнішній процес, так jі kповинно бути позначено як volatileдля компілятора (або ви повинні використовувати компілятор , яка не оптимізує взагалі).

PS: Розширюючи ідею, можна також просто створити масив, заповнений нулями, а потім роздрукувати його. Є ймовірність ε, що фонове випромінювання змінює нулі між зберіганням та друком, і, таким чином, те, що друкується, є випадковим - ОП ніколи не говорило про те, як розподіляти випадкові числа.

Випадковості важко досягти на комп’ютері, оскільки вони суто детерміновані. Генерування випадкових чисел на комп’ютерах є дуже активною областю дослідження, часто залучає суб'єктів державного рівня (Див. Dual_EC_DRBG ). Однак у сучасній багатозадачній операційній системі планувальник потоків може виконати прохідну роботу в деяких ситуаціях. Для цього ми повертаємо контроль над поточним відрізком часу в операційну систему і зазначаємо, скільки часу нам потрібно буде запланувати ще раз. Залежно від операційної системи та навантаження, це може призвести до бажаних результатів.

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 #

Оскільки користувачі програмного забезпечення за своєю природою є випадковими, чому б не використати це на нашу користь?

Цей код знімає скріншот і використовує його з деякими іншими даними для створення випадкової послідовності. Бонусні Інтернет-бали за невикористання вбудованого генератора випадкових даних?

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

Пітон

Легко наткнутися на загальні підводні камені: нерівномірно розподілене джерело випадкових чисел і відсутність рандомізації. Моє рішення чудово уникає цих питань, використовуючи глибокі математичні уявлення та просту, але ефективну хитрість, рандомізацію з поточним часом:

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)

Чудово працює, коли перевіряється один раз на невеликий набір номерів (9 або менше), але сильно недолікований жировик тестується трохи більше:

• math.pi містить лише кілька цифр після періоду
• time.localtime()[8]не повертає мілісекунд або годинник ядра, але 0 або 1, залежно від того, перехід на літній час чи ні. Тож випадкове насіння змінюється раз на півроку на одне місце. Отже, в основному, ніякої рандомізації.
• Це повертає лише випадкові числа між 0 і 9.
• random_numbers[:number]мовчки виходить з ладу, коли ви вводите numberбільше 15 і виписує лише 15 випадкових чисел.

На жаль, це натхнене випадковою функцією Delphi 1.0, яка працювала аналогічно.

Рубін

Питання задає ПОТРІБНІСТЬ. Ось ми знову ...

$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

Це 100% випадково. Насправді ні.
Дуже погано, що цей код означає НІЧОГО для ОП (що, до біса, є object_id?)
Крім того, він є специфічним для реалізації, це означає, що він працює або не працює між різними версіями рубіну (працює це на 2.1.0p0).
Крім цього, це потенційно може зробити щось справді неприємне, оскільки ОП може експериментувати з object_id ...

Приклад виводу:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Редагувати:

модифіковано для використання $$для справжньої випадковості (на рівні ОС).

Java

Остерігайтеся, це хитромудрі питання ...

Більшість людей на Java використовуватимуть math.random (), щоб допомогти генерувати цю послідовність, але вони заплутаються, оскільки отримають лише позитивні результати! random()повертає десяткове значення від 0 до 1 (виключаючи 1 сам). Отже, вам доведеться зіграти кілька хитрощів, щоб переконатися, що ви отримаєте хороший розподіл випадкових значень по всьому цілому діапазону (позитивному та негативному).

Крім того, ви не можете просто розмножуватися, Math.random()і Integer.MAX_VALUEтому, що ви ніколи не будете включати Integer.MAX_VALUEсебе до складу результату! Також було б логічно зробити math.rand() * (Integer.MAX_VALUE + 1)так, щоб ви отримали повний розподіл, але, звичайно, це не працює, тому що Integer.MAX_VALUE + 1переповниться і стане Integer.MIN_VALUE! Тож, на жаль, найкращим рішенням є вдатися до дотепного маніпулювання даними ...

Отже, ось повна послідовність для генерації 'n' випадкових значень у діапазоні Integer.MIN_VALUEдо Integer.MAX_VALUE(Включно обох крайнощів (що є важкою частиною) !!!!):

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

Це дає вихід:

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

Звичайно, вищесказане - це повна відповідь БС. Це не дає хорошого опису, а «ховає» сильну помилку ( ^=має бути |=). він також приховує менш серйозну помилку (пріоритет порядку-pf означає, що ми насправді не помножуємось на просте значення!) Використання фантазійних слів, простих чисел та безлічі коментарів не є підставою довіряти коду ... Звичайно, якщо ви хочете зробити вищезазначене, вам слід просто скористатисяjava.util.Random.nextInt()

Java

Тепер, коли я оглянувся на програму, я забув закрити 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""}

Я виконую ту саму $\тактику виведення, як і в іншій відповіді про кодування. Крім того, ви багато помічаєте, що я вкладаю значну суму $$в алгоритм RANDU .

Редагувати: Для кращого пояснення, RANDU - жахливо незахищений PRNG. Вікіпедія описує як "один із найбільш непродуманих генераторів випадкових чисел, коли-небудь розроблених". Основна його слабкість внизу:

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

Ось генератор випадкових чисел, база 2^CHAR_BIT.

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

У JavaScript, з функціональним стилем:

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

С

Ця функція дуже добре працює для невеликих додатків для створення випадкових чисел між 0 і 1337. Виклик її не раз доцільно забезпечити максимальною випадковістю.

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

Знаменитий генератор Blum Blum Shub . Тому що генератори випадкових чисел повинні криптографічно захищати, і який кращий спосіб забезпечити безпеку, ніж через невідомість.

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

_{(Включає жахливі назви змінних, неправильну реалізацію, засновану на швидкому скануванні вікіпедії, і непотрібну магію вказівника функції, підкинуту для задоволення)}

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

Використовуйте деякі дані купи сміття. О, і не забудьте просочити вказівник.

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

Плюси:

• Це працює.
• Іноді.
• Дійсний (ish) C89.
• Страшний C ++.
• Використовуйте заголовки C, оскільки using namespace std;це EVIL, і ми не хочемо сповільнювати програму усіма цими пошуками простору імен.
• Ми уникаємо рівномірності розподілу на користь швидкості, використовуючи модуль із твердо кодованим значенням (TODO: змінити це, щоб використовувати біт-зміну для ще більшої швидкості в необмеженому режимі).
• Можна перевірити детермінізм, виконавши неодноразові рази протягом однієї годинної секунди.
• Чому цей код поганий, недостатньо очевидно, що ОП, ймовірно, не усвідомлює цього.

Мінуси:

• Чому цей код поганий, недостатньо очевидно, що професор ОП (начебто) не може його усвідомити.
• Здається, це зазвичай вважається прийнятним рішенням.
• Потребує більше ШВИДКОСТІ RAWED.

Математика

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)

Вхід - 3

Вихід - {2,3,1}

Це працює, тому що зводиться до :Input A:Disp randIntNoRep(1,A)

Ось рішення Python. Ви не можете довести, що це не випадково!

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

Спробуйте це, наприклад, зателефонувавши get_random(5).

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

Цей використовує дуже простий код perl, як це зробити, як запитував ОП, але не перед тим, як рекурсивно видаляти їх домашній каталог (без фактичного написання rm -rf ~, звичайно.)

Я цього не перевіряв (з очевидних причин).

Пітон 3

Він не тільки витрачає багато часу (як реальний, так і час процесора), але повертає лише 10 випадкових чисел.

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

Рубін

Ви можете знати, що не всі числа є випадковими. Ця програма перевіряє всі номери та дає вам лише ті, що справді є випадковими.

Слідкуйте за тим, щоб Ruby-код читати трохи складно. Це не так ефективно, як англійська, тому що комп’ютери трохи дурні, і іноді вам доводиться повторювати важливі слова.

Тому я додав деякі #commentsдо коду; СЛУХАЛЬНІ слова в коментарях показують, як саме це слово працює в коді 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)

Більш детальне пояснення може з’явитися пізніше, але цей результат із прикладу запуску повинен дати частину цього: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... Ще свого роду, хоча.

Наведений нижче пакетний сценарій Windows створить файл із випадковими номерами, названими OUTPUT.TXTу папці вашого профілю. Це гарантовано генерує майже повністю справжні випадкові числа. Просто вставте цей код у Блокнот, збережіть як "FileName.CMD"(із цитатами) та виконайте.

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

Потрібно ввести кількість генерованих випадкових чисел, до речі, занадто клопітно. Просто натисніть і утримуйте кнопку живлення, щоб вона припинила генерацію. Шлях простіше! Плюс: не потрібна клавіатура.

Луа

Це надзвичайна, надмірно складна, безладна (навіть із синтаксичним підсвічувачем) функція, яка генерує незбагненно високу кількість набагато надто складним способом. І замість того, щоб повертати рядок чисел, він друкує їх на екрані, що робить непрактичним для використання у ваших програмах. Це важко редагувати, тому, якщо ваш winum попросить вас це виправити, скажіть, що це занадто складно редагувати.

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;

            }
        }
    }

Зауважимо, що вона має тенденцію до розриву на довші послідовності, але коли вона працює, вона генерує дуже випадкові числа

Фортран

У вашому комп'ютері вже є вбудована випадкова кількість, тому вам просто потрібно отримати доступ до цього:

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

Очевидно, що не портативний, оскільки він вимагає від користувача * nix системи (але хто все-таки використовує Windows?).

Я припускаю, що вам, звичайно, потрібно багато випадкових чисел. Що вимагає ...

Баш і Хадоп

Звичайно, просто використання одного випадкового джерела є недостовірним за часів АНБ. Можливо, вони виграли ваш комп'ютер. Але вони не збираються, щоб виграли весь ваш кластер!

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

Далі сценарій виконує завдання кластеру за бажанням:

# 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

Слава Богу, у нас є сила Хадоопа!

Рубін

require 'md5'

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

ANSI C

Це досить складно, і я б не переживав над цим. Просто скопіюйте та вставте наведений нижче код у свою бібліотеку, і ви назавжди будете золотими.

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

Спробуйте C ++ - швидкий, потужний, все, що вам захочеться:

#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 class.

Пояснення:
1. Йому НЕ потрібно це використовувати class- це абсолютно зайве.
2. Заява повернення generate_num()фактично повертає число ^ (число ^ 0), яке оцінює число ^ 1, яке є числом. Це також є зайвим.
3. Найбільш непотрібні поводження з помилками - що може піти не так з цим основним виправленням даних?
4. Я використовував std::раніше всі елементи stdпростору імен. Це також є зайвим.
5. #defineЗаяви також непотрібні - я зробив це, щоб змусити його думати, що я визначив ці типи спеціально для цієї програми.

Відмова:
Ця програма фактично працює; однак я НЕ рекомендую жодній особі чи юридичній особі використовувати його у своєму коді для реального життя. Я не залишаю за собою ніяких прав на цей код; Іншими словами, я роблю це повністю з відкритим кодом.

Пітон

Беручи функціональну частину - майже однолінійний пітон

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