- Welche Rückgabe liefert der Aufruf print(wasPassiert(A,3,99))?

Question

Anhand des unten gezeigten Codes soll folgende Frage beantwortet werden:

- Liste gegeben: A -> [8,99,false] -> [4,99,false] -> [8,10,false] -> [10,8,false] -> [4,10,false] -> [4,3,false] -> [3,4,false] -> nil

- Welche Rückgabe liefert der Aufruf print(wasPassiert(A,3,99))?

Ich verstehe die erste Prozedur push und die zweite Funktion get so, dass zunächst eine neue Liste anhand der gegebenen Werte erstellt und aufgerufen wird.

Die dritte Funktion wasPassiert soll zunächst nach meinem Verständnis immer aus dem zweiten Zahlenwert und dem Wert true eine neue Liste B erstellen. Mir ist jedoch schleierhaft, wozu die Abfrage

if (B <> nil) then
       B := B^.next;
     if (B = nil) then 
       akt := 0
     else 
       akt := B^.zu 

dienen soll. Wenn B=nil, dann ist das Ende der Liste erreicht. Weiter verstehe ich es nicht. Ist diese Abfrage überhaupt nötig?

Bei der letzten Prozedur print verzweifle ich vollkommen. Hier stehe ich völlig auf dem Schlauch.

Code:

type 
tRefKante = ^tKante;
tKante = record
          von: integer;
          zu: integer;
          x:boolean; 
          next: tRefKante
        end;

procedure push(inVon:integer; inZu:integer; var ioG:tRefKante);
  var
  n:tRefKante;
begin 
  new(n);
  n^.von := inVon;
  n^.zu := inZu;
  n^.x := false;  
  n^.next := ioG;
  ioG := n
end;

function get(inG:tRefKante; inVon:integer):tRefKante;
  var
  n:tRefKante;
begin 
  get := nil;
  n := inG;
  while (n <> nil) do
  begin 
    if ((n^.von = inVon) and (not n^.x)) then
      get := n;
    n := n^.next;
  end;
end;

function wasPassiert(inG:tRefKante; inVon:integer; inZu:integer):tRefKante;
  var
  akt:integer;
  kante:tRefKante;
  B:tRefKante;
begin 
  akt := inVon;
  B := nil;
  while ((akt <> inZu) and (akt <> 0)) do 
  begin
    kante := get(inG,akt);
    if (kante <> nil) then
    begin
      push(B,kante^.von,kante^.zu);
      akt := kante^.zu;
      kante^.x := true
    end
    else
    begin
      if (B <> nil) then
        B := B^.next;
      if (B = nil) then 
        akt := 0
      else 
        akt := B^.zu
    end;
  end;
  wasPassiert := B
end;

procedure print(inGraph:tRefKante);
  var
  e,f : tRefKante; 
begin 
  e := inGraph;
  while (e^.next <> nil) do 
  begin
    e := e^.next;
  end;
  write('[',e^.von, ',', e^.zu,']');
  while (e <> inGraph) do
  begin
    f := inGraph;
    while (f^.next <> e) do 
    begin
      f := f^.next
    end; 
    write('[',f^.von, ',', f^.zu,']');
    e := f 
  end;
end;

Comments

Hast du in Erwägung gezogen, einen Pascal-Compiler zu installieren und diesen zu verwenden um den Quelltext zu compiieren?

---

Jupp, das habe ich bereits versucht. Habe einen Onlinecompiler verwendet. Nur kommen die folgenden Fehlermeldungen:

Compiling main.pas
main.pas(60,34) Error: Call by var for arg no. 3 has to match exactly: Got "SmallInt" expected "tRefKante"
main.pas(98) Fatal: Syntax error, "BEGIN" expected but "end of file" found
Fatal: Compilation aborted
Error: /usr/bin/ppcx64 returned an error exitcode

Vor allem der Syntax error bereitet mir Kopfzerbrechen. Das Programm erwartet noch irgendwas nach den ganzen Prozeduren/Funktionen, denn mit einem einfachen "begin - end." gibt es sich nicht zufrieden.

Answer 1

Antwort mit KI erzeugt

Erklärung des Codes und der Funktion wasPassiert

Zuerst eine kurze Erklärung der einzelnen Teile des Codes:

- Die Prozedur push fügt ein neues Element an den Beginn der Liste hinzu. Dabei werden die Werte für von, zu, und x (hier immer false) gesetzt, und das neue Element wird als neuer Listenkopf eingestellt.
- Die Funktion get durchsucht die Liste, beginnend mit dem Kopfelement inG, nach dem ersten Element, dessen von-Feld dem Wert inVon entspricht und dessen x-Feld false ist. Die Suche stoppt, sobald ein passendes Element gefunden oder das Ende der Liste erreicht ist.
- Die Funktion wasPassiert verwendet die Funktion get, um durch die Liste zu navigieren, und verwendet push, um eine neue Liste B aufzubauen.

Die dritte Funktion wasPassiert funktioniert generell so:

1. Beginnend mit akt := inVon wird die Liste durchlaufen, indem mittels get immer das nächste Element basierend auf dem aktuellen zu Wert von akt gefunden wird.
2. Jedes gefundene Element wird mittels push in eine neue Liste B eingefügt, und sein x Wert wird auf true gesetzt, um anzuzeigen, dass dieses Element bereits besucht wurde.
3. Dies wird solange wiederholt, bis entweder das Ziel inZu erreicht ist oder kein weiteres Element (über get) gefunden werden kann (d.h., kante ist nil).

Die fragliche Abfrage:

pascal
if (B <> nil) then
    B := B^.next;
if (B = nil) then 
    akt := 0
else 
    akt := B^.zu

Diese Logik erscheint tatsächlich problematisch, da sie in jedem Fall (sobald B einmal nicht nil ist und falls kein passendes nächstes Element vorhanden ist) B immer auf das zweite Element in der Liste (oder nil, falls die Liste nicht lang genug ist) setzt, was möglicherweise nicht die beabsichtigte Logik ist. Insbesondere wird der Teil akt := B^.zu selten (wenn überhaupt) erreicht, da dies erfordern würde, dass B genau ein Element hat. Diese Logik erscheint somit unlogisch im Kontext der gewünschten Funktionsweise.

Was die Funktion print angeht:

Die Funktion print soll offensichtlich die Liste in der Reihenfolge vom letzten Element bis zum ersten ausgeben. Sie navigiert zuerst bis zum Ende der Liste und gibt dann rückwärts jedes Element aus, indem sie für jedes e das Element f von vorne bis e durchläuft.

Bezüglich der Fragestellung nach der spezifischen Ausgabe von print(wasPassiert(A,3,99)):

Ohne eine vollständige Definition der wasPassiert mit der fraglichen Logik kann die genaue Ausgabe nicht ermittelt werden, insbesondere ohne eine klare Beschreibung oder Implementierung der Initialisierung und Manipulationen der Liste A. Ausgehend von der Beschriebenen Veränderung der Liste A wäre jedoch ein tiefergehendes Verständnis dieser Logik und des Kontextes notwendig, um ohne konkrete Implementierungsdetails die genaue Ausgabe von print auf wasPassiert festzustellen.