Tworzenie 4-cyfrowy liczb losowych przy użyciu języka Java bez powtarzania w cyfr

Question

Napisałem kod za pomocą Java do tworzenia losowy numer 4-cyfrowy bez powtarzania cyfr, kod pisałem podano poniżej: -

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

tutaj są przypadki testowe (generowane z System.out.println(R1+""+R2+""+R3+""+R4);) są następujące: -

| 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 

teraz moje pytanie jej Chodzi o to, że jeśli jest jakiś lepszy sposób na zrobienie tego. Czy mógłbym w jakiś sposób go ulepszyć?

Answer 1

Utwórz listę liczb całkowitych od 0 do 9, przetasować je i wyodrębnić pierwszą 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); 
} 

Jest jakiś brzydki ciąg do int rozmowy dzieje, ale masz pomysł. W zależności od przypadku użycia możesz zobaczyć, co jest potrzebne.

Answer 2

Użyj zestawu może?

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

Answer 3

Kilka podejść:

1. Użyj Set trzymać cyfry i dodajemy losowe cyfry aż zestaw zawiera cztery wartości w nim.

2. Utwórz tablicę z wartościami 0-9. Przetasuj tablicę i wykonaj pierwsze cztery wartości.

Jeśli wydajność ma znaczenie, spróbuj zastosować kilka różnych metod i sprawdzić, która z nich jest szybsza.

Answer 4

Tworzenie listy z całkowitą od 0 do 9 (czyli 10 sztuk w sumie)

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

Answer 5

Oto moje rozwiązanie bez użycia dodatkowego strukturę danych, pętli na generowanie liczb losowych aż posiada unikalne cyfr.

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

Oto moje podejście, choć wykorzystuje wiele strun parsowania ale nie struktury danych:

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

grubsza (nie testowane):

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

(po kodowaniu to ja zdałem sobie sprawę, że operacje przyrostowe muszą być wykonane modulo 10.)