Raccogliere più elementi casuali da una lista in Java

Question

Quindi dire che ho

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

Esiste un modo semplice di scegliere ... diciamo 3 i 6 elementi in questa lista in modo randomizzato senza prendere lo stesso elemento due volte (o più volte)?

Answer 1

Prova questo:

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); 
} 

Sto assumendo che non vi siano elementi ripetuti nella lista di input, anche io prendo la precauzione di mischiare una copia per lasciare indisturbata la lista originale. Si chiama così:

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

Answer 2

Usa

Collections.shuffle(teamList); 

per randomizzare l'elenco, quindi rimuovere le squadre, uno alla volta dalla lista tramite teamList.remove(0);

Ad esempio:

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

creare una serie di int, e inserire numeri casuali tra 0 e la lunghezza dell'elenco meno uno in un ciclo, mentre la dimensione dell'insieme non è uguale al numero desiderato di elementi casuali. Attraversa il set e seleziona gli elementi dell'elenco come indicato dai numeri nell'insieme. In questo modo manterresti la tua lista originale intatta.

Answer 4

L'approccio shuffle è il più idiomatico: dopo di ciò, i primi elementi K sono esattamente ciò di cui avete bisogno.

Se K è molto inferiore alla lunghezza della lista, potresti voler essere più veloce. In questo caso, scorrere l'elenco, scambiando a caso l'elemento corrente con se stesso o con qualsiasi elemento dopo di esso. Dopo l'elemento K-th, fermati e restituisci il prefisso K: sarà già perfettamente mescolato e non dovrai preoccuparti del resto dell'elenco.

(ovviamente, si desidera utilizzare ArrayList qui)

Answer 5

Tutte le buone idee, ma la mischia è costosa. Il metodo più efficiente (IMO) farebbe un ciclo controllato dal conteggio e selezionerebbe un intervallo casuale compreso tra 0 e n; dove n inizialmente è uguale alla lunghezza della tua lista.

In ogni iterazione del ciclo si scambia l'elemento selezionato con l'elemento su n-1 dell'elenco e si diminuisce di uno. In questo modo eviti di selezionare lo stesso elemento due volte e non devi tenere un elenco separato di elementi selezionati.

Answer 6

È inoltre possibile utilizzare reservoir sampling.

ha il vantaggio che non è necessario conoscere la dimensione della lista sorgente in anticipo (ad esempio, se si è data un Iterable invece di un List.) Inoltre è efficace anche quando la lista sorgente non è random- accesso, come il LinkedList nel tuo esempio.

Answer 7

Ecco un modo per farlo utilizzando flussi di Java, senza dover creare una copia della lista originale o mischiare esso:

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()); 
} 

Nota: Si può diventare inefficiente quando n è troppo vicino alla lista dimensione per liste enormi.

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

classe 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; 
    } 
} 

utilizzando

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

sarà casuali 3 articoli nel proprio elenco eccetto collo 0 e la voce 1