> 3 Türme von Hanoi

[dane]

Hallo,

ich 'programmiere' derzeit die Türme von Hanoi.
Auch wenn es recht unlogisch ist, möchte ich auch eine variable Anzahl an Türmen. Die Methode sieht so aus:

    private static void bewege (String stabA, String stabB, String stabC, int scheibenanzahl)
    {
    	if (scheibenanzahl == 1)
    	{
    		System.out.println("Lege die oberste Scheibe von " + stabA + " auf " + stabC + ".");
    	}
    	else
    	{
    		bewege(stabA, stabC, stabB, scheibenanzahl-1);
    		bewege(stabA, stabB, stabC, 1);
    		bewege(stabB, stabA, stabC, scheibenanzahl-1);
    	}
    }

also rekursiv. Wie kann ich das mit den Parametern am besten lösen? Vielen Dank!

 

[Cypha]

Es gibt die sogenannten "varargs", die müssen dann aber hinten stehen:

 private static void bewege (int scheibenanzahl, String... staebe)
    {
        // mach was mit staebe, welches ein String Array ist
    }

 

[dane]

Das übersteigt jetzt meinen Horizont. Wie genau ist da der Ablauf? Auch im inneren der Methode. Ich hab' echt keinen Schimmer, wie ich das vernünftig hinbekommen soll. Danke

 

[faetzminator]

dane, [c]String...[/c] ist fast das gleiche wie [c]String[][/c], allerdings kann es immer nur auf den letzten Parameter angewendet werden.
Wenn du [c]foo(String[])[/c] aufrufen willst, musst du [c]foo(new String[] {"bla", "blubb"})[/c] schreiben. Bei [c]foo(String...)[/c] geht letzteres (Übergabe eines Arrays), aber auch [c]foo("bla", "blubb")[/c].
Intern kannst du dann [c]String...[/c] als normales Array mit for oder for-each prozessieren.

 

[dane]

    	String[] staebe = new String[stabanzahl];
    	
    	for(int i = 0; i < stabanzahl; i++)
    	{
    		staebe[i] = "Stab: "+i+"";
    		System.out.println(staebe[i]);
    	}
    	
    	bewege(scheibenanzahl, staebe[]);
    	
    	
    }
	
    private static void bewege (int scheibenanzahl, String ...staebe)
    {

    	if (scheibenanzahl == 1)
    	{
    		System.out.println("Lege die oberste Scheibe von " + stabA + " auf " + stabC + ".");
    	}
    	else
    	{
    		bewege(scheibenanzahl-1, stabA, stabC, stabB);
    		bewege(1, stabA, stabB, stabC);
    		bewege(scheibenanzahl-1, stabB, stabA, stabC);
    	}
    }

funktioniert ned wirklich, wobei ich das jetzt wirklich nicht verstehe. :rtfm::rtfm::rtfm:

 

[AquaBall]

funktioniert ned wirklich, wobei ich das jetzt wirklich nicht verstehe.

staebe[]

kannst du natürlich nicht mehr mit

stabA

, stabB ... ansprechen, sondern "nur mehr" mit

staebe[0]

, staebe[1], ... und hier eben beliebig viele.
Aber *Rüge* und *ZeigefingerWink* das sagt dir ja der Compiler! "Funktioniert ned wirklich" ist keine Fehlerbeschreibung.


Andererseits brauchst du ja keine "variable" Anzahl von Parametern, sondern genau 2 Fälle.
Und das ist ja eine der Spezialitäten von Java, dass du den selben Namen mit unterchiedlicher Par-Anzahl definieren kannst.

Ca. so (ungeprüft!, vorallem bez. Logik):

    private static void bewege (String stabA, String stabB, String stabC, int scheibenanzahl)
    {
        if (scheibenanzahl > 1)
        {
            bewege(stabA, stabC, stabB, scheibenanzahl-1);
            bewege(stabA, stabC);
            bewege(stabB, stabA, stabC, scheibenanzahl-1);
        }
    }

    private static void bewege (String stabA, String stabC)
    {
        System.out.println("Lege die oberste Scheibe von " + stabA + " auf " + stabC + ".");
    }

Außerdem ist ja gerade das ein Beispiel dafür, dass zw. bewegeStapel (rekursiv) und bewegeScheibe ("Endzug", nicht rekursiv) ein wesentlicher Unterschied ist. (Wie meisten bei einem rekursiven Ansatz.)

[EDIT]
Und eigentlich - so aus dem Bauch heraus, ohne lang zu überlegen, - sollte auch so was gehen,
Eleganter wär's natürlich:
(Noch immer ungeprüft!, vielelicht brauchts noch ein if.)

    private static void bewege (String stabA, String stabB, String stabC, int scheibenanzahl)
    {
        if (scheibenanzahl > 0)
        {
            bewege(stabA, stabC, stabB, scheibenanzahl-1);
            System.out.println("Lege die oberste Scheibe von " + stabA + " auf " + stabC + ".");
            bewege(stabB, stabA, stabC, scheibenanzahl-1);
        }
    }

[/EDIT]

 

[dane]

    	String[] staebe = new String[stabanzahl];
    	
    	for(int i = 0; i < stabanzahl; i++)
    	{
    		staebe[i] = "Stab: "+i+"";
    		//System.out.println(staebe[i]);
    	}
    	
    	
    	
    	bewege(scheibenanzahl, staebe);

    }
	
	private static void bewege (int scheibenanzahl, String... staebe)
    {
        if (scheibenanzahl > 0)
        {
            bewege(scheibenanzahl-1, staebe);
            System.out.println("Lege die oberste Scheibe von " + staebe + " auf " + staebe + ".");
            bewege(scheibenanzahl-1, staebe);
        }
    }

funktioniert leider noch immer nicht. Die Funktionsweise ist mir da echt ein Rätsel. :rtfm::rtfm::rtfm::rtfm::rtfm::rtfm:

 

[SlaterB]

tja, ein Rätsel löst sich nicht von selber,
du kannst doch nicht addieren(Liste von Zahlen) durch rekursiven Aufruf addieren(dieselbe Liste) lösen..,
irgendwann musst du schon mal eine Zahl rausnehmen, den Rest addieren lassen und die gewählte Zahl dazuaddieren,
falls dir dieses Rekursionsbeispiel etwas sagt,

Türme von Hanoi mit beliebig vielen (edit: Türme, gestrichen: Scheiben) ist ein komplexes Programm welches eine Reihe von durchdachten Code-Zeilen erfordert,
auf alle zu verzichten und nur als Parameter ein Array zu setzen, das bleibt in der Tat ein ungelöstes, eben UNBEARBEITETES Rätsel..,
wenn du wenigstens die Reihenfolge im Parameter-Array ändern würdest, so wie vorher die einzelnen Parameter tauschen

übrigens:
What a difference a peg makes: 4 peg Tower of Hanoi ? Republic of Mathematics blog

4 peg Tower of Hanoi puzzle

So much for the 3-peg Tower of Hanoi problem.

But what if we add another peg?

Surely we can do more or less what we already did?

As it turns out – no we can’t.

 

[dane]

Danke. Kann mir mal jemand den richtigen Code posten? Ich komme nicht drauf, sitze schon den ganzen Tag vor dem Problem. Mir fehlt halt das 'Entwicklergen'.:bahnhof:

 

[SlaterB]

die Frage ist in all ihrer Dreistigkeit natürlich gestattet,

um selber genauso deutlich zu werden aber nochmal meine Antwort:
ich habe den Eindruck, dass dies ein komplexes Problem ist, zu dem im ganzen Internet kaum eine Lösung zu finden ist,
insofern wirst du es hier auch nicht große Chancen haben, ich kann mich aber natürlich irren

ein Link noch:
algorithm - Towers of Hanoi with K pegs - Stack Overflow

und als Suchvorschlag: 'tower of hanoi multi-peg'

 

[DaveIT]

Das tolle am programmieren ist es doch sich selbst lösungen zu erarbeiten.
Ich glaube du stehst nicht unbedingt vor einem programmierproblem sondern eher vor einem mathematischen. den mit 3 türmen haben wir eine rekursive vorgehensweise die leicht zu verstehen ist. wenn du aber die anzahl der türme >3 setzt steigt die anzahl der anwendbaren lösungen. z.B:

4 türme, vier scheiben - die erste scheibe hat also statt einem gleich 2 startpunkte. usw.

nimm dir zeit und schau dir verschiedene konstellationen an. 5 türme, 10 scheiben usw...
wenn du erst einmal die logik herausgefunden hast wird das progammieren ein leichtes sein.

 

[hüteüberhüte]

Wenns nicht weiter stört, und alle Scheiben ohnehin auf einen Stab befinden, dann könntest du auch einfach immer nur 3 Stäbe benutzen, um den Turm zu verschieben. Ansonsten hat das wie erwähnt nicht viel mit Programmierung zu tun