Problem bei dyn. Bestimmung der Arraylänge

[puelo]

Hallo,

ich habe ein kleines, vielleicht auch triviales Problem mit einer dynamischen Arraylänge. Für die Uni haben wir eine Hausaufgabe bekommen in welcher wir Dezimalzahlen in Arrays addieren sollen (Arrayübung).
Das Ganze sieht folgendermaßen aus:

z.B:

int[] zahl1 = {1, 1, 2, 4} => Das entspricht der Zahl 4211
int[] zahl2 = {2, 2, 4, 5} => Das entspricht der Zahl 5422

Diese zwei Zahlen sollen wir nun addieren und das Ergebnis in einem weiteren Array in der selben (umgedrehten) Reihenfolge abspeichern.
Bei 2 Arrays mit selber Länge war das ganze kein Problem, auch wenn die letzten beiden Dezimalstellen addiert mehr als 10 ergeben habe ich das Array bei der Initialisierung einfach 1 Größer gemacht.

Das sah folgendermaßen aus:

class AddNumbers{

	public static void main (String[] args){
		int[] zahl1 = {1, 1, 7, 6, 9, 9, 9};
		int[] zahl2 = {1, 2, 3, 4};
		int[] ergebnis;
		int arrLength = 0;
		int arrLengthLong = 0;
		int arrDis = 0;
		int wNumber = 0;
		
		if(zahl1.length == zahl2.length){
		
			arrLength = zahl1.length;
			arrLengthLong = zahl1.length;
			
		}else if(zahl1.length > zahl2.length){
		
			arrLengthLong = zahl1.length;
			arrDis = zahl1.length - zahl2.length;
			wNumber = 1;
			
		}else if (zahl2.length > zahl1.length){
		
			arrLengthLong = zahl2.length;
			arrDis = zahl2.length - zahl1.length;
			wNumber = 2;
			
		}
		
		if(zahl1.length == zahl2.length && zahl1[zahl1.length-1] + zahl2[zahl2.length-1] >= 10){
		
				ergebnis = new int[arrLengthLong+1];
				
			}else{
			
				ergebnis = new int[arrLengthLong];
				
			}
		
		for (int i = 0; i < arrLength; i++){
	
			if(zahl1[i] + zahl2[i] >= 10){
			
				ergebnis[i] += (zahl1[i] + zahl2[i]) - 10;
				ergebnis[i+1] += 1;
			
			}else{
			
				ergebnis[i] = zahl1[i] + zahl2[i];
			
			}
			
			
		}
		if ( arrDis != 0){
		
			for (int i = arrDis + 1; i < ergebnis.length; i++){
			
				if (wNumber == 1)
					ergebnis[i] += zahl1[i];
				else if (wNumber == 2)
					ergebnis[i] += zahl2[i];
						
						
			}
		
		}
		
		for (int i = 0; i < ergebnis.length; i++)
		System.out.println(ergebnis.length);
		
	}
	
}

vielleicht etwas überladen. Habe bereits angefangen Dinge für verschiedene Arraylängen zu implementieren. Wenn ihr hierzu schon Tipps habt nur immer her damit .

Sooo.. Zum eigentlichen Problem:

Wenn jetzt z.B eine Zahl 5500 ist, also im Array dann 0, 0, 5 ,5
und die andere Zahl dann 999900 ist, also im Array 0, 0, 9, 9, 9, 9

Dann wird ja theoretisch das Array des Ergebnisses um 1 Größer als die Länge des 999900 Arrays..

Wie kann ich das bewerkstelligen? Vorher wars ja kein Problem, weil ich die letzten beiden Stellen der Arrays einfach addieren und dann prüfen konnte, aber hier geht das natürlich nichtmehr.

Bin für jeden Ansatz dankbar. Vielen DANK!

puelo

 

[Camill]

Ich stelle dir mal einen anderen Lösungsweg vor:
- Werte aus Array1 sowie Array2 auslesen und als String abspeichern (for-Schleife)
- Beide Strings zu int konvertieren -> Addieren
- Länge des Ergebnis ermitteln und ein Array dieser Länge anlegen
- Ergebnis spliten und in Array schreiben

 

[xehpuk]

Vorher wars ja kein Problem, weil ich die letzten beiden Stellen der Arrays einfach addieren und dann prüfen konnte, aber hier geht das natürlich nichtmehr.

Wieso nur die letzten beiden Stellen? Du musstest vorher schon beliebig viele Stellen beachten: [1, 0, 0, 0] + [9, 9, 9, 9].

Den Vorschlag des Vorposters kann ich so nicht unterstützen.
Zeichenketten haben bei Berechnungen nichts zu suchen. Des Weiteren stößt man so schnell auf einen Überlauf.

Ich würde die Zahlen erst mal normal miteinander addieren und dann in einer zweiten Methode ("normalize" wäre ein passender Name) Überläufe beachten und dort ggf. einen längeren Array zurückgeben. Das wäre auch wesentlich kürzer als dein bisheriger Code

 

[njans]

Camills Idee ist definitiv schöner, aber vermutlich bist du da an die Aufgabenstellung gebunden bezüglich der Addition.
Deswegen mal hier mein Kommentar:
Du unterscheides schon 3 Fälle (Beide Arrays gleich lang oder eines größer als das Andere).
Einfacher wäre es nun, einfach über das länger per Schleife zu laufen und alle Zahlen aus dem kleineren hinauf zu addieren. Dabei musst du dann den Übertrag (Wenn die Zahl > 9) einfach ins nächste Feld übertragen. Wenn du das Ziel-Array einfach eins länger machst, als das längste beider Arrays, dann sollte das für eine Addition ausreichen.
Du kannst natürlich nachträglich alle Daten aus dem Array wieder in ein Array mit passender Größe kopieren

 

[Camill]

Den Vorschlag des Vorposters kann ich so nicht unterstützen.
Zeichenketten haben bei Berechnungen nichts zu suchen. Des Weiteren stößt man so schnell auf einen Überlauf.

Wo genau kann denn ein Überlauf zustande kommen?

 

[bERt0r]

Also ich weis nicht was schön daran ist, ein paar ints in einen string zu konvertieren, nur um dann wieder auf int zu konvertieren.
Machs dir doch einfach, so wie du Addieren gelernt hast, 2 Zahlen untereinanderschreiben und addieren und ggf. eine Übertrag merken:

int [] arr1={1,2,3,4}
int [] arr2={5,6,7,8,9,0}

int l=0;
if(arr1.lenght>arr2.length)
{
l=arr1.length+1;
}
else
{
l=arr2.length+1;
}

int[] erg=new int[l];

//Erstes array in erg schreiben
for(int i=0;i<arr1.lenght;i++)
{
erg[i]=arr1[i];
}

//Mit 2 Array addieren
int uebertrag=0;
for(int i=0;i<arr2.lenght;i++)
{
int zwischenergbnis=arr2[i]+uebertrag;
if(zwischenergebnis>9)
{
erg[i]=zwischenergebnis-10;
uebertrag=1;
}
else
{
erg[i]=zwischenergebnis;
uebertrag=0;
}
}
if(uebertrag!=0)
{
erg[i]=erg[i]+uebertrag;
}

 

[xehpuk]

Camills Idee ist definitiv schöner

Zeichenketten sind für (jetzt kommts) Zeichen, nicht für Zahlen. Die Verwendung als Zahl wäre schlimmer Missbrauch.

wo genau kann denn ein überlauf zustande kommen?

{0, 0, 0, 0, 0, 0, 0, 0, 0, 2} + {0, 0, 0, 0, 0, 0, 0, 0, 0, 2}.

 

[Camill]

Ja da hast du recht - sofern da solche Zahlen eingegeben werden

 

[irgendjemand]

moment mal ... hab ich was nicht mitbekommen ?

warum sollte man eine zahl in umgekehrter reihenfolge irgendwo speichern ?

ja ... es wäre ein deutlicher mehraufwand *zumindest für einen anfänger ... für fortgeschrittene wäre es schlichte lästiges copy&paste* die ziffern einer zahl in der richtigen reihenfolge zu speichern ... hätte dich aber schneller auf die lösung der "normalen" schriftlichen addition gebracht ...

@Camill

thema overflow : sobald du 2^31 erreichst passt das nicht mehr in einen INT ... da INT nur von -2^31 bis +2^31 -1 geht ...

 

[njans]

public static void main(String[] args)
	{
		int [] arr1={1,9,3,4};		// 4.321
		int [] arr2={1,1,1,1,5,5}; 	// 551.111
		int [] erg;
		
		// Sorge dafür, dass das größere Array als erster Parameter
		// eingesetzt wird
		if(arr1.length >arr2.length)
		{
			erg = berechneSumme(arr1, arr2);
		}
		else
		{
			erg = berechneSumme(arr2, arr1);
		}
		
		// Ausgabe des Arrays in angemessener länge
		System.out.println(Arrays.toString(schneideArrayZu(erg)));
	}
	
	
	private static int[] berechneSumme(int[] groesseresArray, int[] kleineresArray)
	{
		// Ergebniss Array mit der maximalen Länge + 1
		int[] ergebnissArray = new int[groesseresArray.length + 1];
		
		// Befülle das Ergebniss Array mit den Zahlen des kleineren Arrays
		for (int i = 0; i < kleineresArray.length; i++)
		{
			ergebnissArray[i] = kleineresArray[i];
		}
		
		// Iteriere über das längere Array
		int uebertrag = 0;
		for (int i = 0; i < groesseresArray.length; i++)
		{
			// Berechne die Summe des i-ten Feldes des Arrays, inklusive des Übertrages
			int feldSumme = ergebnissArray[i] + groesseresArray[i] + uebertrag;
			
			// Wenn die Summe größer 10 ist, dann merke dir den Übertrag 1 und 
			// sorge dafür, dass die feldSumme kleiner als 10 bleibt
			if (feldSumme >= 10)
			{
				feldSumme = feldSumme - 10;
				uebertrag = 1;
			}
			// Setze den Übertrag zurück, damit dieser nicht doppelt verwendet wird
			else
			{
				uebertrag = 0;
			}
			
			// Trage den Wert ins ergebnissArray ein
			ergebnissArray[i] = feldSumme;
		}
		
		// Wenn es am Ende noch einen Übertrag gibt, dann wird das zusätzliche Feld benötigt.
		if (uebertrag > 0)
		{
			ergebnissArray[ergebnissArray.length-1] = uebertrag;
		}
		
		return ergebnissArray;
	}
	
	private static int[] schneideArrayZu (int[] array)
	{
		// Wenn das letzte Feld 0 ist, dann kann dieses gekürzt werden.
		if (array[array.length -1] == 0)
		{
			// Neuer array, um einen kürzer
			int[] kurzesArray = new int[array.length -1];
			
			// Übertragen der benötigten Werte ins neue Array
			for (int i = 0; i < kurzesArray.length; i++)
			{
				kurzesArray[i] = array[i];
			}
			
			return kurzesArray;
		}
		// Wenn nicht, dann ist das Array okay
		else
		{
			return array;
		}
	}

Hier mal ne etwas beschriebener Lösung, die auch noch diese führende Null aus dem Array nimmt.
@ bert0r, du hattest da ein paar Fehler in deinem Code, hab deine Idee aber mal weiter geführt.

 

[irgendjemand]

private static int[] schneideArrayZu (int[] array)
	{
		// Wenn das letzte Feld 0 ist, dann kann dieses gekürzt werden.
		if (array[array.length -1] == 0)
		{
			// Neuer array, um einen kürzer
			int[] kurzesArray = new int[array.length -1];
			
			// Übertragen der benötigten Werte ins neue Array
			for (int i = 0; i < kurzesArray.length; i++)
			{
				kurzesArray[i] = array[i];
			}
			
			return kurzesArray;
		}
		// Wenn nicht, dann ist das Array okay
		else
		{
			return array;
		}
	}

hier würde ich aber eher <T> Arrays.copyOfRange(T[], int, int) verwenden als ein neues array zu erzeugen und in einer for() alles zu kopieren ...

 

[puelo]

Ich stelle dir mal einen anderen Lösungsweg vor:
- Werte aus Array1 sowie Array2 auslesen und als String abspeichern (for-Schleife)
- Beide Strings zu int konvertieren -> Addieren
- Länge des Ergebnis ermitteln und ein Array dieser Länge anlegen
- Ergebnis spliten und in Array schreiben

Da es sich um eine Hausaufgabe für Arrays handelt und wir bisher nur wenig "Schnick Schnack" außenrum gelernt haben würde ich gerne auch nur die bisher gelernten Dinge einsetzen. Danke trotzdem.

moment mal ... hab ich was nicht mitbekommen ?

warum sollte man eine zahl in umgekehrter reihenfolge irgendwo speichern ?

Das kommt später in der Aufgabe - ich wills halt gerne nach Reihenfolge machen, da ich glaube , dass ich so den meisten Lernerfolg habe. Ich stoße auf verschiedene Probleme und muss diese lösen.

Hier mal ne etwas beschriebener Lösung, die auch noch diese führende Null aus dem Array nimmt.
@ bert0r, du hattest da ein paar Fehler in deinem Code, hab deine Idee aber mal weiter geführt.

Danke, das hilft mir sehr weiter!


Danke an Alle! Ich denke ab hier komme ich alleine zu recht.

 

[bERt0r]

Das mit der umgekehrten Reihenfolge macht durchaus Sinn, dadurch sind die Nullen am ende des Arrays nämlich unwichtig und so eine Kopierfunktion von 2 unterschiedlich langen Arrays ist viel einfacher. (Int Arrays werden mit 0 initialisiert)