Autor Beitrag
German_Voice
Hält's aus hier
Beiträge: 2



BeitragVerfasst: Fr 05.12.14 22:39 
Ich bin neu in der Informatik und habe ein Problem mit dem Berechnen der Türme von Hanoi in Lazarus als Quelltext. Kann mir jemand helfen?
Xion
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
EE-Maler
Beiträge: 1952
Erhaltene Danke: 128

Windows XP
Delphi (2005, SmartInspect), SQL, Lua, Java (Eclipse), C++ (Visual Studio 2010, Qt Creator), Python (Blender), Prolog (SWIProlog), Haskell (ghci)
BeitragVerfasst: Fr 05.12.14 23:33 
:welcome:
Klar können wir dir helfen, allerdings nur, wenn du eine konkrete Frage hast.
:arrow: Was möchtest du genau berechnen? "Berechnen der Türme von Hanoi" ist keine sehr präzise Aufgabenstellung :)
:arrow: Was hast du schon versucht und an welcher Stelle kommst du nicht weiter?
Wir helfen gerne, aber niemand wird dir hier ein komplettes Programm schreiben (von dem ich wie gesagt im Moment auch garnicht wüsste, was es überhaupt machen soll).

Wenn du allgemein Probleme beim Herangehen an das Problem hast, dann gucke dir deine Aufgabenstellung nochmals genau an. Ermittle, was gegeben ist, und was gesucht. Überlege dir dann, wie du bei der Lösung schrittweise im echten Leben vorgehen würdest und schreibe dies grob umgangssprachlich auf. Hierbei ist besonders die Reihenfolge wichtig. In etwa so, als ob du einem Kleinkind erklären müsstest, wie die Berechnung abläuft. Nun ist der Computer leider viel dümmer als jedes Kleinkind und du musst es noch genauer und detaillierter aufschreiben. Wenn du dann dein Vorgehen so exakt in "Pseudocode" aufgeschrieben hast, dann kannst du es auch relativ leicht in Lazarus umsetzen.
Der eigentlich schwierige Schritt ist meist nicht das Programmieren in Lazarus, sondern das exakte formulieren der Vorgehensweise ganz allgemein. Das ist auch der Grund, warum die Lösung immer logisch erscheint, das finden der Lösung jedoch vor allem dem Anfänger sehr schwer fällt. Ähnlich zur Mathematik, bei der man in der Schule leider die Lösung ausnahmslos immer vorgekaut bekommt.
Wir helfen dir gerne in jedem der Schritte weiter, wenn du konkrete Fragen hast. Solltest du jemanden suchen, der dir eine Hausaufgabe programmiert, dann versuche es in der Jobbörse...aber ich bezweifle, dass du genug zahlen willst :)

_________________
a broken heart is like a broken window - it'll never heal
In einem gut regierten Land ist Armut eine Schande, in einem schlecht regierten Reichtum. (Konfuzius)
ub60
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 638
Erhaltene Danke: 69



BeitragVerfasst: Sa 06.12.14 14:20 
Ich glaube, das Problem ist hier eher der Pseudocode.
Das Zauberwort heißt hier "Rekursion", das heißt, dass sich ein Unterprogramm im Verlauf seiner Abarbeitung immer wieder selbst aufruft.

Nun die Überlegungen:
  1. Ich möchte alle Bewegungen der Scheiben notieren, darf aber immer nur eine Scheibe bewegen. Also reicht es, wenn ich aufschreibe, von welchem Platz (z.B. Platz A) ich eine Scheibe an welchen Platz (z.B Platz B) bewege.
  2. Ich notiere also in meinem Unterprogramm nur, wenn ich eine Scheibe bewege.
  3. Angenommen, ich soll mehr als eine Scheibe bewegen (also N Scheiben von A nach B), so bewege ich die obersten N-1 Scheiben (Wie ich das mache, wird gleich erklärt) von A nach C, bewege die eine Scheibe (Das darf ich ja.) von A nach B und bewege wieder die obersten N-1 Scheiben (Siehe nächster Punkt!) von C nach B.
  4. Und wie bewege ich nun aber N-1 Scheiben? Ganz einfach, ich nehme N-2 Scheiben, lege sie ab, bewege die erlaubte eine Scheibe und staple dort die N-2 Scheiben drauf.
  5. Und wie bewege ich nun aber N-2 Scheiben? Ganz einfach, ich nehme N-3 Scheiben, ... und so weiter ...
  6. Das programmiere ich natürlich nicht N mal, sondern ich rufe jeweils das Unterprogramm wieder mit entsprechenden Parametern auf.
  7. Die 4 sinnvollen Parameter wären: Anzahl der Scheiben, Startposition, Endposition und Hilfsposition.


Und jetzt noch der Lazarus-Quelltext:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
procedure Bewege(N: Integer; A, B, C : Char);
begin
  // Der Rest steht ja schon oben...
end;


Aufgerufen wird das Ganze dann zum Beispiel mit:
ausblenden Delphi-Quelltext
1:
Bewege(5'A''B''C');					


Ich hoffe, das hilft etwas beim Probieren und vor Allem beim Verstehen der Rekursion.

ub60
Fiete
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 449
Erhaltene Danke: 161

W7
Delphi 6 pro
BeitragVerfasst: Sa 06.12.14 17:53 
Moin German_Voice,
in meinem DOS-Archiv habe ich dies gefunden:
ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
PROGRAM TUERME_VON_HANOI_NACH_WB;
 USES CRT;
 CONST MAX=10;SPERRE=100;
 VAR T:ARRAY[1..3,1..MAX]OF BYTE;(* DREI TüRME *)
     A:ARRAY[1..3]OF BYTE;       (* SCHEIBENZAHL PRO TURM *)
     SCHEIBE,I,J,N,N1,K,L,X,Y:BYTE;
     Z:INTEGER;
 PROCEDURE NEHMEN(VAR SCHEIBE:BYTE;R:BYTE);
  VAR I:BYTE;
  BEGIN
   SCHEIBE:=T[R,1];
   FOR I:=1 TO A[R]-1 DO T[R,I]:=T[R,I+1];
   T[R,A[R]]:=SPERRE;A[R]:=PRED(A[R])
  END;
 PROCEDURE LEGEN(SCHEIBE,R:BYTE);
  VAR I:BYTE;
  BEGIN
   FOR I:=A[R] DOWNTO 1 DO T[R,I+1]:=T[R,I];
   T[R,1]:=SCHEIBE;A[R]:=SUCC(A[R])
  END;
 BEGIN(* OF MAIN *)
  REPEAT
   CLRSCR;WRITE('Wieviele Scheiben (1-',MAX,') ? ');READLN(N)
  UNTIL N IN[1..MAX];
  FOR I:=1 TO N DO T[1,I]:=I;A[1]:=N;(* 1. TURM *)
  FOR I:=2 TO 3 DO
   FOR J:=1 TO N DO T[I,J]:=SPERRE;
  A[2]:=0;A[3]:=0;J:=1;Z:=1;N1:=1;IF N MOD 2=0 THEN N1:=2;
  NEHMEN(SCHEIBE,J);K:=J;J:=J+N1;IF J>3 THEN J:=J-3;
  WRITELN(Z:4,') Scheibe  1 von Turm ',K:2,' nach Turm',J:2);
  WHILE T[1,1]<>T[3,1DO
  BEGIN
   L:=6-J-K;LEGEN(SCHEIBE,J);
   IF T[K,1]>T[L,1THEN BEGIN X:=K;Y:=L END ELSE BEGIN X:=L;Y:=K END;
   NEHMEN(SCHEIBE,Y);Z:=SUCC(Z);
   WRITELN(Z:4,') Scheibe',SCHEIBE:3,' von Turm ',Y:2,' nach Turm',X:2);
   LEGEN(SCHEIBE,X);NEHMEN(SCHEIBE,J);Z:=SUCC(Z);
   K:=J;J:=J+N1;IF J>3 THEN J:=J-3;
   WRITELN(Z:4,') Scheibe  1 von Turm ',K:2,' nach Turm',J:2)
  END;
  WRITELN;WRITELN(Z:4,'-mal habe ich geschleppt !')
 END.

oder rekursiv
ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
{ Nach einer alten Legende standen drei goldene S„ulen vor dem Tempel     }
{ von Ankorvat. Auf einer S„ule befanden sich 100 goldene Scheiben,       }
{ jedesmal eine kleinere auf einer gr”áeren Scheibe. Ein alter M”nch      }
{ bekam die Aufgabe, den Scheibenturm von S„ule 1 nach S„ule 2 unter      }
{ folgenden Bedingungen zu transportieren :                               }
{  - Es darf jeweils nur die oberste Scheibe von einem Turm genommen      }
{    werden.                                                              }
{ - Es darf niemals eine gr”áere Scheibe auf einer kleineren liegen.      }
{ Wenn der M”nch seine Arbeit erledigt habe, so berichtet die Legende     }
{ dann werde das Ende der Welt kommen.                                    }
{ Belastet mit dieser schweren Aufgabe setzte sich der alte M”nch in      }
{ seinen Tempel und meditierte. Schon bald sah er ein, daá zur Erledi-    }
{ gung seiner Aufgabe auch S„ule 3 ben”tigt wurde. Er dachte und          }
{ meditierte weiter, bis ihm die g”ttliche Erleuchtung kam. Die           }
{ Aufgabe konnte in drei Schritten gel”st werden :                        }
{ Schritt 1 : Transportiere den Turm, bestehend aus den oberen 99         }
{             Scheiben, von S„ule 1 nach S„ule 3.                         }
{ Schritt 2 : Transportiere die letzte, gr”áte Scheibe von S„ule 1        }
{             nach S„ule 2.                                               }
{ Schritt 3 : Transportiere zum Schluá den Turm von 99 Scheiben,          }
{             von S„ule 3 nach S„ule 2.                                   }
                                                                      
PROGRAM HANOI_REKURSIV;
 USES CRT;
 VAR ANZAHL:BYTE; TASTE:CHAR;
 PROCEDURE LEGE(N,TURM1,TURM2,TURM3:BYTE);
  BEGIN
   IF N>1 THEN LEGE(N-1,TURM1,TURM3,TURM2);
   WRITELN('Scheibe ',N,' von Turm ',TURM1,' nach Turm ',TURM2);
   IF N>1 THEN LEGE(N-1,TURM3,TURM2,TURM1)
  END;
 BEGIN
  CLRSCR;WRITE('Scheibenanzahl (1-9) : ');
  REPEAT
   GOTOXY(24,1);READLN(ANZAHL)
  UNTIL ANZAHL IN[1..9];WRITELN;
  LEGE(ANZAHL,1,2,3);
  WRITE('Fertig!');TASTE:=READKEY
 END.

Viel Spaß beim Studium
Gruß Fiete

_________________
Fietes Gesetz: use your brain (THINK)
ub60
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 638
Erhaltene Danke: 69



BeitragVerfasst: Sa 06.12.14 20:33 
@Fiete:
Gib es zu, das hattest Du noch auf Lochstreifen. :lol:

ub60
Fiete
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 449
Erhaltene Danke: 161

W7
Delphi 6 pro
BeitragVerfasst: So 07.12.14 11:03 
Moin ub60,

Zitat:
Gib es zu, das hattest Du noch auf Lochstreifen.

Stimmt fast, es war ein Lochkartenstapel für die TR440 programmiert in ALGOL 60. :wink:
Gruß Fiete

_________________
Fietes Gesetz: use your brain (THINK)