セットからランダムな要素を選ぶ
セットからランダムな要素を選択するにはどうすればよいですか？ JavaのHashSetまたはLinkedHashSetからランダムな要素を選択することに特に興味があります。他の言語のソリューションも歓迎します。
int size = myHashSet.size();
int item = new Random().nextInt(size); // In real life, the Random object should be rather more shared than this
int i = 0;
for(Object obj : myhashSet)
{
if (i == item)
return obj;
i++;
}
やや関連するご存知ですか：
Java.util.Collections にはコレクション全体をシャッフルするための便利なメソッドがあります： Collections.shuffle(List<?>) および Collections.shuffle(List<?> list, Random rnd) 。
Javaの高速ソリューションは、ArrayListおよびHashMapを使用して：[element-> index]。
動機：RandomAccessプロパティを持つアイテムのセットが必要でした。特に、セットからランダムなアイテムを選択するには（pollRandomメソッドを参照）。バイナリツリーでのランダムナビゲーションは正確ではありません。ツリーは完全にバランスが取れておらず、均一な分布にはなりません。
public class RandomSet<E> extends AbstractSet<E> {
List<E> dta = new ArrayList<E>();
Map<E, Integer> idx = new HashMap<E, Integer>();
public RandomSet() {
}
public RandomSet(Collection<E> items) {
for (E item : items) {
idx.put(item, dta.size());
dta.add(item);
}
}
@Override
public boolean add(E item) {
if (idx.containsKey(item)) {
return false;
}
idx.put(item, dta.size());
dta.add(item);
return true;
}
/**
* Override element at position <code>id</code> with last element.
* @param id
*/
public E removeAt(int id) {
if (id >= dta.size()) {
return null;
}
E res = dta.get(id);
idx.remove(res);
E last = dta.remove(dta.size() - 1);
// skip filling the hole if last is removed
if (id < dta.size()) {
idx.put(last, id);
dta.set(id, last);
}
return res;
}
@Override
public boolean remove(Object item) {
@SuppressWarnings(value = "element-type-mismatch")
Integer id = idx.get(item);
if (id == null) {
return false;
}
removeAt(id);
return true;
}
public E get(int i) {
return dta.get(i);
}
public E pollRandom(Random rnd) {
if (dta.isEmpty()) {
return null;
}
int id = rnd.nextInt(dta.size());
return removeAt(id);
}
@Override
public int size() {
return dta.size();
}
@Override
public Iterator<E> iterator() {
return dta.iterator();
}
}
これは、受け入れられた回答のfor-eachループよりも高速です。
int index = Rand.nextInt(set.size());
Iterator<Object> iter = set.iterator();
for (int i = 0; i < index; i++) {
iter.next();
}
return iter.next();
For-each構文は、すべてのループでIterator.hasNext()を呼び出しますが、index < set.size()なので、このチェックは不要なオーバーヘッドです。速度は10〜20％向上しましたが、YMMVは向上しました。 （また、これは余分なreturnステートメントを追加することなくコンパイルします。）
このコード（および他のほとんどの回答）は、セットだけでなく、任意のコレクションに適用できることに注意してください。汎用メソッド形式：
public static <E> E choice(Collection<? extends E> coll, Random Rand) {
if (coll.size() == 0) {
return null; // or throw IAE, if you prefer
}
int index = Rand.nextInt(coll.size());
if (coll instanceof List) { // optimization
return ((List<? extends E>) coll).get(index);
} else {
Iterator<? extends E> iter = coll.iterator();
for (int i = 0; i < index; i++) {
iter.next();
}
return iter.next();
}
}
Javaで実行する場合は、要素を何らかの種類のランダムアクセスコレクション（ArrayListなど）にコピーすることを検討する必要があります。セットが小さい場合を除き、選択した要素へのアクセスは負荷が高くなります（O（1）ではなくO（n））。 [ed：リストのコピーもO（n）]
または、要件にさらに近い別のSet実装を探すこともできます。 Commons Collectionsの ListOrderedSet は有望に見えます。
Javaの場合
Set<Integer> set = new LinkedHashSet<Integer>(3);
set.add(1);
set.add(2);
set.add(3);
Random Rand = new Random(System.currentTimeMillis());
int[] setArray = (int[]) set.toArray();
for (int i = 0; i < 10; ++i) {
System.out.println(setArray[Rand.nextInt(set.size())]);
}
List asList = new ArrayList(mySet);
Collections.shuffle(asList);
return asList.get(0);
Clojureソリューション：
(defn pick-random [set] (let [sq (seq set)] (nth sq (Rand-int (count sq)))))
Perl 5
@hash_keys = (keys %hash);
$Rand = int(Rand(@hash_keys));
print $hash{$hash_keys[$Rand]};
これを行う1つの方法を次に示します。
上記のソリューションはレイテンシの観点から言えますが、各インデックスが選択される確率が等しいことを保証するものではありません。
それを考慮する必要がある場合は、リザーバーサンプリングを試してください。 http://en.wikipedia.org/wiki/Reservoir_sampling 。
Collections.shuffle（）（少数で示唆されているように）は、そのようなアルゴリズムの1つを使用します。
C++。セット全体を繰り返し処理したり、並べ替えたりする必要がないため、これはかなり速いはずです。 tr1 をサポートしていると仮定すると、これはほとんどの最新のコンパイラですぐに動作するはずです。そうでない場合は、Boostを使用する必要があります。
Boost docs は、Boostを使用しない場合でも、これを説明するのに役立ちます。
秘Theは、データがバケットに分割されているという事実を利用し、ランダムに選択されたバケットを（適切な確率で）迅速に識別することです。
//#include <boost/unordered_set.hpp>
//using namespace boost;
#include <tr1/unordered_set>
using namespace std::tr1;
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
int main() {
unordered_set<int> u;
u.max_load_factor(40);
for (int i=0; i<40; i++) {
u.insert(i);
cout << ' ' << i;
}
cout << endl;
cout << "Number of buckets: " << u.bucket_count() << endl;
for(size_t b=0; b<u.bucket_count(); b++)
cout << "Bucket " << b << " has " << u.bucket_size(b) << " elements. " << endl;
for(size_t i=0; i<20; i++) {
size_t x = Rand() % u.size();
cout << "we'll quickly get the " << x << "th item in the unordered set. ";
size_t b;
for(b=0; b<u.bucket_count(); b++) {
if(x < u.bucket_size(b)) {
break;
} else
x -= u.bucket_size(b);
}
cout << "it'll be in the " << b << "th bucket at offset " << x << ". ";
unordered_set<int>::const_local_iterator l = u.begin(b);
while(x>0) {
l++;
assert(l!=u.end(b));
x--;
}
cout << "random item is " << *l << ". ";
cout << endl;
}
}
Java 8の場合：
static <E> E getRandomSetElement(Set<E> set) {
return set.stream().skip(new Random().nextInt(set.size())).findFirst().orElse(null);
}
これは受け入れられた回答（Khoth）と同じですが、不要なsizeおよびi変数が削除されています。
int random = new Random().nextInt(myhashSet.size());
for(Object obj : myhashSet) {
if (random-- == 0) {
return obj;
}
}
前述の2つの変数を廃止しましたが、上記のソリューションはランダム（ランダムに選択されたインデックスから開始）に依存しているため、各反復で0に向かって減少します。
どうですか
public static <A> A getRandomElement(Collection<A> c, Random r) {
return new ArrayList<A>(c).get(r.nextInt(c.size()));
}
Icon には、セット型とランダム要素演算子、単項「？」があるため、式
? set( [1, 2, 3, 4, 5] )
1〜5の乱数を生成します。
ランダムシードはプログラムの実行時に0に初期化されるため、実行ごとに異なる結果を生成するにはrandomize()を使用します
「他の言語のソリューションも歓迎します」と言ったので、Pythonのバージョンは次のとおりです。
>>> import random
>>> random.choice([1,2,3,4,5,6])
3
>>> random.choice([1,2,3,4,5,6])
4
セット/配列のサイズ/長さを取得し、0とサイズ/長さの間の乱数を生成してから、その番号に一致するインデックスを持つ要素を呼び出すことはできませんか？ HashSetには.size（）メソッドがあります。
擬似コードで-
function randFromSet(target){
var targetLength:uint = target.length()
var randomIndex:uint = random(0,targetLength);
return target[randomIndex];
}
Mathematicaの場合：
a = {1, 2, 3, 4, 5}
a[[ ⌈ Length[a] Random[] ⌉ ]]
または、最近のバージョンでは、単純に：
RandomChoice[a]
おそらく説明がないため、これは下票を受け取ったので、ここにあります：
Random[]は、0〜1の擬似乱数フロートを生成します。これにリストの長さを掛けてから、天井関数を使用して次の整数に切り上げます。このインデックスは、aから抽出されます。
ハッシュテーブルの機能はMathematicaのルールで頻繁に行われ、ルールはリストに保存されるため、次のように使用できます。
a = {"Badger" -> 5, "Bird" -> 1, "Fox" -> 3, "Frog" -> 2, "Wolf" -> 4};
PHP、「セット」が配列であると仮定します。
$foo = array("alpha", "bravo", "charlie");
$index = array_Rand($foo);
$val = $foo[$index];
Mersenne Twister関数は優れていますが、PHPにはarray_Randに相当するMTがありません。
Javascriptソリューション;）
function choose (set) {
return set[Math.floor(Math.random() * set.length)];
}
var set = [1, 2, 3, 4], Rand = choose (set);
または、代わりに：
Array.prototype.choose = function () {
return this[Math.floor(Math.random() * this.length)];
};
[1, 2, 3, 4].choose();
C＃の場合
Random random = new Random((int)DateTime.Now.Ticks);
OrderedDictionary od = new OrderedDictionary();
od.Add("abc", 1);
od.Add("def", 2);
od.Add("ghi", 3);
od.Add("jkl", 4);
int randomIndex = random.Next(od.Count);
Console.WriteLine(od[randomIndex]);
// Can access via index or key value:
Console.WriteLine(od[1]);
Console.WriteLine(od["def"]);
残念ながら、これは効率的に実行できません（標準ライブラリセットコンテナのO(n))よりも優れています）。
これは、バイナリセットと同様にハッシュセットにランダム化された選択関数を追加するのが非常に簡単なので、奇妙です。スパースではないハッシュセットでは、ヒットするまでランダムエントリを試すことができます。バイナリツリーの場合、最大O(log2)ステップで、左または右のサブツリーからランダムに選択できます。以下のデモを実装しました：
import random
class Node:
def __init__(self, object):
self.object = object
self.value = hash(object)
self.size = 1
self.a = self.b = None
class RandomSet:
def __init__(self):
self.top = None
def add(self, object):
""" Add any hashable object to the set.
Notice: In this simple implementation you shouldn't add two
identical items. """
new = Node(object)
if not self.top: self.top = new
else: self._recursiveAdd(self.top, new)
def _recursiveAdd(self, top, new):
top.size += 1
if new.value < top.value:
if not top.a: top.a = new
else: self._recursiveAdd(top.a, new)
else:
if not top.b: top.b = new
else: self._recursiveAdd(top.b, new)
def pickRandom(self):
""" Pick a random item in O(log2) time.
Does a maximum of O(log2) calls to random as well. """
return self._recursivePickRandom(self.top)
def _recursivePickRandom(self, top):
r = random.randrange(top.size)
if r == 0: return top.object
Elif top.a and r <= top.a.size: return self._recursivePickRandom(top.a)
return self._recursivePickRandom(top.b)
if __== '__main__':
s = RandomSet()
for i in [5,3,7,1,4,6,9,2,8,0]:
s.add(i)
dists = [0]*10
for i in xrange(10000):
dists[s.pickRandom()] += 1
print dists
出力として[995、975、971、995、1057、1004、966、1052、984、1001]を取得したため、分布の継ぎ目は良好です。
私は同じ問題に苦労しましたが、このより効率的なピックのパフォーマンスの向上がpythonベースのコレクションを使用するオーバーヘッドに見合うだけの価値があるかどうか、まだ決めていません。もちろん、それを洗練してCに翻訳することもできますが、それは今日の私にはあまりにも大変な仕事です:)
LISPで
(defun pick-random (set)
(nth (random (length set)) set))
Khothの答えを出発点として使用する一般的なソリューション。
/**
* @param set a Set in which to look for a random element
* @param <T> generic type of the Set elements
* @return a random element in the Set or null if the set is empty
*/
public <T> T randomElement(Set<T> set) {
int size = set.size();
int item = random.nextInt(size);
int i = 0;
for (T obj : set) {
if (i == item) {
return obj;
}
i++;
}
return null;
}
PHP、MTを使用：
$items_array = array("alpha", "bravo", "charlie");
$last_pos = count($items_array) - 1;
$random_pos = mt_Rand(0, $last_pos);
$random_item = $items_array[$random_pos];
また、セットを配列に転送することもできます配列を使用して、おそらく小規模で動作します最も投票された答えのforループはO(n)とにかく
Object[] arr = set.toArray();
int v = (int) arr[rnd.nextInt(arr.length)];
設定サイズが大きくない場合、配列を使用してこれを行うことができます。
int random;
HashSet someSet;
<Type>[] randData;
random = new Random(System.currentTimeMillis).nextInt(someSet.size());
randData = someSet.toArray();
<Type> sResult = randData[random];
楽しみのために、拒否サンプリングに基づいてRandomHashSetを作成しました。 HashMapはテーブルに直接アクセスすることを許可しないため、少しハックしますが、正常に機能するはずです。
余分なメモリは使用せず、ルックアップ時間はO(1)で償却されます。 （Java HashTableは密集しているため）。
class RandomHashSet<V> extends AbstractSet<V> {
private Map<Object,V> map = new HashMap<>();
public boolean add(V v) {
return map.put(new WrapKey<V>(v),v) == null;
}
@Override
public Iterator<V> iterator() {
return new Iterator<V>() {
RandKey key = new RandKey();
@Override public boolean hasNext() {
return true;
}
@Override public V next() {
while (true) {
key.next();
V v = map.get(key);
if (v != null)
return v;
}
}
@Override public void remove() {
throw new NotImplementedException();
}
};
}
@Override
public int size() {
return map.size();
}
static class WrapKey<V> {
private V v;
WrapKey(V v) {
this.v = v;
}
@Override public int hashCode() {
return v.hashCode();
}
@Override public boolean equals(Object o) {
if (o instanceof RandKey)
return true;
return v.equals(o);
}
}
static class RandKey {
private Random Rand = new Random();
int key = Rand.nextInt();
public void next() {
key = Rand.nextInt();
}
@Override public int hashCode() {
return key;
}
@Override public boolean equals(Object o) {
return true;
}
}
}
Guava を使用すると、Khothの答えよりも少し良くなります。
public static E random(Set<E> set) {
int index = random.nextInt(set.size();
if (set instanceof ImmutableSet) {
// ImmutableSet.asList() is O(1), as is .get() on the returned list
return set.asList().get(index);
}
return Iterables.get(set, index);
}
ランダム性を保証せずに、本当にSetから「任意の」オブジェクトを選択したい場合、最も簡単なのは、イテレータから最初に返されたものを取得することです。
Set<Integer> s = ...
Iterator<Integer> it = s.iterator();
if(it.hasNext()){
Integer i = it.next();
// i is a "random" object from set
}
Java 8で最も簡単なのは：
outbound.stream().skip(n % outbound.size()).findFirst().get()
ここで、nはランダムな整数です。もちろん、for(elem: Col)を使用した場合よりもパフォーマンスは低下します