Произвольно генерировать 1 и 0 в очереди

Question

Я хочу, чтобы моя программа произвольно генерировала 1 и 0, но она должна выглядеть так, как будто она находится в очереди. 1 представляет лицо, а 0 означает, что нет человека. Он должен генерировать случайные 1 и 0 как это 0 0 0 0 1 1 1 1 1 1, если строка находится слева и наоборот, если она справа, а не так 1 1 1 0 0 1 0 0 1 1.

public void randPeople(){ 
    int person1 = rand.nextInt((1 - 0) + 1) + 0; 
    int person2 = rand.nextInt((1 - 0) + 1) + 0; 
    int person3 = rand.nextInt((1 - 0) + 1) + 0; 
    int person4 = rand.nextInt((1 - 0) + 1) + 0; 
    int person5 = rand.nextInt((1 - 0) + 1) + 0; 
    int person6 = rand.nextInt((1 - 0) + 1) + 0; 
    int person7 = rand.nextInt((1 - 0) + 1) + 0; 
    int person8 = rand.nextInt((1 - 0) + 1) + 0; 
    int person9 = rand.nextInt((1 - 0) + 1) + 0; 
    int person10 = rand.nextInt((1 - 0) + 1) + 0; 

    EntryFloor1.setText(Integer.toString(person1) + " " + Integer.toString(person2) + " " + 
          Integer.toString(person3) + " " + Integer.toString(person4) + " " + 
          Integer.toString(person5) + " " + Integer.toString(person6) + " " + 
          Integer.toString(person7) + " " + Integer.toString(person8) + " " + 
          Integer.toString(person9) + " " + Integer.toString(person10)); 
} 

Answer 1

Я считаю, что это будет делать то, что вы хотите. Как побочная заметка - если вы только заботитесь о том, существует ли человек, я бы предложил использовать логические значения для представления людей. Поскольку вы специально сказали 1 и 0, я написал код ниже для создания этого вывода. Вы заметите, что я использую метод nextBoolean() класса Random, поскольку он проще и читабельнее для того, что я делаю.

import java.util.ArrayList; 
import java.util.List; 
import java.util.Random; 

public class RandPeopleMain { 

    public static void main(String[] args) { 
     System.out.println(lineUpLeft(10)); 
     System.out.println(lineUpRight(10)); 
    } 

    public static List<Integer> lineUpLeft(int numPeople){ 
     Random rand = new Random(); 
     List<Integer> list = new ArrayList<Integer>(); 

     for(int i=0; i < numPeople; i++){ 
      boolean person = rand.nextBoolean(); 
      if(person){ 
       list.add(1); 
      } 
     } 
     for(int i=list.size(); i < numPeople; i++){ 
      list.add(0); 
     } 

     return list; 
    } 

    public static List<Integer> lineUpRight(int numPeople){ 
     Random rand = new Random(); 
     List<Integer> list = new ArrayList<Integer>(); 

     for(int i=0; i < numPeople; i++){ 
      boolean person = rand.nextBoolean(); 
      if(person){ 
       list.add(1); 
      } 
     } 
     for(int i=list.size(); i < numPeople; i++){ 
      list.add(0, 0); 
     } 
     return list; 
    } 

} 

Пример вывода:

[1, 1, 1, 1, 1, 1, 0, 0, 0, 0]

[0, 0, 0, 1, 1, 1, 1, 1, 1, 1]

Я предоставил приведенные выше методы, чтобы проиллюстрировать, как аналогичное выравнивание людей слева или справа может быть. Вот более общая версия, которая использует один метод с дополнительным параметром для указания выравнивания.

public static List<Integer> lineUpPeople(int numPeople, boolean alignLeft){ 
     Random rand = new Random(); 
     List<Integer> list = new ArrayList<Integer>(); 

     for(int i=0; i < numPeople; i++){ 
      boolean person = rand.nextBoolean(); 
      if(person){ 
       list.add(1); 
      } 
     } 
     for(int i=list.size(); i < numPeople; i++){ 
      if(alignLeft) 
       list.add(0); 
      else 
       list.add(0,0); 
     } 

     return list; 
    } 

Наконец, вот еще один способ подойти к проблеме. Вместо того, чтобы генерировать случайное значение для каждого потенциального человека, просто генерируйте количество людей, а затем соответствующим образом заполните список/очередь.

public static List<Integer> lineUp(int maxPeople, boolean alignLeft){ 
     Random rand = new Random(); 
     int numPeople = rand.nextInt(maxPeople+1); 
     List<Integer> list = new ArrayList<Integer>(); 

     for(int i=0; i < maxPeople; i++){ 
      if(i < numPeople) 
       list.add(1); 
      else if(alignLeft) 
       list.add(0); 
      else 
       list.add(0,0); 
     } 
     return list; 
    } 

Answer 2

Реализован простой случайной функции для генерации 0 и 1

int[] queue = new int[10]; 
    Random r = new Random(); 
    int rand = r.nextInt(queue.length); 
    int r1 = 1 - rand % 2; 
    int r2 = rand % 2; 
    for (int i = 0; i < queue.length; i++) { 
     if (i <= rand) { 
      queue[i] = r1; 
     } else { 
      queue[i] = r2; 
     } 
    } 
    System.out.println("Queue " + Arrays.toString(queue)); 

выходные

Queue [1, 1, 1, 0, 0, 0, 0, 0, 0, 0] 

с генератором Java8

final int size = 10; 
    final Random random = new Random(); 
    boolean order = random.nextBoolean(); 
    Object[] arr = IntStream.generate(() -> random.nextInt(size) % 2).limit(size).boxed().sorted((i1, i2) -> order ? i1 - i2 : i2 - i1).toArray(); 
    System.out.println("Arrays " + Arrays.toString(arr)); 

выход

Arrays [1, 1, 1, 1, 1, 0, 0, 0, 0, 0] 

Answer 3

Попробуйте это:

Random r = new Random(); 

    boolean b = r.nextBoolean(); // left or right 
    int l = r.nextInt(11); // breakpoint to change from 0 to 1 or other way 
    System.out.println(b + " " + l); 
    int person[] = new int[10]; 
    for (int i = 0; i < 10; i++) { 
     if (b) { 
      if (i < l) 
       person[i] = 1; 
      else 
       person[i] = 0; 

     } else { 
      if (i < l) 
       person[i] = 0; 
      else 
       person[i] = 1; 
     } 
    } 
    System.out.println(Arrays.toString(person));