Creazione di un numero casuale a 4 cifre utilizzando Java con nessuna ripetizione in cifre

Question

Ho scritto un codice utilizzando Java per creare un numero di 4 cifre a caso senza ripetizione di cifre, il codice che ho scritto è il seguente: -

Random r = new Random(); 
d1 = r.nextInt(9); 
d2 = r.nextInt(9); 
d3 = r.nextInt(9); 
d4 = r.nextInt(9); 
while(d1==d2||d1==d3||d1==d4||d2==d3||d2==d4||d3==d4) 
{ 
    if(d1==d2||d2==d3||d2==d4) 
    { 
     d2 = r.nextInt(9); 
    } 
    if(d1==d3||d2==d3||d3==d4) 
    { 
     d3 = r.nextInt(9); 
    } 
    if(d1==d4||d2==d4||d3==d4) 
    { 
     d4 = r.nextInt(9); 
    } 
} 
System.out.println(d1+""+d2+""+d3+""+d4); 

qui sono i casi di test (generati da System.out.println(R1+""+R2+""+R3+""+R4);) sono i seguenti: -

| OK as required 
1234 | OK as required 
2123 | not OK because 2 is present more than one time 
9870 | OK as required 
0444 | not OK because 4 is present more than one time 

Ora la mia domanda di lei È, se c'è un modo migliore per farlo. Se potessi migliorarlo in qualche modo?

Answer 1

creare un elenco di numeri interi da 0 a 9, rimescolalo ed estrarre il primo 4.

public static void main(String[] args) { 
    List<Integer> numbers = new ArrayList<>(); 
    for(int i = 0; i < 10; i++){ 
     numbers.add(i); 
    } 

    Collections.shuffle(numbers); 

    String result = ""; 
    for(int i = 0; i < 4; i++){ 
     result += numbers.get(i).toString(); 
    } 
    System.out.println(result); 
} 

C'è un po 'int string-to-brutta conversare in corso, ma si ottiene l'idea. A seconda del tuo caso d'uso puoi vedere cosa è necessario.

Answer 2

Utilizzare un set forse?

Random r = new Random(); 
Set<Integer> s = new HashSet<Integer>(); 
while (s.size() < 4) { 
    s.add(r.nextInt(9)); 
} 

Answer 3

Un paio di approcci:

1. utilizzare un set per contenere le cifre e continuare ad aggiungere cifre casuali fino a quando l'insieme ha quattro valori in esso.

2. Creare una matrice con valori 0-9 in essa. Mescola l'array e prendi i primi quattro valori.

Se le prestazioni sono importanti, ti consigliamo di provare un paio di metodi diversi e vedere quale è più veloce.

Answer 4

creare una lista con intero da 0 a 9 (quindi 10 articoli in totale)

List<Integer> l = ... 
Collections.shuffle(l); 
d1 = l.get(0); 
d2 = l.get(1); 
d3 = l.get(2); 
d4 = l.get(3); 

Answer 5

Ecco la mia soluzione senza l'utilizzo di qualsiasi struttura di dati aggiuntivi, loop sulla generazione di numeri casuali fino a che non ha cifre uniche.

int a = 0, b = 0, c = 0, d = 0; 
int x = 0; 
while (true) { 
    x = r.nextInt(9000) + 1000; 
    a = x % 10; 
    b = (x/10) % 10; 
    c = (x/100) % 10; 
    d = x/1000; 
    if (a == b || a == c || a == d || b == c || b == d || c == d) 
     continue; 
    else 
     break; 
} 

System.out.println(x); 

Answer 6

Ecco il mio approccio, anche se si utilizza un sacco di parsing della stringa, ma nessuna struttura dati:

static int generateNumber(int length){ 
      String result = ""; 
      int random; 
      while(true){ 
       random = (int) ((Math.random() * (10))); 
       if(result.length() == 0 && random == 0){//when parsed this insures that the number doesn't start with 0 
        random+=1; 
        result+=random; 
       } 
       else if(!result.contains(Integer.toString(random))){//if my result doesn't contain the new generated digit then I add it to the result 
        result+=Integer.toString(random); 
       } 
       if(result.length()>=length){//when i reach the number of digits desired i break out of the loop and return the final result 
        break; 
       } 
      } 

      return Integer.parseInt(result); 
     } 

Answer 7

Approssimativamente (non testato):

int randomNum = r.nextInt(5040); 
int firstDigit = randomNum % 10; 
randomNum = randomNum/10; 
int secondDigit = randomNum % 9; 
randomNum = randomNum/9; 
int thirdDigit = randomNum % 8; 
randomNum = randomNum/8; 
int fourthDigit = randomNum % 7; 

if (secondDigit == firstDigit) { 
    secondDigit++; 
} 

while ((thirdDigit == firstDigit) || (thirdDigit == secondDigit)) { 
    thirdDigit++: 
} 

while ((fourthDigit == firstDigit) || (fourthDigit == secondDigit) || (fourthDigit == thirdDigit)) { 
    fourthDigit++; 
} 

(Dopo la codifica questo ho capito che le operazioni di incremento devono essere fatte modulo 10.)