Hallo Leute,

hab mal ne Bitte an euch: Auf Arbeit hab ich die Aufgabe bekommen den rekursiven Algorithmus zu den Türmen von Hanoi zu schreiben.

Jetzt hab ich schon einiges probiert, hatte aber keinen Erfolg.

Hier also meine Bitte an euch: Wenn ihr einen rekursiven Algorithmus hab oder ihn mal schreiben könntet, dann postet in mir hier bitte mal.

Vorgaben sind nur das er rekursiv seien muss und in c# programmiert. Ansonsten lass ich euch freie Hand.

Wenn ihr mir also helfen könntet dann bitte, lass euch nicht aufhalten.

Danke schonmal im vorraus für alle antworten die mir irgentwie weiterhelfen.

Das Forum ist nicht dazu da, dass du hier deine Aufgaben von jemand anderem erledigen lassen kannst.

Wir helfen dir gern bei konkreten Problemen, aber du musst schon Eigeninitiave zeigen. Zeig, was du dir überlegt hast, und wir sagen dir, was falsch ist.

Du weist aber schon wie der Algorithmus funktioniert, oder?

Gut.

Hier wie vom Admin gefordert der bisherige Quellcode + genauere Fehlerbeschreibung:

class Program

    {

        static int x;


        static int[][] Turmarray = new int[3][];


        static void Main(string[] args)

        {

            x = 4;


            Turmarray[0] = new int[x];

            Turmarray[1] = new int[x];

            Turmarray[2] = new int[x];


            Start();


            Verschiebe(0, 1);

        }


        static void Start()

        {

            int temp = x;


            for (int i = 0; i < x; i++)

            {

                Turmarray[0][i] = temp;


                temp--;

            }

        }


        static void Verschiebe(int p_VonTurm, int p_NachTurm)

        {

            int a;

            int b;

            int c = 0;

            int d = 1;

            int Von = 0;

            int Nach = 0;


            a = SucheObersteScheibe(Turmarray[p_VonTurm]);

            b = SucheObersteScheibe(Turmarray[p_NachTurm]);

            if (Turmarray[p_NachTurm][0] != 0)

            {

                 b = b - 1;

            }

            if (Turmarray[p_VonTurm][0] != 0)

            {

                a = a - 1;

            }

            Von = Turmarray[p_VonTurm][a];

            Nach = Turmarray[p_NachTurm][b];


            if (p_VonTurm == p_NachTurm)

            {

                d++;

                Verschiebe(c, d);

            }

            else if (Von != 0 && Von < Nach || Turmarray[p_NachTurm][0] == 0)

            {

                SchreibeÄnderung(p_NachTurm, p_VonTurm, a, ;

                c++;

                Verschiebe(c, d);

	}

            else

	{

                Befehle(p_VonTurm, p_NachTurm, a, b );

	}

        }


        static int SucheObersteScheibe(int[] p_Turm)

        {

            int i = 0;


            while (i < p_Turm.Length && p_Turm[i] != 0)

            {

                i++;

            }


            return i;            

        }


        static void SchreibeÄnderung(int p_NachTurm, int p_VonTurm, int a, int 

        {

            if (Turmarray[p_NachTurm][0] != 0)

            {

                b = b + 1;

            }


            Turmarray[p_NachTurm][b] = Turmarray[p_VonTurm][a];

            Turmarray[p_VonTurm][a] = 0;

        }


        static void Befehle(int p_VonTurm, int p_NachTurm, int a, int 

        {

            int c = p_VonTurm;

            int d = p_NachTurm;


            // Befehl3

            if (p_VonTurm == 0 && Turmarray[p_VonTurm][0] == 0)

	{

	   c++;

                d--;

                d--;

                Verschiebe(c,d);

	}

            // Befehl5 

            else if (Turmarray[p_NachTurm - 1][0] > Turmarray[p_NachTurm][b])

	{

                if (b == 1)

                {

                    c++;

                    c++;

                    d--;

                    d--;

                    Verschiebe(c, d);


                }

                else

                {

                    c++;

                    c++;

                    d--;

                    Verschiebe(c, d);   

                }

	}

            // Befehl4

            else if (Turmarray[p_VonTurm][a] == 0 && Turmarray[p_VonTurm][a] < Turmarray[p_NachTurm][b] )

            {

	   c++;

                Verschiebe(c,d);

	}

            // Befehl2

            else if (p_VonTurm == 0 && p_NachTurm == 2)

	{

                if (Turmarray[1][0] == 0)

                {

                    d--;

                    Verschiebe(c, d);

                }

                else

                {

                    c++;

                    Verschiebe(c,d);

                }

	}

            // Befehl1

            else if (p_VonTurm == 0 && p_NachTurm == 1)

            {

                Verschiebe(c,d);

            }

        }

    }[/code]

Probleme gibts an Folgender "Turm-/ Arraykonstruktion"

4

1 3 2

hier ist es so das er zwar schreiben kann, es aber nicht soll.

Wie kann ich das unterbinden, bzw. mit welcher bedingung kann ich das unterbinden?

Hoffe das ist jetzt besser/ genauer vormuliert.

Hoffe das ist jetzt besser

Könntest du den Algorithmus erklären, der hinter dem Code steckt? Das sieht mir unnötig kompliziert aus.

nagut.

Hier die Erklärung:

Jeder Turm wird von einem Array dargestellt.

Dieses Array befindet sich in einem übergeordnetem Array(der übersicht halber)

mit hilfe der einzelnen Methoden werden bestimmte dinge erledigt

Methode Befehle = in ihr sind die einzelnen Möglichkeiten der Veränderung eingearbeitet

Methode Verschiebe(c,d) = dient als eigentlicher ablaufort für alles was sich ändert

Methode SchreibeÄnderung = dient wieder name schon sagt dazu die änderungen in den Arrays / auf den Türmen darzustellen

Methode SucheobersteScheibe= hat den sinn mir wie der name verrät die position der obersten scheibe zu bestimmen

was soll jetzt passieren - über rekursion sollen die scheiben eine nach der anderen verschoben werden um so vom ersten auf den dritte stapel zu kommen

es wäre noch zu sagen das ich jedesmal wenn ich verschiebe(c,d) aufrufe veränderte übergabeparameter benutze.

hoffe das hilft weiter

Du hast erklärt, welche Aufgaben die einzelnen Programmteile haben, aber wie genau dein Algorithmus aussieht, hast du nicht gesagt.

Man kann das aus dem Code leider nicht erkennen. Mit Variablennamen wie a,b,c,d und Kommentaten wie "Befehl 5" ist das einfach nicht möglich.

Wenn du also möchtest, dass wir dir helfen, Fehler in deinem Algorithmus zu finden, musst du ihn schon erklären.

es wäre noch zu sagen das ich jedesmal wenn ich verschiebe(c,d) aufrufe veränderte übergabeparameter benutze.

hoffe das hilft weiter

Leider gar nicht, wenn man nicht weiß, wofür c und d stehen.

schau Dir doch mal Türme von Hanoi ? Wikipedia an, da ist sogar Pseudocode zu finden. Ansonsten geb ich Klotzkopp recht

die Methode verschiebe hat die aufrufparameter p_VonTurm und p_NachTurm

damit ich diese nicht jedesmal mit definieren muss, habe ich mir die variablen c und d generiert. c steht für p_VonTurm und d steht für p_NachTurm. Sie stellen blos zahlen da, die eben wenn die methode Verschieben aufgerufen wird für p_VonTurm und p_NachTurm übernommen werden. es ist leichter zu handhaben so und vorallem für mich der den code geschriebenhat übersichtlicher. wenn dir die möglichkeit gegeben ist, dann zieh dir den code mal in visual studio 2010 und debug ihn mal durch vllcht wirds dann ersichtlich wie er funktioniert.

wenn nicht stell bitte einfach die fragen klar was du nicht verstehst,damit ich sie beantworten kann.

wenn dir die möglichkeit gegeben ist, dann zieh dir den code mal in visual studio 2010 und debug ihn mal durch vllcht wirds dann ersichtlich wie er funktioniert.

Ich bitte dich die ganze Zeit um eine Erklärung, damit ich genau das nicht tun muss. Warum soll ich (und jeder andere, der hier helfen möchte) "reverse-engineeren", was du einfach (und nur einmal) erklären könntest? Mag sein, dass der Code für dich übersichtlich ist, ich finde das nicht.

Vielleicht willst du deinen Algorithmus nicht erklären, vielleicht kannst du es nicht, egal. Das Problem lässt sich jedenfalls ziemlich elegant in drei Teilprobleme zerlegen:

1. Alle Scheiben bis auf die größte auf einen Zwischenturm

2. Die größte Scheibe auf den Zielturm

3. Alle Scheiben aus 1. auf den Zielturm

Das ist eigentlich schon alles. Schritt 1 und 3 beinhalten eine Rekursion.

ok du klug******er

das du das spiel kennst is ja schonmal von vorteil

aber im endeeffekt weis ich das was du mir da erzählst schon lange und

du hilfst mir net weiter

ich seh schon das das hier nix wird

am besten ich beende das jetzt hier

Geh mal den Abaluf für eine Turmgrösse von 3, 4 und 5 Scheiben durch. Was fällt dir dabei auf?

aber im endeeffekt weis ich das was du mir da erzählst schon lange

Dann muss ich mich fragen, warum du es nicht genauso umsetzt, sondern so etwas kompliziertes zusammenbastelst.

    class Program

    {

        static void Main(string[] args)

        {

            hanoi(1, 2, 3, 12);

        }


        static void verschiebe(int von, int nach, int größe)

        {

            // Verschiebe-Logik, hier Ausgabe als Platzhalter

            Console.WriteLine("Verschiebe Scheibe " + größe + " von " + von + " nach " + nach);

        }


        static void hanoi(int von, int über, int nach, int höhe)

        {

            if (höhe > 0)

            {

                hanoi(von, nach, über, höhe - 1);

                verschiebe(von, nach, höhe);

                hanoi(über, von, nach, höhe - 1);

            }

        }

    }

[/code]