เลือกองค์ประกอบสุ่มจากชุด

ฉันจะเลือกองค์ประกอบแบบสุ่มจากชุดได้อย่างไร ฉันสนใจเป็นพิเศษในการเลือกองค์ประกอบแบบสุ่มจาก HashSet หรือ LinkedHashSet ใน Java โซลูชั่นสำหรับภาษาอื่น ๆ ก็ยินดีต้อนรับ

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: [องค์ประกอบ -> ดัชนี]

แรงจูงใจ: ฉันต้องการชุดของรายการที่มี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();
    }
}

นี่เร็วกว่าลูปสำหรับแต่ละลูปในคำตอบที่ยอมรับ:

int index = rand.nextInt(set.size());
Iterator<Object> iter = set.iterator();
for (int i = 0; i < index; i++) {
    iter.next();
}
return iter.next();

การสร้างสำหรับแต่ละสายIterator.hasNext()บนทุกวง แต่ตั้งแต่index < set.size()ตรวจสอบนั้นไม่จำเป็นต้องมีค่าใช้จ่าย ฉันเห็นความเร็วเพิ่มขึ้น 10-20% แต่ YMMV (นอกจากนี้ยังรวบรวมโดยไม่ต้องเพิ่มคำสั่งคืนพิเศษ)

โปรดทราบว่ารหัสนี้ (และคำตอบอื่น ๆ ส่วนใหญ่) สามารถนำไปใช้กับคอลเลกชันใด ๆ ไม่เพียง แต่ตั้งค่า ในรูปแบบวิธีการทั่วไป:

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 (n) แทนที่จะเป็น O (1)) [ed: การคัดลอกรายการยังเป็น O (n)]

หรือคุณอาจค้นหาการติดตั้งชุดอื่นที่ตรงกับความต้องการของคุณมากขึ้น ListOrderedSetจากคอมมอนส์คอลเลกชันดูแนวโน้ม

ใน Java 8:

static <E> E getRandomSetElement(Set<E> set) {
    return set.stream().skip(new Random().nextInt(set.size())).findFirst().orElse(null);
}

ใน 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);

นี้เป็นเหมือนการยอมรับคำตอบ (Khoth) แต่ด้วยความที่ไม่จำเป็นsizeและiตัวแปรลบออก

    int random = new Random().nextInt(myhashSet.size());
    for(Object obj : myhashSet) {
        if (random-- == 0) {
            return obj;
        }
    }

แม้ว่าการทำไปกับตัวแปรทั้งสองข้างต้นวิธีการแก้ปัญหาข้างต้นยังคงสุ่มเพราะเราอาศัยการสุ่ม (เริ่มต้นที่ดัชนีสุ่มเลือก) เพื่อลดตัวเองไป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]};

นี่คือวิธีหนึ่งในการทำ

C ++ สิ่งนี้ควรจะเร็วพอสมควรเนื่องจากไม่ต้องวนซ้ำทั้งชุดหรือจัดเรียง นี้จะทำงานออกจากกล่องกับคอมไพเลอร์ที่ทันสมัยที่สุดสมมติว่าพวกเขาสนับสนุนtr1 ถ้าไม่คุณอาจต้องใช้ Boost

เอกสาร Boostจะเป็นประโยชน์ที่นี่เพื่ออธิบายเรื่องนี้แม้ว่าคุณจะไม่ได้ใช้ Boost

เคล็ดลับคือการใช้ประโยชน์จากความจริงที่ว่าข้อมูลถูกแบ่งออกเป็นที่เก็บข้อมูลและเพื่อระบุกลุ่มที่เลือกแบบสุ่ม (ด้วยความน่าจะเป็นที่เหมาะสม) อย่างรวดเร็ว

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

โซลูชันข้างต้นพูดในรูปแบบของเวลาแฝง แต่ไม่รับประกันความน่าจะเป็นที่เท่ากันของแต่ละดัชนีที่ถูกเลือก
หากจำเป็นต้องพิจารณาให้ลองสุ่มตัวอย่างอ่างเก็บน้ำ http://en.wikipedia.org/wiki/Reservoir_sampling
Collections.shuffle () (ตามที่แนะนำโดยบางคน) ใช้หนึ่งอัลกอริทึมดังกล่าว

เนื่องจากคุณกล่าวว่า "ยินดีต้อนรับโซลูชันภาษาอื่น ๆ ด้วย" นี่เป็นเวอร์ชั่นสำหรับ Python:

>>> import random
>>> random.choice([1,2,3,4,5,6])
3
>>> random.choice([1,2,3,4,5,6])
4

คุณไม่สามารถรับขนาด / ความยาวของชุด / อาร์เรย์สร้างตัวเลขสุ่มระหว่าง 0 ถึงขนาด / ความยาวแล้วเรียกองค์ประกอบที่ดัชนีตรงกับตัวเลขนั้นหรือไม่ HashSet มีวิธีการขนาด. () ฉันค่อนข้างแน่ใจ

ใน psuedocode -

function randFromSet(target){
 var targetLength:uint = target.length()
 var randomIndex:uint = random(0,targetLength);
 return target[randomIndex];
}

PHP โดยสมมติว่า "set" เป็นอาร์เรย์:

$foo = array("alpha", "bravo", "charlie");
$index = array_rand($foo);
$val = $foo[$index];

ฟังก์ชั่น Mersenne Twister ดีกว่า แต่ไม่มีค่าเทียบเท่ากับ array_rand ของ MT ใน PHP

ไอคอนมีประเภทชุดและตัวดำเนินการองค์ประกอบแบบสุ่ม unary "?" ดังนั้นการแสดงออก

? set( [1, 2, 3, 4, 5] )

จะสร้างตัวเลขสุ่มระหว่าง 1 ถึง 5

การสุ่มเริ่มต้นเป็น 0 เมื่อมีการเรียกใช้โปรแกรมดังนั้นเพื่อให้ได้ผลลัพธ์ที่แตกต่างกันในการใช้งานแต่ละครั้ง randomize()

ใน 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"]);

โซลูชัน 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();

ในเสียงกระเพื่อม

(defun pick-random (set)
       (nth (random (length set)) set))

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

เป็นไงบ้าง

public static <A> A getRandomElement(Collection<A> c, Random r) {
  return new ArrayList<A>(c).get(r.nextInt(c.size()));
}

เพื่อความสนุกสนานฉันเขียน 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;
        }
    }
}

Java 8 ที่ง่ายที่สุดคือ:

outbound.stream().skip(n % outbound.size()).findFirst().get()

โดยที่nเป็นจำนวนเต็มแบบสุ่ม แน่นอนว่ามันมีประสิทธิภาพที่ต่ำกว่าด้วยfor(elem: Col)

ด้วย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);
}

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

คุณยังสามารถถ่ายโอนชุดไปยังอาร์เรย์ใช้อาร์เรย์มันอาจจะทำงานในขนาดเล็กฉันเห็นการวนรอบในคำตอบโหวตมากที่สุดคือ O (n) ต่อไป

Object[] arr = set.toArray();

int v = (int) arr[rnd.nextInt(arr.length)];

หากคุณเพียงแค่ต้องการเลือกวัตถุ "ใด ๆ " จากSet, โดยไม่มีการรับประกันใด ๆ เกี่ยวกับการสุ่ม, วิธีที่ง่ายที่สุดคือการส่งคืนโดย iterator เป็นครั้งแรก

    Set<Integer> s = ...
    Iterator<Integer> it = s.iterator();
    if(it.hasNext()){
        Integer i = it.next();
        // i is a "random" object from 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;
}

น่าเสียดายที่สิ่งนี้ไม่สามารถทำได้อย่างมีประสิทธิภาพ (ดีกว่า 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 __name__ == '__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] เป็นเอาต์พุตดังนั้นการกระจายจึงดี

ฉันได้ต่อสู้กับปัญหาเดียวกันสำหรับตัวเองและฉันยังไม่ได้ตัดสินใจว่าสภาพอากาศการเพิ่มประสิทธิภาพของตัวเลือกที่มีประสิทธิภาพมากขึ้นนั้นคุ้มค่ากับค่าใช้จ่ายในการใช้คอลเล็กชั่นจากไพ ธ อน แน่นอนว่าฉันสามารถปรับแต่งและแปลเป็น C แต่มันทำงานได้ดีเกินไปสำหรับฉันในวันนี้ :)