it-swarm.com.de

Finden Sie n Anzahl der fehlenden Elemente aus einem Array in Java

Ich habe ein Array mit ganzzahligen Zahlen. Sagen Sie numbers={3,0,1} oder sagen Sie numbers={9,6,4,2,3,5,7,0,1}. Nun muss ich die fehlenden Zahlen aus dem Array herausfinden. Bei diesem Beispiel fehlt in jedem Satz nur eine Nummer. Der 1. verfehlt 2 und der 2. verfehlt 8. 

Ich habe es schon programmiert. Mein Code findet nicht nur eine fehlende Zahl aus dem angegebenen Satz heraus, sondern kann auch mehr als eine fehlende Zahl aus einem bestimmten Satz herausfinden.

Aber wenn zwei aufeinanderfolgende Nummern in derselben Gruppe fehlen, kann es nicht herausfinden .

My code
import Java.util.Arrays;

public class Missing_number 
{
    public static void main( String args[] )
    {
        int numbers[]={9,6,4,5,7,0,1};
        Arrays.sort(numbers);
        int i=1;

        while ( i < numbers.length ) 
        {
            if ( numbers[i] - numbers[i-1] == 1 ) 
            {
            } 
            else 
            {
                System.out.println( "Missing number is " + ( numbers[i-1] + 1 ) );
            }
            i++;
        }
    }
}

Ich denke so, wenn ich die erste fehlende Zahl im Array anhängen kann und dann mit der Suche beginne. Wie sieht der Code aus? numbers={9,6,4,5,7,0,1} Nun fehlt bereits 8 in diesem Set. Jetzt habe ich zwei weitere Elemente (2,3) aus der Liste beendet. Ausgabe: laut meinem Code: 2,8 Aber es fehlt auch 3, aber das wird nicht angezeigt. 

Ich denke, wenn ich 2 im Zahlenfeld anhängen kann, ist es vielleicht etwas einfacher. Aber wie wir alle wissen, ist das Java-Array unveränderlich, so dass wir seine Länge nicht vergrößern können. 

Vielleicht benutze ich List . Aber in der Liste dieser Art der Indizierung wird number[0]=somethingnicht unterstützt. Wie könnte ich dann vorgehen? Benutze ich list oder stecke ich immer noch im Array? 

Also versuche ich, es mit einer Arrayliste zu erstellen.

Mycode(modified version from array)

 public class T1 {
 public static void main(String args[]){
    List<Integer> numbers=new ArrayList<>();
    numbers.add(9);
    numbers.add(6);
    numbers.add(4);
    numbers.add(5);
    numbers.add(7);
    numbers.add(0);
    numbers.add(1);
    Collections.sort(numbers);
    int i=1;
    while(i< numbers.size()) {
        if (numbers.get(i) - numbers.get(i-1) == 1) {

        } else {
            System.out.println("Missing number is " + (numbers.get(i-1) + 1));
            numbers.add((numbers.get(i-1)+1));
            Collections.sort(numbers);
        }
        i++;
    }

    }
}

Arraylist kann mein Problem lösen. Aber gibt es eine Möglichkeit, dass ein einfaches Array dieses Problem lösen kann?

11
Encipher

Dieser Code verwendet eine HashSet:

public static void main(String[] args) {
    int[] numbers = {9, 6, 4, 5, 7, 0, 1};
    Arrays.sort(numbers);
    HashSet<Integer> set = new HashSet<>();

    for (int i = numbers[0]; i < numbers[numbers.length - 1]; i++) {
        set.add(i);
    }

    for (int i = 0; i < numbers.length; i++) {
        set.remove(numbers[i]);
    }

    for (int x : set) {
        System.out.print(x + " ");
    }
}

wird drucken:

2 3 8 


So funktioniert es:
1. Fügt dem Array alle Zahlen von der Mindestanzahl des Arrays bis zur maximalen Anzahl des Arrays hinzu.
2. Iteriert durch das Array und entfernt alle Elemente des Arrays aus dem Satz.
3. Druckt die verbleibenden Elemente im Satz, dh alle fehlenden Elemente des Arrays.

6
forpas

ersetzen Sie die Klausel else durch:

for(int j=numbers[i-1] + 1; j <= numbers[i] - 1; j++) {
    System.out.println( "Missing number is " + ( j ) );
}

lassen Sie uns den Fall untersuchen: {9, 6, 4, 5, 7, 0, 1} Nach der Sortierung lautet: {0, 1, 4, 5, 6, 7, 9} jetzt wenn i Bei Index 2 ist der Unterschied zwischen numbers[i] und numbers[i-1] ungleich 1 (4 - 1 = 3). Nun benötigen Sie ALLE Zahlen zwischen 1 und 4, die 2, 3 sind. Daher müssen Sie von numbers[i-1] zu numbers[i] ( exklusiv), um dies zu erreichen.

Die Komplexität dieses Codes ist ein großes O von N(O(N)), wobei N das größte Element in Ihrem Array ist.

4
Mis94

Es gibt viele Fragen, die hier nicht beantwortet werden. Zum Beispiel: Beginnt ein Array immer mit Null?, Was ist die maximal mögliche Größe? usw.

Hier ist eine einfache Möglichkeit, dieses Problem anzugehen.

  • Finden Sie die maximale Anzahl in Ihrem Set.
  • Erstellen Sie ein leeres boolean-Array mit der Länge der maximalen Anzahl, die Sie im letzten Schritt gefunden haben, plus eins.
  • Scannen Sie Ihren ursprünglichen Satz und setzen Sie den Wert Ihres neuen booleschen Arrays an den Index entsprechend der Anzahl in Ihrem ursprünglichen Satz als true.
  • Scannen Sie schließlich Ihr boolean-Array, um alle Indizes mit dem Wert false zu suchen und zu prüfen.

Beispiel:

Originalsatz: {1,0,3}

  • Schritt 1: Maximale Anzahl in der Gruppe = 3
  • Schritt 2: Boolean Array mit Length = 3 + 1 -> {false, false, false, false}
  • Schritt 3: Beim Scannen der ursprünglichen Gruppe und der Werte im boolean-Array wird dies der Endzustand sein -> {true, true, false, true}
  • Schritt 4: Sie scannen schließlich das boolean-Array zum Drucken 2 da dies nur der Index ist, der den Wert = false hat
1
user2004685
int[] numbers = { 11, 6, 4, 5, 7, 1 };
Arrays.sort(numbers);
int numbersArrayIndex = 0;
for (int i = 0; i < numbers[numbers.length - 1]; i++) {
    if (i == numbers[numbersArrayIndex]) {
        numbersArrayIndex++;
    }
    else {
        System.out.println(i);
    }
}
0
tech