0 Daumen
442 Aufrufe

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;
Avatar von

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.

1 Antwort

0 Daumen

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.
Avatar von 4,6 k

Ein anderes Problem?

Stell deine Frage

Ähnliche Fragen

Willkommen bei der Stacklounge! Stell deine Frage einfach und kostenlos

x
Made by a lovely community