[Java] Array-Inhalt auf Duplikate überprüfen.

[kalleberlin]

Hallo, ich mal wieder


Nehmen wir mal an ich fülle mir ein Array mit, sagen wir mal 10 beliebigen (Random) Zahlen.
Wie kann ich jetzt diese Zahlen überprüfen ob eine Zahl doppelt vorhanden ist?

Ich weiss zwar wie ich mir das mit einer for-schleife schön der reihe nach ausgeben kann, aber nicht wie ich auf doppelte prüfen kann.

Jemand eine Idee?

 

[SoniX'[]'Hunter]

Hey.

Sowas ?

    	Random random = new Random();
    	
    	ArrayList rdm = new ArrayList();
    	rdm.contains(random);

Wobei contains nen boolean zurück gibt.

 

[Grenzwert]

Du ordnest die Zahlen der Reihe nach an und überprüfst dann jede Zahl mit der nächsten. Gleiche Zahlen kann man dann direkt rausschmeissen.

 

[kalleberlin]

mhh Sortieren wäre dann stichwort bubblesort?
//edit:
und ob die nächste zahl mit der nächsten überprüfen wäre dann
for...
if (zahlen==zahlen[i+1]) ?
....

 

[Kampfgnom]

sort ist eher Stichwort für "fertige Funktion suchen"

http://java.sun.com/j2se/1.4.2/docs/api/java/util/Arrays.html

Habe ewig kein Java gemacht, weiß also nicht ob das teil Funktioniert.

 

[Cobinja]

Wenn du die Werte in einer java.util.List hast, kannst du Duplikate herausfinden, indem du das Ergebnis von List.indexOf() mit dem von List.lastIndexOf() vegleichst.

 

[Grenzwert]

mhh Sortieren wäre dann stichwort bubblesort?
//edit:
und ob die nächste zahl mit der nächsten überprüfen wäre dann
for...
if (zahlen==zahlen[i+1]) ?
....

Ja, zum Beispiel.
Das mit Bubblesort würde ich lassen.
Das schöne an Java ist, dass es für fast jeden Scheiss bereits zur verfügung stehende Funktionen gibt. Das beschleunigt die Entwicklung ungemein.
Also anstatt selbst was zu implementieren, klick auf den link weiter oben und such dir was aus.

 

[kalleberlin]

So, hatte die ganze zeit ein Internet totalausfall, deswegen hab ich in der Zeit es doch mit Bubblesort gemacht^^.

Nun hab ich aber doch noch ein Problem, da könnt ihr mir sicher auch helfen .

Also hier erstmal der Code:

/*
Schreiben Sie ein Programm, das eine Lottoziehung (6 aus 49 mit Zusatzzahl) simuliert. 
Wichtig ist natürlich, keine Zahlen doppelt zu ziehen. Eine einfache Strategie dazu ist, solange eine Zufallszahl zu erzeugen, bis eine neue Zahl entsteht.
*/
import java.util.*;

public class lotto
{   public static void main (String args[])
    {
		Random zufallZahl=new Random();
		int[] Zahlen=new int[6];
		int k,i,j,h;
		for (i=0;i<6;i++){
		//zufalls array
		Zahlen[i]=zufallZahl.nextInt(49)+1;
		}
		// Sortiere:
        for (k=1; k<6; k++)
        {   j=k; // Sortiere Zahlen[i] ein
            while (j>0) // solange es nicht ganz vorne steht
            {   if (Zahlen[j-1]>Zahlen[j]) // steht noch falsch
                {   h=Zahlen[j]; Zahlen[j]=Zahlen[j-1]; Zahlen[j-1]=h; // vertauschen
                }
                else break; // steht richtig
                j--;
            }
        }
		//doppelte zahl mit neuer ersetzen
		for (i=0;i<5;i++)
		if (Zahlen[i]==Zahlen[i+1]){
			System.out.println("Eine Doppelt:"+Zahlen[i]);
			int ersatzzahl=zufallZahl.nextInt(49)+1;
			System.out.println("ersatzzahl :"+ersatzzahl);
			Zahlen[i]=ersatzzahl;
			//neu sortieren
			for (k=1; k<6; k++){   		
				j=k; // Sortiere Zahlen[i] ein
					while (j>0){ // solange es nicht ganz vorne steht		
						if (Zahlen[j-1]>Zahlen[j]){ // steht noch falsch
							h=Zahlen[j]; Zahlen[j]=Zahlen[j-1]; Zahlen[j-1]=h; // vertauschen
						}
						else break; // steht richtig
						j--;
					}
			}
			
			
			
			}
			
				
		for (i=0;i<6;i++){	
		System.out.println(Zahlen[i]);}

		
		}
	
	
}

Also, folgendes weiss ich :

Der Code so wie er dort oben steht ist nur suboptimal.
Wie man sieht, muss ich a: das Array 2 mal sortieren und b: kann es mir trotzdem noch passieren das ich Doppelte Zahlen drin habe (ist zwar unwahrscheinlich, aber theoretisch möglich).

@Grenzwert

Ich habe mir dein link mal angeschaut.

Unter den vielen tausend (), hab ich den hier:

sort(byte[] a, int fromIndex, int toIndex)

als Interessant befunden ABER: wie setze ich das jetzt in meinen code um? Sorry aber ich hab das alles noch nicht so 100%ig begriffen^^.

Der code da oben hat mich schon ein paar graue Haare gekostet .

Danke erstmal für eure Antworten

 

[Grenzwert]

Das wäre mein Vorschlag.

import java.util.*;

public class Main {
    
    public static int doppelteZahlNr;
    
    public static void main(String[] args) {
        
        Random zufallZahl = new Random();
        int[] array = new int[6];
       
        for (int i = 0; i < 6; i++) {
        
        array[i] = zufallZahl.nextInt(49) + 1;
        }
        
        
        while (aufDoppeltePruefen(array) == true) {
            doppelteZahlErsetzen(array);
        }
        
        for (int i = 0; i < 6; i++) {    
            System.out.println(array[i]);
        }
    }
    
    public static boolean aufDoppeltePruefen(int[] array) {
        
        boolean doppelteVorhanden = false;
        Arrays.sort(array);
        
        for (int i = 1; i < array.length; i++) {
            if (array[i] == array[i - 1]) {
                doppelteVorhanden = true;
                doppelteZahlNr = i;
            }
        }
        return doppelteVorhanden;
    }
    
    public static void doppelteZahlErsetzen(int[] array) {
        Random zufallszahl = new Random();
        array[doppelteZahlNr] = zufallszahl.nextInt(49) + 1;
    }
}

Kann man sicherlich besser und effizienter machen. Aber auf die schnelle ist mir nur das eingefallen. Hab den letzten Java Code vor über 1 Jahr geschrieben.

 

[Keita]

Es wäre IMHO sinnvoller eine ArrayList-Instanz mittels add() zu füllen und dabei mit contains() auf Duplizität zu prüfen:

import java.util.*;

class keitaLotto
{

	public static void main(String args[])
	{
		Random rand = new Random();
		ArrayList list = new ArrayList(6);
       
		for (int i = 0; list.size() < 6; ++i) {
			Integer obj = new Integer(rand.nextInt(49));
			if (list.contains(obj))
				continue;
			list.add(obj);
		}
        
		Object[] array = list.toArray();
        
		for (int i = 0; i < 6; ++i) {    
			System.out.println(array[i]);
		}
	}
}

Ob's tatsächlich sinnvoller ist, müßte jemand, der sich mit Java auskennt, beantworten… ich selbst hab nämlich von Java keinen Plan

greetings, Keita

 

[Grenzwert]

Deine Lösung ist besser, falls man mit einer ArrayList arbeiten möchte / kann. Allerdings ist es durch das 'continue' falsch. Deine ArrayList würde dann nicht mehr 6 Zahlen beinhalten. Müsste man noch ändern.
Der Ansatz ist insofern besser, da man nicht das ganze Array direkt vollpackt, sondern nacheinander Zahlen addiert und dabei auf Duplikate prüft.

 

[Cobinja]

Ich hatte grade mal ein bischen Langeweile:

package test;

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

public class Lotto {
  
  public static void main(String args[])
  {
    Random rand = new Random();
    List<Integer> list = new ArrayList<Integer>();
    
    // Hier wird die Liste gefüllt
    for (int counter = 0; counter < 6; counter++) {
      Integer number = null;
      do {
        number = Integer.valueOf(rand.nextInt(49) + 1);
      } while (list.contains(number));
      list.add(number);
    }
    
    // Liste sortieren
    Collections.sort(list);
    
    // Hier wird die Liste ausgegeben
    Iterator<Integer> iter = list.iterator();
    while (iter.hasNext()) {
      Integer num = iter.next();
      System.out.println(num);
    }
  }

}

Die addierte 1 beim Ziehen der Zufallszahl kommt daher, daß Random.nextInt(int) Zahlen zwischen 0 (inklusive) und der angegebenen Zahl (exklusive) ausgibt, bei nextInt(49) also nur die Zahlen von 0 bis 48.

 

[krizzelfix]

Habe mal die Version von Keita etwas abgeändert:

import java.util.*;

class keitaLotto
{

	public static void main(String args[])
	{
		Random rand = new Random();
		ArrayList list = new ArrayList(6);
       
		for (int i = 0; list.size() < 6; i++) {
			Integer obj = new Integer(rand.nextInt(49));
			if (list.contains(obj))
                        {
                               i--;
                        }
                        else 
                        {
             			list.add(obj);
                        }
		}
        
		Object[] array = list.toArray();
        
		for (int i = 0; i < 6; ++i) {    
			System.out.println(array[i]);
		}
	}
}

Habe es jetzt nicht getest, denke aber das ist die einfachste Lösung.

Grüße

tewes

 

[kalleberlin]

Ok, vorweg erstmal ein fettes Dankschön an euch alle das ihr mir so zahlreiche Vorschläge unterbreitet habt .

Das ist jetzt ne Menge Input für mich, deshalb würde ich das gerne mal mit euch durchgehen, ob ich das auch richtig verstanden hab .

also:

ArrayList list = new ArrayList(6);

Wenn ich jetzt richtig verstanden habe, ist das das gleiche wie:

int[] Array=new int[6];

Was mich wundert, ist das bei der obigen Variante das Array ohne Typ deklariert wird?!

Das nächste:

for (int i = 0; list.size() < 6; i++)

wäre dann ?

for (int i = 0;Array.length<6;i++)

So und nun noch sachen die ich eher gar nicht verstehe:

if (list.contains(obj)) //was passiert hier?
                        {
                               i--;
                        }
                        else 
                        {
             			list.add(obj); //woher kommt das "add"?
                        }
		}
        
		Object[] array = list.toArray(); //was ist das?

Schonmal Danke für eure Geduld

 

[Grenzwert]

Die ArrayList ist nicht das Gleiche wie ein Array. Sie kann aber unter anderem die gleiche Aufgabe erfüllen und noch viel mehr. Das Add ist eine Methode, welche zur Klasse ArrayList gehört oder zumindest von einer höheren abgeleitet wird. Dazu müsstest Du aber ein gutes Javabuch bemühen um das zu kapieren (www.javabuch.de)

 

[krizzelfix]

if (list.contains(obj)) //Die Klasse "list" hat die Methode "contains" die true zurück gibt wenn das Übergeben Integer in der Liste existiert. Ansonsten False.
                        {
                               i--;
                        }
                        else 
                        {
                         list.add(obj); //Add ist ebenfalls eine Methode, diese Fügt aber ein Element der Liste hinzu
                        }
        }
        
        Object[] array = list.toArray(); //Dort wird die Liste zu einem Array convertiert und in dem Object Array gespeichert. Was aber eventuell etwas überflüssig ist.

 

[Keita]

Allerdings ist es durch das 'continue' falsch.

Oh ja, da hab ich gepennt, das Inkrement gehört natürlich in den Schleifenrumpf…

Der korrigiert Code (nach meinem Styleguide ):

import java.util.*;

class keitaLotto
{

	public static void main(String args[])
	{
		Random rand = new Random();
		ArrayList list = new ArrayList(6);

		/* Inkrement ++i raus… */
		for (int i = 0; list.size() < 6;) {
			Integer obj = new Integer(rand.nextInt(49));
			if (list.contains(obj))
				continue;
			list.add(obj);
			/* und hier rein… */
			++i;
		}
        
		Object[] array = list.toArray();
        
		for (int i = 0; i < 6; ++i) {    
			System.out.println(array[i]);
		}
	}
}

greetings, Keita

 

[krizzelfix]

@Keita: Würde das Continue rausnehmen und es durch i-- ersetzen. Da continue ja nicht viel besser als goto ist

 

[Cobinja]

@Keita: Das ist so auch nicht ganz richtig. Du müsstest (nach deinem styleguide) direkt vor dem continue ein i-- einfügen und dein i++ wieder rausnehmen:

        for (int i = 0; list.size() < 6;) {
            Integer obj = new Integer(rand.nextInt(49));
            if (list.contains(obj)) {
                i--;
                continue;
            }
            list.add(obj);
        }

Ansonsten würdest du , sofern keine Zahl doppelt ge-zufall-t wird, nur drei Zahlen in der Liste haben.

 

[Grenzwert]

@Keita: Das ist so auch nicht ganz richtig. Du müsstest (nach deinem styleguide) direkt vor dem continue ein i-- einfügen und dein i++ wieder rausnehmen:

        for (int i = 0; list.size() < 6;) {
            Integer obj = new Integer(rand.nextInt(49));
            if (list.contains(obj)) {
                i--;
                continue;
            }
            list.add(obj);
        }

Ansonsten würdest du , sofern keine Zahl doppelt ge-zufall-t wird, nur drei Zahlen in der Liste haben.

Das ist schon korrekt was er gemacht hat. Im Schleifenkopf inkrementiert er ja nichts mehr, sondern erst am Ende.