Wie kann ich zählen, wenn eine bestimmte Gruppe von Ziffern in einem Array vorhanden ist?

Question

Angenommen, ich habe eine Nummer 123. Ich muss sehen, ob ich alle Ziffern 1 bis 9, einschließlich 0, erhalten habe. Die Zahl 123 hat drei Ziffern: 1, 2, und 3. Dann multipliziere ich es mit 2 und bekomme 246 (ich bekomme die Ziffern 2, 4, 6). Dann multipliziere ich es mit 3 und ich bekomme 369. Ich mache weiter inkrementelle Multiplikation, bis ich alle Ziffern bekomme.

Mein Ansatz ist die folgende:

public int digitProcessSystem(int N) { 
String number = Integer.toString(N); 
String [] arr = number.split(""); 
// List <Integer> arr2 = new ArrayList<>(); 
for (Integer i = 0; i < arr.length; i++) { 
    try { 

     arr2[i] = Integer.parseInt(arr[i]); 
    } catch (NumberFormatException e) { 
     } 
    } 

count =0; 
boolean contains = IntStream.of(arr2).anyMatch(x -> x == 1|| x==2 ||x == 3|| x==4|| x == 5|| x==6 ||x == 7|| x==8||x == 9|| x==0); 

} 

Ich weiß wirklich nicht, wie kann ich für Ziffern tun die boolean halten, die nicht oben in der ersten Spur brachte, weil ich auf jeden Fall einem der bekommen alle Ziffern in der obigen booleschen Suche. Wie kann ich das bekommen, wenn bestimmte Ziffern vorhanden sind und manche nicht so sind, dass ich die tatsächliche Zahl multiplizieren kann, um nach den Ziffern zu suchen, die im ersten Versuch nicht gefunden wurden; genauso wie ich es am Anfang definiert habe.

Answer 1

Sie könnten das in eine while-Schleife einbinden und die Zahlen in eine Set einbinden. Sobald das Set die Größe 10 hat, sind alle Ziffern in der Nummer vorhanden. Ich schlage auch vor, eine long anstelle einer int zu verwenden, oder Sie werden falsche Ergebnisse erhalten oder in eine Exception laufen. Heres einige Beispiel-Code für diese:

private static long digitProcessSystem(long N) { 
    long numberN = N; 
    String number = Long.toString(N); 
    // calculate 10 digits number here yet 
    if (number.length() < 10) { 
     // using the smallest possible number with each digit 
     // By using this number we are most likely allmost at the result 
     // This will increase the performance for small digits heavily. 
     long divider = 1023456789L/numberN; 
     numberN *= divider; 
    } 
    number = Long.toString(numberN); 
    String[] arr = number.split(""); 
    Set<String> input = new HashSet<>(Arrays.asList(arr)); 
    while(input.size() != 10){ 
     // add N to number 
     numberN += N; 
     // Parse the new number 
     number = Long.toString(numberN); 
     // split 
     arr = number.split(""); 
     // clear set 
     input.clear(); 
     // Add the new numbers to the set. If it has the size 10 now the loop will stop and return the number. 
     input.addAll(Arrays.asList(arr)); 
    }; 
    return numberN; 
} 

public static void main(String[] args) { 
    System.out.println(digitProcessSystem(123)); 
} 

Ausgang:

1023458769 

Answer 2

Ich bin nicht sicher, was Ziel, Ihr Ende ist. Aber man kann ein HashSet und tun so etwas wie dies nutzen, um zu erreichen, was Sie erreichen wollen:

public static void main (String[] args) throws Exception { 
    long number = 123L, counter = 1000000000L/number; 
    while(digitProcessSystem(number * counter++)); 
    System.out.println("Number: " + number * (counter - 1)); 
} 

public static boolean digitProcessSystem(long input) { 
    char[] arr = Long.toString(input).toCharArray(); 
    Set<Character> set = new HashSet<>(); 
    for (int i = 0; i < arr.length; i++) { 
     set.add(arr[i]); 
    } 
    return set.size() != 10; 
} 

Ausgang:

Number: 1023458769 

Answer 3

ohne Java-Sprache Einrichtungen mit und Hashset:

private static long digitProcessSystem(long N) { 
long numberN = N; 
String number = Long.toString(N); 
String[] arr = number.split("");; 
int arr2=new int[10]; 
int sum=0; 
while(sum != 10){ 
    sum=0; 
    // add N to number 
    numberN += N; 
    // Parse the new number 
    number = Long.toString(numberN); 
    // If it doesn´t have 10 digitis continue here yet 
    if(number.length() < 10) continue; 
    // split 
    arr = number.split(""); 
    for(int i=0;i<arr.length;i++){ 
     arr2[arr]=1; 
    } 
    for(int i=0;i<10;i++){ 
     sum+=arr2[i]; 
    } 
}; 
return numberN; 
} 

Answer 4

Im Allgemeinen, wenn Sie die Zeichen eines String, nicht tun möchten tun Sie es, indem Sie das strin aufspalten g in Teilstrings. Beachten Sie, dass alle CharSequence, einschließlich String, über die Methoden chars() und verfügen, mit denen alle Zeichen als IntStream verarbeitet werden können.

Um zu überprüfen, ob alle Stellen '0'-'9' vorhanden sind, können wir chars() verwenden (nicht über Ersatzpaare denken) und tun es geradlinig, Karte sie auf ihre tatsächliche Anzahl von '0' Subtrahieren, herauszufiltern Alle Nicht-Ziffern (nur um sicher zu sein), dann ordnen Sie sie auf eine int, wo die n th Bit gesetzt ist, so können wir binär oder sie alle zusammen und prüfen, ob alle der niedrigsten zehn Bits gesetzt sind:

public static boolean hasAllDigits(String s) { 
    return s.length()>9 && 
     s.chars().map(c -> c-'0').filter(c -> c>=0 && c<=9) 
       .map(c -> 1 << c).reduce(0, (a,b)->a|b) == 0b1111111111; 
} 

Als Bonus, eine Länge-che ck wird vorangestellt, da ein String mindestens zehn Zeichen haben muss, um alle zehn Ziffern zu enthalten, so dass wir eine Abkürzung vornehmen können, wenn dies nicht der Fall ist.

---

Jetzt bin ich nicht sicher über Ihre eigentliche Aufgabe.Wenn Sie nur bis zu stoßen eine Reihe mit allen Ziffern wiederholen wollen, dann ist es ganz einfach:

long number=123; 
for(long l = 1, end = Long.MAX_VALUE/number; l < end; l++) { 
    long candidate = number * l; 
    if(hasAllDigits(String.valueOf(candidate))) { 
     System.out.println("found: "+candidate); 
     return; 
    } 
} 
System.out.println("not found within the long range"); 

Aber wenn Sie wissen wollen, wenn Sie alle Ziffern innerhalb der Sequenz von Zahlen begegnet, müssen wir den Test anpassen Verfahren und die bitset zwischen den Iterationen halten:

public static int getDigits(String s) { 
    return s.chars().map(c -> c-'0').filter(c -> c>=0 && c<=9) 
      .map(c -> 1 << c).reduce(0, (a,b)->a|b); 
} 

long number=123; 
int digits=0; 
for(long l = 1, end = Long.MAX_VALUE/number; l < end; l++) { 
    long candidate=number * l; 
    int newDigits=digits | getDigits(String.valueOf(candidate)); 
    if(newDigits != digits) { 
     System.out.printf("pos %10d: %10d%n", l, candidate); 
     digits=newDigits; 
     if(digits == 0b1111111111) { 
      System.out.println("encountered all digits"); 
      break; 
     } 
    } 
} 
if(digits != 0b1111111111) { 
    System.out.println("did not encounter all digits within the long range"); 
} 

Diese Methode wird nur taub Druck Die Sequenzer haben mindestens eine Ziffer, die vorher noch nicht gefunden wurde, so dass Sie leicht sehen können, welche zu dem vollständigen Satz beigetragen hat und höchstens zehn Zahlen der Sequenz sehen wird.