Caeser Verschlüsselung

[SirMaurice]

Hallo, ich bin's mal wieder.

Ich muss ein Programm schreiben welches die Zeichen eines Strings um 'key' Stellen verschiebt. Also wenn der 'key' ein B ist wird aus einem A ein B. Soweit klappt das auch, also für einzelne Zeichen. Da kommt auch mein Problem. Ich verstehe nicht ganz, wie das Ganze für einen kompletten String gehen soll bzw. wie ich die nun umgewandelten Zeichen zu einem String zusammen schließe.

Mein Code sieht im MOment so aus:

Code:

//-------- GetText (public) --------------------------------------------
function TCaeser.GetText : string;
var
i : integer;
begin
  for i:=1 to length(text) do begin
  //##############################
  text:= chr(ord(text[i]) + key);
  end;
  result:=text;
end;

LG Maurice

[hoika]

Hallo,
und wo ist da jetzt Dein Problem?
Außer dem fehlenden [i].

text[i]:= chr(ord(text[i]) + key);

Und natürlich der Tatsache, dass nach der "Verschlüsselung" der Originaltext text auch weg ist.
Besser wäre eine lokale String-Variable.

[Delphi.Narium]

Delphi-Quellcode:

function TCaeser.GetText : string;
var
i : integer;
begin
  for i := 1 to length(text) do begin
    // Diese Zuweisung ist falsch. Text wir damit durch das erste veränderte Zeichen überschrieben.
    text := chr(ord(text[i]) + key);
  end;
  result := text;
end;

Delphi-Quellcode:

function TCaeser.GetText : string;
var
i : integer;
begin
  for i := 1 to length(text) do begin
    // eventuell so
    text[i] := chr(ord(text[i]) + key);
  end;
  result := text;
end;

Delphi-Quellcode:

function TCaeser.GetText : string;
var
i : integer;
begin
  Result := '';
  for i := 1 to length(text) do begin
    Result := Result + chr(ord(text[i]) + key);
  end;
end;

[DieDolly]

OffTopic

Zitat:

Ich muss ein Programm schreiben welches die Zeichen eines Strings um 'key' Stellen verschiebt.

Psychologisch gesehen, gehst du falsch an die Sache ran.

Sage dir selber, dass du ein solches Programm schreiben darfst und nicht musst. Dann geht vieles leichter.

[SirMaurice]

Zitat:

Hallo,
und wo ist da jetzt Dein Problem?

Das [i] hatte ich vergessen, danke dafür schonmal.
Das Problem ist, dass wenn ich einen "Key:= ord(Z) - 65" habe, also die Verschiebung 25 Stellen beträgt und dies mit der Lösung aus der anderen Antwort berechne ein Zeichen "[" rauskommt, es sollte jedoch ein "B" sein.
Ich müsste also jedes mal ein neues Alphabet hinten dranhängen, wenn "ord(text[i]) + key" größer als "ord([)" , also 91, wird.

Das könnte man theoretisch mit einer if-Anweisung umsetzen, ich weiß nun nur nicht, wie ich das zu einer vernünftigen Lösung mit der Form "Result:=" verarbeite.

[DieDolly]

[QUOTE=SirMaurice;1428802]

Zitat:

Das Problem ist, dass wenn ich einen "Key:= ord(Z) - 65" habe, also die Verschiebung 25 Stellen beträgt und dies mit der Lösung aus der anderen Antwort berechne ein Zeichen "[" rauskommt, es sollte jedoch ein "B" sein.

Wenn ich zum Testen

Delphi-Quellcode:

Caption := Chr(Ord('Z') - 25)

ausführen lasse, erhalte ich ein A. Weder ein B noch ein [.
Der Fehler liegt also woanders. Und außerdem. Warum -65? Um von ASCII Z (90) auf Ascii A zu kommen, rechnet man -25.

[SirMaurice]

Ich möchte ja nicht Z - 25 rechnen sondern der Key ist Z, also 25 Stellen Verschiebung. Zudem wird der Key ja hinzuaddiert und nicht subtrahiert.
Das Problem ist jetzt aber wenn der Key 25 beträgt und man z.B. ein B verschlüsseln möchte, rechnet man den ASCII-Wert von B, also 66, plus den Key, also 25,
dies ergibt dann 91 und somit ein "[".

[Delphi.Narium]

Wenn bei Key = B aus dem A ein B werden soll, so ist die Differenz = 1.

Ord('A') = 65
Ord('B') = 66

Ord('B') - Ord('A') = 1

Du musst also die Differenz zwischen Ord(Key) und Ord('A') berechnen und zu Ord(text[i]) addieren, also nicht Ord(text[i]) + Key sondern Ord(text[i]) + Ord(key) - Ord('A').

Und natürlich wird Z + Ord(Key) immer ein Zeichen "hinter" den Großbuchstaben ergeben.

Wenn also aus Z + Key -> A werden soll, also ein Buchstabe, dessen Ord < Ord('Z') ist, dann musst Du Dir überlegen, welchen Wert Du dann abziehen musst, um von Ord('Z') -> 90 plus Ord(Key) auf Ord('A') -> 65 zu kommen.

Delphi-Quellcode:

function TCaeser.GetText : string;
var
  i : integer;
begin
  Result := text;
  for i := 1 to Length(Result) do begin
    Result[i] := Chr(Ord(Result[i]) + (Ord(Key) - Ord('A')));
    if Ord(Result[i]) > Ord('Z') then Result[i] := Chr(Ord(Result[i] - (Ord('Z') - Ord('A')));
  end;
end;

PS: Das ist jetzt nur hingedaddelt, keine Ahnung ob's auch korrekt ist.

[hoika]

Hallo,
du musst da schon noch ein if reinpacken,
sowas wie

Delphi-Quellcode:

var
  j: Integer,  // oh Gott, i und j ;)


  j:= Ord(text[i]);
  if j<=was_weis_ich then
  begin
    j:= was_weiss_ich_2;
  end;
  j:= j-25;

Damit bekommst Du dein "Ring-Alphabet".

Geh doch das einmal auf einem Blatt Papier durch.
'A'->'Z', Ord('A)=, Ord('Z')

Schreib alles auf und dann weiter mit dem if.

[Luckie]

Kurz, dein Problem ist der Übertrag. Überlege dir wie du feststellst, wann es zu einem und was du dann machen musst.

[SirMaurice]

Also nach ein paar motivierenden Sprüchen und ein paar Rendez-vous mit der ASCII-Tabelle, bin ich auf folgende Lösung gekommen.
Ich bedanke mich bei allen die mir beigestanden haben. :-D

Delphi-Quellcode:

function TCaeser.GetGeheimtext : string;
var
i : integer;
begin
  Result := '';
  for i := 1 to length(text) do begin
    if ord(text[i]) + key > ord('Z') then
    Result:= Result + chr(ord(text[i]) + key - 26)
    else
    Result := Result + chr(ord(text[i]) + key);
  end;
end;

[DieDolly]

Zitat:

Radezvous

Der Richtigkeit halber. Es heißt Rendez-vous :thumb: