जावा

Question

में एक सूची से कई यादृच्छिक तत्वों उठाओ

तो कहते हैं कि मैं

List<String> teamList = new LinkedList<String>() 
teamList.add("team1"); 
teamList.add("team2"); 
teamList.add("team3"); 
teamList.add("team4"); 
teamList.add("team5"); 
teamList.add("team6"); 

है वहाँ उठा का एक आसान तरीका है ... कहते हैं 3 बाहर एक ही उठा के बिना एक यादृच्छिक तरह से इस सूची में 6 तत्वों तत्व दो बार (या अधिक बार)?

Answer 1

इस प्रयास करें (जाहिर है, आप यहाँ ArrayList उपयोग करना चाहते हैं):

public static List<String> pickNRandom(List<String> lst, int n) { 
    List<String> copy = new LinkedList<String>(lst); 
    Collections.shuffle(copy); 
    return copy.subList(0, n); 
} 

मैं यह सोचते हैं रहा हूँ इनपुट सूची में कोई दोहराया तत्वों देखते हैं कि, यह भी मैं सावधानी बरतते हैं मूल सूची को छोड़ने के लिए एक प्रतिलिपि बनाने के लिए। इसे इस तरह कहा जाता है:

List<String> randomPicks = pickNRandom(teamList, 3); 

Answer 2

उपयोग

Collections.shuffle(teamList); 

सूची randomize करने के लिए, तो टीमों के माध्यम से teamList.remove(0);

सूची से एक समय में एक को दूर उदाहरण के लिए:

List<String> teamList = new LinkedList<String>(); 
    teamList.add("team1"); 
    teamList.add("team2"); 
    teamList.add("team3"); 
    teamList.add("team4"); 
    teamList.add("team5"); 
    teamList.add("team6"); 

    java.util.Collections.shuffle(teamList); 

    String[] chosen3 = new String[3]; 
    for (int i = 0; i < chosen3.length && teamList.size() > 0; i++) { 
    chosen3[i] = teamList.remove(0); 
    } 

Answer 3

ints का एक सेट बनाएँ, और एक लूप में 0 और सूची की लंबाई के बीच यादृच्छिक संख्याओं को एक में रखें, जबकि सेट का आकार यादृच्छिक तत्वों की वांछित संख्या के बराबर नहीं है। सेट के माध्यम से जाएं, और सूची में संख्याओं द्वारा इंगित सूची तत्वों को चुनें। इस तरह आपकी मूल सूची बरकरार रहेगी।

Answer 4

shuffle दृष्टिकोण सबसे बेवकूफ है: उसके बाद, पहले के तत्व बिल्कुल वही हैं जो आपको चाहिए।

यदि के सूची की लंबाई से बहुत कम है, तो आप तेजी से बनना चाहेंगे। इस मामले में, सूची के माध्यम से पुन: चालू करें, वर्तमान तत्व को यादृच्छिक रूप से अपने या उसके बाद के तत्वों के साथ आदान-प्रदान करें। के-वें तत्व के बाद, के-उपसर्ग को रोकें और वापस करें: यह पहले से ही पूरी तरह से शफल हो जाएगा, और आपको बाकी सूची के बारे में परवाह करने की आवश्यकता नहीं है।

Answer 5

सभी अच्छे विचार लेकिन शफलिंग महंगा है। अधिक कुशल विधि (आईएमओ) एक गिनती नियंत्रित पाश कर रही है और 0 और एन के बीच यादृच्छिक int चुन रही है; जहां शुरुआत में आपकी सूची की लंबाई के बराबर है।

लूप के प्रत्येक पुनरावृत्ति में आप चयनित आइटम को सूची में एन -1 पर आइटम के साथ स्वैप करते हैं और एक से कमी करते हैं। इस तरह आप एक ही तत्व को दो बार चुनने से बचते हैं और चयनित वस्तुओं की एक अलग सूची नहीं रखना है।

Answer 6

आप reservoir sampling का भी उपयोग कर सकते हैं।

यह लाभ है कि आपको पहले से ही स्रोत सूची के आकार को जानने की आवश्यकता नहीं है (उदाहरण के लिए यदि आपको List के बजाय Iterable दिया गया है।) यह भी कुशल है जब स्रोत सूची यादृच्छिक नहीं है- आपके उदाहरण में LinkedList की तरह पहुंच।

Answer 7

यहाँ, का उपयोग कर जावा धाराओं यह करने का एक तरीका है मूल सूची की एक प्रति बनाने के लिए हो रही है या यह फेरबदल के बिना:

public static List<String> pickRandom(List<String> list, int n) { 
    if (n > list.size()) { 
     throw new IllegalArgumentException("not enough elements"); 
    } 
    Random random = new Random(); 
    return IntStream 
      .generate(() -> random.nextInt(list.size())) 
      .distinct() 
      .limit(n) 
      .mapToObj(list::get) 
      .collect(Collectors.toList()); 
} 

ध्यान दें: यह अक्षम हो सकता है जब n भी सूची के करीब है विशाल सूचियों के लिए आकार।

Answer 8

int[] getRandoms(int[] ranges, int n, int[] excepts) { 
    int min = ranges[0]; 
    int max = ranges[1]; 

    int[] results = new int[n]; 
    for (int i = 0; i < n; i++) { 
     int randomValue = new Random().nextInt(max - min + 1) + min; 
     if (ArrayUtils.contains(results, randomValue) || ArrayUtils.contains(excepts, randomValue)) { 
      i--; 
     } else { 
      results[i] = randomValue; 
     } 
    } 
    return results; 
} 

util वर्ग

public static class ArrayUtils { 

    public static boolean contains(int[] array, int elem) { 
     return getArrayIndex(array, elem) != -1; 
    } 

    /** Return the index of {@code needle} in the {@code array}, or else {@code -1} */ 
    public static int getArrayIndex(int[] array, int needle) { 
     if (array == null) { 
      return -1; 
     } 
     for (int i = 0; i < array.length; ++i) { 
      if (array[i] == needle) { 
       return i; 
      } 
     } 
     return -1; 
    } 
} 

का उपयोग कर

int[] randomPositions = getRandoms(new int[]{0,list.size()-1}, 3, new int[]{0,1}); 

यह आइटम 0 और मद 1