Array rekursiv teilen und aufsummieren

[Guest]

folegende aufgabe soll ich lösen:

Schreiben Sie eine weitere Methode, die das Array im Attribut aufsummiert, allerdings
auf rekursive Art. Verwenden Sie dazu eine weitere Hilfsmethode
mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs
angibt. Diese Methode soll, sofern der spezifizierte Bereich aus mehr als einer
Zahl besteht, den Bereich halbieren und rekursiv jeweils die Summe der beiden Hälften
berechnen, diese zusammenzahlen und die Summe zurückgeben!

das heißt quasi

public static float sum2 ( float[] array ) {
		
		if (array.length == 1 ) {
			return array[0];
			}
			else {

jetzt muss ich hier die methode sum2 wieder aufrufen, und die soll das array teilen und die beiden arrays aufsummieren oder?
wie kann ich ein array ohne system.arraycopy teilen?

 

[SlaterB]

> Verwenden Sie dazu eine weitere Hilfsmethode mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs angibt.

du sollst das Array nicht kopieren, sondern so wie es ist überall durchreichen,
mit den Indexen gibts du an, welcher Teil des Arrays gerade betrachtet wird

 

[Leroy42]

... und zwar so:

public static float sum2 ( float[] array ) { 
       
      if (array.length == 1 ) { 
         return array[0]; 
         } 
         else {
            return sum2(array, 0, array.length()-1);
        }
}

 

[Guest]

sorry mein fehler.... gehört noch zur aufgabe! das is die rekursive art nach der ich das machen soll!

....das array in 2 hälften aufzuteilen diese einzeln zu summieren und die beiden Ergebnisse aufzuaddieren. Das Aufsummieren der beiden Halften
kann dann wieder rekursiv durch weiteres Aufteilen und Zusammenzahlen geschehen.

das gehört noch dazu...
ich soll das array wenn es nicht der länge 1 entspricht immer in 2 teile teilen, die aufsummieren und den linken und den rechten bereich angeben.... also das array so lange teilen bis es nur noch teile der länge 1 hat.... so hab ich das verstanden!!
oder versteh ich das falsch....

 

[SlaterB]

wenn du das Array teilen würdest, wozu dann "linken und rechten Index als Parameter übergeben"?
die wären dann ja bestensfalls immer 0 und array-length()-1,
schlimmstenfalls Indexe aus dem Originalarray und noch weniger zu gebrauchen,

und außerdem wäre der Aufwand gigantisch hoch, zig bis tausende Arrays zu erzeugen, je nach Größe des Ursprungsarrays,
macht keinen Sinn

auf logischer Ebene stimmt die Aussage natürlich,
jeder Operationsaufruf summiert nur einen Teil des Arrays

 

[Guest]

leider muss ich das aber so machen.... hab nachgefragt.... muss das array immer teilen so wie es hier steht!!!
aber leider bekomm ich die rekursion nicht hin!!!

 

[Leroy42]

Manno, das "Teilen" ist metaphorisch zu verstehen.

Durch Übergabe von je zwei Indizes (Anfang und Ende des Arrays)
teilst du schon gewissermaßen das Array.

Nimm einfach meine Methodensignatur und versuche daraus
was zu basteln.

 

[Guest]

Schreiben Sie eine weitere Methode, die das Array im Attribut aufsummiert, allerdings
auf die oben beschriebene rekursive Art. Verwenden Sie dazu eine weitere Hilfsmethode
mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs
angibt. Diese Methode soll, sofern der spezifizierte Bereich aus mehr als einer
Zahl besteht, den Bereich halbieren und rekursiv jeweils die Summe der beiden Hälften
berechnen, diese zusammenzahlen und die Summe zurückgeben!


oben beschriebene rek.art:

Unter der Annahme, dass große und kleine Zahlen in einem Array ungefahr uberall gleich
häufig vorkommen, ist es daher sinnvoll, das Array in zwei Halften aufzuteilen, diese einzeln
zu summieren und die beiden Ergebnisse aufzuaddieren. Das Aufsummieren der beiden Hälften kann dann wieder rekursiv durch weiteres Aufteilen und Zusammenzählen geschehen.

heißt doch:

methode1. array in 2 teile teilen, und diese dann aufsummieren!
und zwar durch so langes teilen des arrays bis die teilarrays 1 lang sind und diese dann aufsummieren...
das ganze dann mit der hilfsmethode

hilfsmethode:

soll jeweils den startwert der beiden teilarray wiedergeben! - falls das teilarray länger als 1 ist soll dieser wieder geteilt und rekursiv aufsummiert werden!


quasi einmal rekursiv teilen und in der hilfsmethode rekusiv ausummieren...

da ist doch das teilen nicht metaphorisch oder? da muss ich das doch echt teilen, und zwar auf rek. art bis die teilarrays neu noch die länge 1 haben und diese dann aufsummieren!

oder nicht?

 

[SlaterB]

wie jetzt, zuletzt schriebst du noch, du hättest 'nachgefragt'

die Aufgabe an sich sagt nix direkt darüber aus, was du machen sollt,
wenn man sie wörtlich nimmt kann man es so machen

den allgemeinen Erfahrungen bei solchen Formulierungen,
dem extrem richtungsweisenden Hinweis "zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs",
und dem gesunden Menschenverstand (Berechnungsaufwand, Programmieraufwand, Nutzen) nach
ist die Sache eindeutig: nicht teilen

wie schon X-MAL GESAGT!
noch mal von mir jedenfalls nicht

 

[Leroy42]

Um dem ganzen Heckmeck hier mal ein Ende zu bereiten:

	public static float sum(float[] floats) {return sum(floats, 0, floats.length-1);}
	public static float sum(float[] floats, int from, int to) {
		if (from>to)
			return 0;
		if (from==to)
			return floats[from];
		int mid = (from+to)/2;
		return sum(floats, from, mid)+sum(floats, mid+1, to);
	}

1. vielleicht lernt Gast ja durch Analysieren des Codes
2. Versuch mal, der Aufgabenstellung genau zu folgen: Also
Eine Klasse schreiben, die die floats als Instanzvariable besitzt und somit
die sum-Helper-Methode tatsächlich nur 2 Paramater benötigt (Anfang- und Endindex)