该问题给出了所有必要的数据：在给定区间内生成 K 非重复整数序列的有效算法 [0，N-1] 。如果 K 很大且足够接近 N <，那么简单的算法（生成随机数，并在将它们添加到序列之前，查看它们是否已经存在）是非常昂贵的/ em>的
Efficiently selecting a set of random elements from a linked list中提供的算法似乎比必要的更复杂，需要一些实现。我刚刚发现了另一种似乎可以完成工作的算法，只要您知道所有相关参数，一次性完成。
答案 0 :(得分：12)
Python库中的random module使其非常简单有效：
from random import sample
print sample(xrange(N), K)
sample函数返回从给定序列中选择的K个唯一元素的列表
xrange是一个“列表模拟器”，即它的行为类似于连续数字的列表而不在内存中创建它，这使得它对于像这样的任务来说超级快。
答案 1 :(得分：12)
在The Art of Computer Programming, Volume 2: Seminumerical Algorithms, Third Edition中，Knuth描述了以下选择抽样算法：
算法S（选择抽样技术）。从一组N中随机选择n个记录，其中0 <0。 n≤N。
S1。 [初始化。]设置t←0，m←0.（在此算法中，m表示到目前为止选择的记录数，t是我们处理的输入记录总数。）
S2。 [Generate U.]生成一个随机数U，均匀分布在0和1之间。
S3。 [测试。]如果（N - t）U≥n - m，转到步骤S5。
S4。 [选择。]选择样本的下一条记录，并将m和t增加1.如果m＆lt; n，转到步骤S2;否则样本完成，算法终止。
S5。 [跳过。]跳过下一条记录（不要在示例中包含它），将t增加1，然后返回步骤S2。
实施可能比描述更容易理解。这是一个Common Lisp实现，它从列表中选择n个随机成员：
(defun sample-list (n list &optional (length (length list)) result)
(cond ((= length 0) result)
((< (* length (random 1.0)) n)
(sample-list (1- n) (cdr list) (1- length)
(cons (car list) result)))
(t (sample-list n (cdr list) (1- length) result))))
这是一个不使用递归的实现，它适用于所有类型的序列：
(defun sample (n sequence)
(let ((length (length sequence))
(result (subseq sequence 0 n)))
(loop
with m = 0
for i from 0 and u = (random 1.0)
do (when (< (* (- length i) u)
(- n m))
(setf (elt result m) (elt sequence i))
(incf m))
until (= m n))
result))
答案 2 :(得分：5)
实际上，可以在与所选元素数量成比例的空间中执行此操作，而不是您选择的集合的大小，无论您选择的总集合的比例是多少。你可以通过生成一个随机排列，然后从中选择：
选择一个分组密码，例如TEA或XTEA。使用XOR folding将块大小减小到比您选择的集合大2的最小幂。使用随机种子作为密码的密钥。要在置换中生成元素n，请使用密码对n进行加密。如果输出编号不在您的设置中，请对其进行加密。重复，直到数字在集合内。平均而言，每个生成的数量必须少于两次加密。如果你的种子在加密方面是安全的，那么你的整个排列也是如此。
我更详细地写了here。
答案 3 :(得分：3)
以下代码（在C中，未知来源）似乎可以很好地解决问题：
/* generate N sorted, non-duplicate integers in [0, max[ */
int *generate(int n, int max) {
int i, m, a;
int *g = (int *)calloc(n, sizeof(int));
if ( ! g) return 0;
m = 0;
for (i=0; i<max; i++) {
a = random_in_between(0, max - i);
if (a < n - m) {
g[m] = i;
m ++;
}
}
return g;
}
有谁知道在哪里可以找到更多像这样的宝石？
答案 4 :(得分：2)
生成一个填充0...N-1的数组a[i] = i。
然后随机播放第一个K项。
改组：
J = N-1 0...J（例如R）a[R]交换a[J]
R可以等于J，因此该元素可以自行交换1减去J并重复。最后，取K个最后元素。
这实际上从列表中选取一个随机元素，将其移出，然后从剩余列表中选择一个随机元素，依此类推。
适用于 O（K）和 O（N）时间，需要 O（N）存储。
洗牌部分称为Fisher-Yates shuffle或 Knuth's shuffle ，在计算机编程艺术的第2卷中有所描述。
答案 5 :(得分：1)
通过在散列存储中存储K个数字来加速简单算法。在开始之前了解K会消除插入哈希映射的所有低效率，并且您仍然可以获得快速查找的好处。
答案 6 :(得分：1)
我的解决方案是面向C ++的，但我确信它可以翻译成其他语言，因为它非常简单。
此解决方案仅涉及两个循环迭代，并且没有散列表查找或任何类型。所以在实际代码中：
// Assume K is the highest number in the list
std::vector<int> sorted_list;
std::vector<int> random_list;
for(int i = 0; i < K; ++i) {
sorted_list.push_back(i);
}
// Loop to K - 1 elements, as this will cause problems when trying to erase
// the first element
while(!sorted_list.size() > 1) {
int rand_index = rand() % sorted_list.size();
random_list.push_back(sorted_list.at(rand_index));
sorted_list.erase(sorted_list.begin() + rand_index);
}
// Finally push back the last remaining element to the random list
// The if() statement here is just a sanity check, in case K == 0
if(!sorted_list.empty()) {
random_list.push_back(sorted_list.at(0));
}
答案 7 :(得分：1)
第1步：生成整数列表。
第2步：执行Knuth Shuffle。
请注意，您不需要对整个列表进行随机播放，因为Knuth Shuffle算法允许您仅应用n个shuffle，其中n是要返回的元素数。生成列表仍然需要与列表大小成比例的时间，但您可以重用现有列表以满足任何未来的混乱需求（假设大小保持不变），而无需在重新启动混洗算法之前预先对部分洗牌列表进行预处理。
Knuth Shuffle的基本算法是从一个整数列表开始。然后，将第一个整数与列表中的任何数字交换，并返回当前（新的）第一个整数。然后，将第二个整数与列表中的任何数字交换（第一个除外），并返回当前（新的）第二个整数。然后...等...
这是一个非常简单的算法，但要小心，在执行交换时将当前项目包含在列表中，否则您将破坏算法。
答案 8 :(得分：0)
水库采样版非常简单：
my $N = 20;
my $k;
my @r;
while(<>) {
if(++$k <= $N) {
push @r, $_;
} elsif(rand(1) <= ($N/$k)) {
$r[rand(@r)] = $_;
}
}
print @r;
这是来自STDIN的$ N随机选择的行。如果您没有使用文件中的行，请将＆lt;＆gt; / $ _ stuff替换为其他内容，但这是一个非常简单的算法。
答案 9 :(得分：0)
如果对列表进行排序，例如，如果要从N中提取K个元素，但不关心它们的相对顺序，则在文章An Efficient Algorithm for Sequential Random Sampling中提出了一种有效的算法（Jeffrey Scott Vitter） ， ACM数学软件交易，第13卷，第1期，1987年3月，第56-67页。）。
已编辑使用boost在c ++中添加代码。我刚输入它，可能会有很多错误。随机数来自boost库，有一个愚蠢的种子，所以不要做任何严重的事情。
/* Sampling according to [Vitter87].
*
* Bibliography
* [Vitter 87]
* Jeffrey Scott Vitter,
* An Efficient Algorithm for Sequential Random Sampling
* ACM Transactions on MAthematical Software, 13 (1), 58 (1987).
*/
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string>
#include <iostream>
#include <iomanip>
#include <boost/random/linear_congruential.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/random/uniform_real.hpp>
using namespace std;
// This is a typedef for a random number generator.
// Try boost::mt19937 or boost::ecuyer1988 instead of boost::minstd_rand
typedef boost::minstd_rand base_generator_type;
// Define a random number generator and initialize it with a reproducible
// seed.
// (The seed is unsigned, otherwise the wrong overload may be selected
// when using mt19937 as the base_generator_type.)
base_generator_type generator(0xBB84u);
//TODO : change the seed above !
// Defines the suitable uniform ditribution.
boost::uniform_real<> uni_dist(0,1);
boost::variate_generator<base_generator_type&, boost::uniform_real<> > uni(generator, uni_dist);
void SequentialSamplesMethodA(int K, int N)
// Outputs K sorted random integers out of 0..N, taken according to
// [Vitter87], method A.
{
int top=N-K, S, curr=0, currsample=-1;
double Nreal=N, quot=1., V;
while (K>=2)
{
V=uni();
S=0;
quot=top/Nreal;
while (quot > V)
{
S++; top--; Nreal--;
quot *= top/Nreal;
}
currsample+=1+S;
cout << curr << " : " << currsample << "\n";
Nreal--; K--;curr++;
}
// special case K=1 to avoid overflow
S=floor(round(Nreal)*uni());
currsample+=1+S;
cout << curr << " : " << currsample << "\n";
}
void SequentialSamplesMethodD(int K, int N)
// Outputs K sorted random integers out of 0..N, taken according to
// [Vitter87], method D.
{
const int negalphainv=-13; //between -20 and -7 according to [Vitter87]
//optimized for an implementation in 1987 !!!
int curr=0, currsample=0;
int threshold=-negalphainv*K;
double Kreal=K, Kinv=1./Kreal, Nreal=N;
double Vprime=exp(log(uni())*Kinv);
int qu1=N+1-K; double qu1real=qu1;
double Kmin1inv, X, U, negSreal, y1, y2, top, bottom;
int S, limit;
while ((K>1)&&(threshold<N))
{
Kmin1inv=1./(Kreal-1.);
while(1)
{//Step D2: generate X and U
while(1)
{
X=Nreal*(1-Vprime);
S=floor(X);
if (S<qu1) {break;}
Vprime=exp(log(uni())*Kinv);
}
U=uni();
negSreal=-S;
//step D3: Accept ?
y1=exp(log(U*Nreal/qu1real)*Kmin1inv);
Vprime=y1*(1. - X/Nreal)*(qu1real/(negSreal+qu1real));
if (Vprime <=1.) {break;} //Accept ! Test [Vitter87](2.8) is true
//step D4 Accept ?
y2=0; top=Nreal-1.;
if (K-1 > S)
{bottom=Nreal-Kreal; limit=N-S;}
else {bottom=Nreal+negSreal-1.; limit=qu1;}
for(int t=N-1;t>=limit;t--)
{y2*=top/bottom;top--; bottom--;}
if (Nreal/(Nreal-X)>=y1*exp(log(y2)*Kmin1inv))
{//Accept !
Vprime=exp(log(uni())*Kmin1inv);
break;
}
Vprime=exp(log(uni())*Kmin1inv);
}
// Step D5: Select the (S+1)th record
currsample+=1+S;
cout << curr << " : " << currsample << "\n";
curr++;
N-=S+1; Nreal+=negSreal-1.;
K-=1; Kreal-=1; Kinv=Kmin1inv;
qu1-=S; qu1real+=negSreal;
threshold+=negalphainv;
}
if (K>1) {SequentialSamplesMethodA(K, N);}
else {
S=floor(N*Vprime);
currsample+=1+S;
cout << curr << " : " << currsample << "\n";
}
}
int main(void)
{
int Ntest=10000000, Ktest=Ntest/100;
SequentialSamplesMethodD(Ktest,Ntest);
return 0;
}
$ time ./sampling|tail
在我的笔记本电脑上提供以下ouptut
99990 : 9998882
99991 : 9998885
99992 : 9999021
99993 : 9999058
99994 : 9999339
99995 : 9999359
99996 : 9999411
99997 : 9999427
99998 : 9999584
99999 : 9999745
real 0m0.075s
user 0m0.060s
sys 0m0.000s
答案 10 :(得分：0)
这个Ruby代码展示了Reservoir Sampling, Algorithm R方法。在每个周期中，我从n=5范围中选择[0,N=10)个唯一随机整数：
t=0
m=0
N=10
n=5
s=0
distrib=Array.new(N,0)
for i in 1..500000 do
t=0
m=0
s=0
while m<n do
u=rand()
if (N-t)*u>=n-m then
t=t+1
else
distrib[s]+=1
m=m+1
t=t+1
end #if
s=s+1
end #while
if (i % 100000)==0 then puts i.to_s + ". cycle..." end
end #for
puts "--------------"
puts distrib
输出：
100000. cycle...
200000. cycle...
300000. cycle...
400000. cycle...
500000. cycle...
--------------
250272
249924
249628
249894
250193
250202
249647
249606
250600
250034
选择0-9之间的所有整数，概率几乎相同。
它基本上Knuth's algorithm应用于任意序列（事实上，该答案有一个LISP版本）。该算法及时 O（N），如果序列以@MichaelCramer's answer所示流入其中，则可以在内存中 O（1）。
答案 11 :(得分：-1)
这是一种在没有额外存储的情况下在O（N）中执行此操作的方法。我很确定这不是一个纯粹的随机分布，但它可能足够接近许多用途。
/* generate N sorted, non-duplicate integers in [0, max[ in O(N))*/
int *generate(int n, int max) {
float step,a,v=0;
int i;
int *g = (int *)calloc(n, sizeof(int));
if ( ! g) return 0;
for (i=0; i<n; i++) {
step = (max-v)/(float)(n-i);
v+ = floating_pt_random_in_between(0.0, step*2.0);
if ((int)v == g[i-1]){
v=(int)v+1; //avoid collisions
}
g[i]=v;
}
while (g[i]>max) {
g[i]=max; //fix up overflow
max=g[i--]-1;
}
return g;
}
答案 12 :(得分：-2)
这是Perl Code。 Grep是一个过滤器，我一如既往地没有测试这段代码。
@list = grep ($_ % I) == 0, (0..N);
只能通过模数运算符获得与您的间隔匹配的数字。
@list = grep ($_ % 3) == 0, (0..30);
将返回0,3,6，...... 30
这是伪Perl代码。您可能需要调整它以使其编译。