[Rekursion] Newbie-Hilfe

[Guest]

Hallo an alle,

erster Post hier, ich versuche mal mein Glück.
Folgendes: Ich schreib nächste Woche ne Java-Einführungs-Klausur in der Uni, und gehe gerade die diversen Übungen durch. Themenbereich sollten eigentlich machbar sein, es geht von gerenreller Syntax, Datentypen, Schleifen, Methoden, Objekterzeugung, Rekursion...und später dann ein paar dynamische Datentypen, sowas mit Bäumen umhängen, Stacks, Queues, Listen usw usw...

Naja, bin gerade bei Rekursion dran und krieg ne Krise.
Aufgabenstellung ist folgende:

Sie erben eine Bananenpflanze. Jede Bananenpflanze entwickelt binnen eines Jahres drei
Ableger, die Sie in eigenen Töpfe pflanzen.

Schreiben Sie eine Klasse Banane, die rekursiv eine Methode ableger aufruft um die
Ausgabe „Ich bin ein Ableger“ für jede neu entstandene Bananenpflanze auf den Bildschirm
auszugeben, die sich nach dem übergebenen Zeitraum gebildet haben.

So...Hab schon diverse Dinge versucht, klappt aber keins so richtig. Mit Objekten oder ohne, und überhaupt...wie da der Aufruf genau klappen soll...Das Teil soll ne 3 Jahres-Laufzeit haben, und ich denke die wollen folgendes sehen:
0tes Jahr - 1 Pflanze
1 Jahr - 4 Pflanzen
2 Jahr - 12 Pflanzen
3 Jahr - 48 Pflanzen...also dann 48 x "Ich bin ein Ableger" .

OK, mein Code bisher (der nicht funktioniert):

public class Banane { // rekusiver Aufruf von Bananenpflanzen, pro Pflanze 3 Ableger, 3 Jahre Laufzeit

	
	public static void main (String args[]) { //Hauptprogramm
	Banane.ableger(3);
		
	}
	
	public static void ableger(int jahre) { //Ableger rekursiv aufrufen
	
		jahre = 0;	
		
		while(jahre < 3) {
		System.out.println("Ich bin ein Ableger");		
		}
		
	jahre = jahre++;	
	ableger(jahre);
	
	}

}

Wie gesagt, das ist einer von vielen Versuchen. Entweder gibts ne Endlos-Schleife, oder garnichts...Hab auch was mit Banane test = new Banane; (nach der While-Schleife) und dann Banane.ableger(jahre) versucht, aber das hat auch nicht geklappt...
Kann vielleicht jemand Licht ins dunkeln bringen? Oder mir die Logik dahinter erklären außer "Jaja, Rekursion, total einfach, da ruft sich einfach ne Funktion selber auf..."

Danke im voraus

CU
Lio

 

[SlaterB]

wichtigste Aufgabe bei Aufgaben: die Aufgabe verstehen, notfalls beim Aufgabensteller nachfragen,
also ich wüsste aus der Aufgabenstellung nicht was da genau gemeint ist, so richtig schön rekursiv sieht das gar nicht aus

zu deinem Programm:
du bekommst in der Operation einen Parameter jahre übergeben, der wahrscheinlich eine wichtige Information enthälte (0, 1, 2, 3?)
dein erster Schriff in der Operation: jahre = 0;
warum? damit zerstörst du ja diese Information, der Parameter wird nutzlos, ist IMMER 0,
so also nicht

-------

while(jahre < 3) {
System.out.println("Ich bin ein Ableger");
}

macht auch keinen Sinn, entweder wird die Schleife nie ausgeführt (jahre < 3),
ansonsten gibts ne Endlosschleife, weil jahre >= 3 immer >= 3 bleibt!,

in so einer Schleife müsste alos z.B. jahre jedesmal um 1 reduziert werden oder so

------------

es macht aber auch keinen Sinn da über jahre zu arbeiten,
besser läßt du jahre so wie es ist, z.B. als Parameter mit Wert 2 übergeben, am Ende auf 3 erhöht und weitergegeben,

stattdessen musst du zwischendurch ausrechen wieviele Bananen in diesem Jahr vorhanden sind,
int bananen = jahre * 75; (bessere Formel finden)
und die Ausgabeschleife dann an die Anzahl der Bananen binden

for (int i=0; i<bananen; i++) {
System.out.println("Ich bin ein Ableger im Jahre "+jahre); // vielleicht noch die Nummer i mit ausgeben, sonst steht x-mal das gleich da..
}

----------

das ist allerdings nicht besonders rekursiv, deshalb besser nochmal klären was überhaupt gefragt ist,

vielleicht etwas in der Art von:
Ich bin Banane 1 im Jahre 0
Ich bin Banane 1.1 im Jahre 1
Ich bin Banane 1.1.1 im Jahre 2
Ich bin Banane 1.1.1.1 im Jahre 3
Ich bin Banane 1.1.1.2 im Jahre 3
Ich bin Banane 1.1.1.3 im Jahre 3
Ich bin Banane 1.1.2.1 im Jahre 3
....
Ich bin Banane 1.2 im Jahre 1
.......
Ich bin Banane 3.3.3.3 im Jahre 3

hat auch nicht wirklich was mit der Formulierung der Aufgabe zu tun
aber so schön verschachtelt kriegt man das nur per Rekursion hin,

das andere, die drei Jahre hintereinander, das geht auch hintereinander mit
ableger(0);
ableger(1);
ableger(2);
ableger(3);

 

[LioGetz]

Hola,

danke schonmal. Leider bin ich daraus nicht so wirklich schlau geworden...vielleicht liegts daran dass ich nicht so den richtig Java-Plan habe und auch bis jetzt nur die absoluten Grudlagen kenne...
Zur Aufgabenstellung kann ich nur sagen, dass die genau so in der Übung drin stand...nich mehr und nicht weniger...und natürlich beim Thema "Rekursion"...

Rekursiv kann das ganze (nach meinem Verständnis) ja schon werden, da sich die Ableger die Funktion ja immer neu aufrufen, da sie ja selber wieder neue Ableger erzeugen...

Mit den Jahren hab ich mir das einfach so gedacht, dass ich nen Abbruch nach 3 Jahren bekomme...aber da ist wohl was falsch...hab erstmal jahre auf Null gesetzt, und dann später jahre++, so das nach dem 3ten Mal die Bedinung in der while-schleife nicht mehr zutrifft...und dann fertig . Naja, soweit meine Theorie, wie schon gesagt, die Praxis klappt noch nicht so wie ich mir das vorstelle.

Das mit deiner Bananen-Formel hab ich nicht ganz gecheckt ?!?!

Ach, und zur Ausgabe: Ich glaub mehr als "Ich bin ein Ableger" wollen die nicht sehen, aber das in der richtigen Anzahl durch Rekursion aufgerufen...das wäre schon Luxus wenn da sowas wie 1.1, 1.2 etc. dahinter stehen würde um zu sehen aus welchem Jahrgang die Pflanze ist. Absehen davon, ich weiß garnicht ob wir sowas schon können (müssen).

Danke

CU
Lio

 

[mouk]

Hi!

Ich habe ein bisschen geknobelt und bin dann zu diesem Ergebnis gekommen:

public class Banane {

	public static int counter = 3;

	public static void main(String args[]) {
		Banane.ableger(3);
	}

	public static void ableger(int jahre) {

		while (jahre > 0) {

			System.out.println("Ich bin ein Ableger");
			System.out.println("Ich bin ein Ableger");
			System.out.println("Ich bin ein Ableger");

			// die variable counter gibt die Anzahl der "Ich bin..." 
			// Nachrichten aus die bereits ausgegeben wurden
			System.out.println(counter);
			counter += 3;
				
			jahre--;

			Banane.ableger(jahre);
			Banane.ableger(jahre);
			Banane.ableger(jahre);
		}
	}
}

Sag bescheid ob es das ist, was du wolltest.

fg, mouk

 

[SlaterB]

ich will gar nix, da ich mir wie gesagt nicht genau vorstellen kann was als Lösung rauskommen soll,
(edit: oh da hatte ja jemand anders als der Ursprungsposter geantwortet)

deins macht aber durchaus Sinn so wie du es möchtest und bestimmt auch gemeint ist, ja

etwas übersichtlicher wirds vielleicht durch

public class Banane {

	public static int counter;

	public static void main(String args[]) {
		Banane.ableger(3);
	}

	public static void ableger(int jahre) {
		if (jahre < 1) {
			return;
		}

		System.out.println("Ich bin ein Ableger");
		System.out.println("Ich bin ein Ableger");
		System.out.println("Ich bin ein Ableger");

		// die variable counter gibt die Anzahl der "Ich bin..."
		// Nachrichten aus die bereits ausgegeben wurden
		counter += 3;
		System.out.println(counter);


		jahre--;

		if (jahre > 0) {
			Banane.ableger(jahre);
			Banane.ableger(jahre);
			Banane.ableger(jahre);
			Banane.ableger(jahre);
		}
	}
}

 

[tingel]

So solltest du damit was anfangen können:

public class Banane {
  
  public static void main(String args[]) {
    int startJahr=0;
    int anzahlJahre=3;
    int anzahlEltern=0;
    System.out.println("Wir starten im "+startJahr+". Jahr mit "+anzahlEltern+" Eltern und einem Zuchtzeitende im "+anzahlJahre+" Jahr");
    Banane.ableger(startJahr,anzahlJahre,anzahlEltern);
  }
  
  public static void ableger(int jahre, int anzahlJahre, int anzahlEltern) {
    if(jahre==anzahlJahre) {
      System.out.println("Ende der Zuchtzeit");
      return;
    } else {
      if(anzahlEltern==0) {
        System.out.println(jahre+". Jahr: - 1 Pflanze");
        Banane.ableger(++jahre,anzahlJahre,1);
      } else {
        int kinder=anzahlEltern*3;
        System.out.println(jahre+". Jahr: - "+(kinder+anzahlEltern)+" Pflanze, davon "+kinder+" Kinder.");
        Banane.ableger(++jahre,anzahlJahre,(kinder+anzahlEltern));
      }
    }
    return;
  }
}

Noch eine Anmerkung:
Durch dein Beispiel bin ich nicht unbedingt durchgestiegen. Nach meiner Auffassung muss es im 1. Jahr 4 Pflanzen (3 neue Ableger) geben. Im zweiten Jahr muss es 16 Pflanzen (12 neue Ableger) geben, da die Pflanze auf dem 1. Jahr auch noch wieder 3 Ableger produziert.

 

[LioGetz]

Hallo...

danke für die Hilfestellung!
Aber entweder bin ich zu blöd, oder da sind noch Fehler drin...
Ich hab mal alle kompiliert und geguckt was passiert.
Beim Code vom Slater und Mouk kommt wieder ne Endlosschleife raus...also hauts meine Konsole voll mit "Ich bin ein Ableger"...und eigentlich soll der ja nach 3 Jahren feddich sein .

Und der Tingel-Code lässt sich nicht kompilieren wegen folgenden Fehlermeldungen:

>javac *.java
Banane3.java:8: ableger(int) in Banane cannot be applied to (int,int,int)
    Banane.ableger(startJahr,anzahlJahre,anzahlEltern);
          ^
Banane3.java:18: ableger(int) in Banane cannot be applied to (int,int,int)
        Banane.ableger(++jahre,anzahlJahre,1);
              ^
Banane3.java:22: ableger(int) in Banane cannot be applied to (int,int,int)
        Banane.ableger(++jahre,anzahlJahre,(kinder+anzahlEltern));
              ^
3 errors
>Exit code: 1

Mach ich da was falsch? Schön zu sehen das auch schon fortgeschrittene User damit Probleme haben .
Dann kanns in der Klausur ja nur besser werden...

Danke,

CU
Lio

P.S. @tingel: Klaro, das war natürlich ein Fehler von mir...im zweiten Jahr sinds natürlich 16 Ableger, und nicht 12...


// edit: Und noch ein kleiner Nachtrag, was ich gerade im Forum der Vorlesung entdeckt habe:

hallo

gehen wir davon aus, dass eine bananenpflanze nur ein Jahr überlebt, oder überlebt sie die kompletten drei Jahre, und erzeugt jedes Mal drei Ableger?

gute frage. kriegen die bananen einmal kinder oder immer wieder? ich gehe von einmal aus. sonst geht das ja gar nicht, dann bräuchte man ja DIN-A3 papier...

Nach Aufgabenstellung werfen die jährlich was ab. Aber da die Aufgabe ja nochmal à la Vorlesung das schöne Schneeballsystem verdeutlichen soll und sich ja auch direkt auf Rekursionsprobleme beziehen soll, ist davon auszugehen, dass die nciht ganz zu fruchrtbar sind.
So oder so muss der Tuppes sich ja sein restliches Leben von Bananen ernähren

Mit "binnen eines Jahres" ist hier "binnen des ersten Jahres" gemeint. Ansonsten würde sich die Rekursive Implementation auch etwas verkomplizieren. War wohl etwas undeutlich formuliert.

 

[SlaterB]

wieso sagst du dass bei mir eine Endlosschleife kommt?
du musst das doch nur kopieren und ausführen und es hört irgendwann auf,
ganz bestimmt

anderenfalls bitte Hinweise geben

---------

der Fehler:
du hast die Klasse von Tingel Banane3 genannt, die Operationsaufrufe heißen aber weiter Banane.ableger(int,int,int),

diese Operation wird nun nicht in der Klasse Banane3 sondern in der Klasse Banane gesucht, die eine solche Operation natürlich nicht hat,

daher vielleicht auch die Endlosschleife in meinem Programm, falls du das Banane2 genannt hast

merke: am besten Programme nur kopieren und erstmal nicht umbenennen oder sonstwas,
dann siehst du dass sie eigentlich laufen

 

[LioGetz]

Man, bin ich ne hohle Nuss (Banene ?! )...

Yes, jetzt hats geklappt. Ich dachte man müsste einfach nur den Klassennamen ändern, und gut ist...aber wenn da natürlich irgendwelche Objektzugriffe passieren kann das ja nicht klappen. Danke!
Nichtsdestotrotz sollte ich mich mit dem Thema wohl noch etwas beschäftigen...es ist zwar schön nen funktionierenden Code zu haben, und es auch nachvollziehen zu können, aber nächste Woche muss ich den Kram ja auch alleine hinbekommen...

CU
Lio

 

[tingel]

[...]
Und der Tingel-Code lässt sich nicht kompilieren wegen folgenden Fehlermeldungen:

>javac *.java
Banane3.java:8: ableger(int) in Banane cannot be applied to (int,int,int)
    Banane.ableger(startJahr,anzahlJahre,anzahlEltern);
          ^
Banane3.java:18: ableger(int) in Banane cannot be applied to (int,int,int)
        Banane.ableger(++jahre,anzahlJahre,1);
              ^
Banane3.java:22: ableger(int) in Banane cannot be applied to (int,int,int)
        Banane.ableger(++jahre,anzahlJahre,(kinder+anzahlEltern));
              ^
3 errors
>Exit code: 1

[...]

Ich denke SlaterB hat deine Frage schon beantwortet, oder?

 

[Guest]

Ich überlege mir immer folgendes:
1. Was ist mein Startwert? -> In diesem Fall 3 Jahre
2. Was ist mein Abbruchwert für die Rekursion -> Jahreszahl 0
3. Was gebe ich beim Abbruch als Returnwert? -> 1. Pflanze
4. Wie ist der "weitere" Algorithmus? -> Eltern+Kinder -> Eltern+Eltern*3

Daraus ergibt sich dann folgender Code:

public class Banane {
  
  public static void main(String args[]) {
    int a = Banane.ableger(3);
  }
  
  public static int ableger(int jahre) {
    if(jahre==0) {
      return 1;
    } else {
      int ableger = Banane.ableger(--jahre);
      System.out.println(jahre+". Jahr: "+ableger+" Pflanzen");
      return ableger+ableger*3;
    }
  }
}

 

[mouk]

@SlaterB

In deinem Code ist ein kleiner logischer Fehler, wenn man nämlich mit (if jahre > 0) testet statt mit (while jahre > 0) wirft jede Pflanze nur einmal Nachkommen, und nicht 1 mal pro Jahr.

fg, mouk

 

[SlaterB]

das ist kein logischer Fehler sondern (meiner Meinung nach) eine etwas schönere Aufteilung,
denn statt 3x wird ja nun 4x der Ableger aufgerufen,

die weiteren while-Schleifendurchgänge sind also in einem 4. Ableger-Aufruf gekapselt