Leerzeichen in Unterstriche umwandeln

[Snow Dragon]

Hallo,
ich hab ein Problem mit Leerzeichen, bzw. dem Umwandeln.
Und zwar schreibe ich gerade an einem Programm was Text im CeasarCode verschüsseln soll, das halt am besten mit Leerzeichen oder Umwandlung der Leerzeichen in _ oder der ähnlichen. Der Quellcode sieht immoment wie folgt aus:

Delphi-Quellcode:

begin
  s:=edein.text;
  sch:=StrToint(lbein.text);
  FOR I:=1 TO length(s) DO
    BEGIN
    c:=s[i];
    case c of
      'A' .. 'Z' : s1 := s1 + c;
      'a' .. 'z' : s1 := s1 + upcase(c);
      'ß'        : s1 := s1 + 'SS';
      'ä'        : s1 := s1 + 'AE';
      'ö'        : s1 := s1 + 'OE';
      'ü'        : s1 := s1 + 'UE';
      'Ä'        : s1 := s1 + 'AE';
      'Ö'        : s1 := s1 + 'OE';
      'Ü'        : s1 := s1 + 'UE';
    END;
    END;
    aus:='';
   for ii:=1 to length(s1) do
    begin
     c:=s1[ii];
     ASCII:=ord(c)+sch;
     aus:=aus+CHR(ASCII);
    end;
edaus.lines.add(aus);
end;

Das ist der Programmteil fürs Verschlüsseln. Wenn ich da allerdings nun einen Satz mir Leerzeichen eingebe kommt unten ein zusammengequetschtes Zeug raus und ist nach dem Entschlüsseln kaum zu lesen.

Freu mic hschon auf eure Beiträge

[mkinzler]

Schau dir mal StringReplace() an

[nahpets]

Hallo,

Zitat von Snow Dragon:

Hallo,
ich hab ein Problem mit Leerzeichen, bzw. dem Umwandeln.
Und zwar schreibe ich gerade an einem Programm was Text im CeasarCode verschüsseln soll, das halt am besten mit Leerzeichen oder Umwandlung der Leerzeichen in _ oder der ähnlichen. Der Quellcode sieht immoment wie folgt aus:

Delphi-Quellcode:

begin
  s:=edein.text;
  sch:=StrToint(lbein.text);
  FOR I:=1 TO length(s) DO
    BEGIN
    c:=s[i];
    case c of
      'A' .. 'Z' : s1 := s1 + c;
      'a' .. 'z' : s1 := s1 + upcase(c);
      'ß'        : s1 := s1 + 'SS';
      'ä'        : s1 := s1 + 'AE';
      'ö'        : s1 := s1 + 'OE';
      'ü'        : s1 := s1 + 'UE';
      'Ä'        : s1 := s1 + 'AE';
      'Ö'        : s1 := s1 + 'OE';
      'Ü'        : s1 := s1 + 'UE';
    END;
    END;
    aus:='';
   for ii:=1 to length(s1) do
    begin
     c:=s1[ii];
     ASCII:=ord(c)+sch;
     aus:=aus+CHR(ASCII);
    end;
edaus.lines.add(aus);
end;

Das ist der Programmteil fürs Verschlüsseln. Wenn ich da allerdings nun einen Satz mir Leerzeichen eingebe kommt unten ein zusammengequetschtes Zeug raus und ist nach dem Entschlüsseln kaum zu lesen.

Freu mic hschon auf eure Beiträge

erweitere doch Deine Case-Abfrage um ein
      ' '        : s1 := s1 + '_'; Welchen Wert enthält sch?
Wenn Ord(c) + sch > 255 wird, können aus Chr(Ascii) nichtdarstellbare Zeichen werden.

[SirThornberry]

Zitat von mkinzler:

Schau dir mal StringReplace() an

Wenn es um mehrere Ersetzungen geht ist die Schleife wohl der sinnvollere Weg.

[Tyrael Y.]

Zitat von SirThornberry:

Zitat von mkinzler:

Schau dir mal StringReplace() an

Wenn es um mehrere Ersetzungen geht ist die Schleife wohl der sinnvollere Weg.

Wie kommst du denn darauf?

Zitat:

type
TReplaceFlags = set of (rfReplaceAll, rfIgnoreCase);
function StringReplace(const S, OldPattern, NewPattern: string; Flags: TReplaceFlags): string;

Beschreibung

Mit StringReplace ersetzen Sie in dem angegebenen String den im Parameter OldPattern festgelegten Sub-String mit dem im Parameter NewPattern übergebenen neuen Sub-String. StringReplace nimmt an, daß der String Multibyte-Zeichen enthalten kann.

Wenn im Parameter Flags nicht rfReplaceAll enthalten ist, wird nur das erste Vorkommen von OldPattern im String S ersetzt. Andernfalls werden alle Instanzen von OldPattern durch NewPattern ersetzt.

Wenn der Parameter Flags rfIgnoreCase enthält, wird die Groß-/Kleinschreibung nicht berücksichtigt.

[Jens Hartmann]

Hallo erstmal,

Schau die mal diesen Tread von mir an, ich habe auch das Problem gehabt diverse Zeichen zu ersetzten.

Vieleicht hilft Dir der ja weiter, dort habe ich dann auch die Lösung mit StringReplaced genutzt.

StringReplaced

MFG

Jens

[himitsu]

Zitat von Tyrael Y.:

Zitat von SirThornberry:

Wenn es um mehrere Ersetzungen geht ist die Schleife wohl der sinnvollere Weg.

Wie kommst du denn darauf?

Zitat:

type
TReplaceFlags = set of (rfReplaceAll, rfIgnoreCase);

er meinte mehrere verschiedene Ersetzungen
StringReplace erstetzt nur ein Zeichen/String (und das notfalls mehrmals)

aber irgendwo hier in der DP gab's 'ne StringReplace-Variante, der man statt Strings ganze Arrays übergeben konnte. (evtl. sogar in der CodeLib)

[Snow Dragon]

Zitat von nahpets:

erweitere doch Deine Case-Abfrage um ein
      ' '        : s1 := s1 + '_'; Welchen Wert enthält sch?
Wenn Ord(c) + sch > 255 wird, können aus Chr(Ascii) nichtdarstellbare Zeichen werden.

das mit der erweiterten CASE abfrage ging leider nicht, so schlau war ich auchschon.
Sch steht hier für schlüssel und ist eine zahl die vom Benutzer gewählt wird also 5 oder 6 oder auch 1234, das geht soweit auch wieder zu entschlüsseln auch wenns bei großen zahlen meistens nach humbuk aussieht^^
kann man denn lehrzeilen mit StringReplace() ersetzen?

PS: Ein 'Hallo' würde mit nem Schlüssel von 1234 verschlüsselt ungefähr so aussehen:
!
Wie man erkennt erkennt man nichts aber kopiert mans ins Programm rein udn entschlüsselt gehts^^

[nahpets]

Hallo,

Zitat von Snow Dragon:

Zitat von nahpets:

erweitere doch Deine Case-Abfrage um ein
      ' '        : s1 := s1 + '_'; Welchen Wert enthält sch?
Wenn Ord(c) + sch > 255 wird, können aus Chr(Ascii) nichtdarstellbare Zeichen werden.

das mit der erweiterten CASE abfrage ging leider nicht, so schlau war ich auchschon.
Sch steht hier für schlüssel und ist eine zahl die vom Benutzer gewählt wird also 5 oder 6 oder auch 1234, das geht soweit auch wieder zu entschlüsseln auch wenns bei großen zahlen meistens nach humbuk aussieht^^
kann man denn lehrzeilen mit StringReplace() ersetzen?

PS: Ein 'Hallo' würde mit nem Schlüssel von 1234 verschlüsselt ungefähr so aussehen:
!
Wie man erkennt erkennt man nichts aber kopiert mans ins Programm rein udn entschlüsselt gehts^^

Leerzeilen könntest Du an zwei aufeinanderfolgende Zeilenumbrüchen (#13#10#13#10) erkennen, das müsste mit StringReplace eigentlich zu ersetzen sein.
StringReplace(Zeichenfolge,#13#10#13#10,'****',[rfReplaceAll]);

[globetrotter77]

lass mal besser die Umwandlung von ß und Umlauten sein, die ist irreversibel und damit nicht mehr entschlüsselbar.
Im Gegensatz zur Umwandlung zu Caesars Zeiten geht es doch darum, alle Zeichen eines Strings um den gleichen Versatz zu verschieben, oder?
Würde ich jedenfalls mal empfehlen, denn dann fängst du auch Kandidaten mit Akzenten etc. ein ...
Und dann reicht es völlig, die Position im zugrundeliegenden Zeichensatz zu ermitteln, den Versatz zu addieren und danach wieder in ein Zeichen zu verwandeln, allerdings modulo 256, weil sonst ein Überlauf entstehen könnte, bei dem ich nicht weiß, was Delphi draus macht.

Also z.B. so:

Delphi-Quellcode:

const versatz = 7;

function codieren(s: string): string;
var i: integer;
    c: char;   // ein Zeichen
    p: integer;
    x: string; // das Zwischenergebnis
begin
  x:='';
  for i:=1 to Length(s) do
  begin
    c:=s[i];
    p:=ord(c);
    p:=(p+versatz) mod 256;
    c:=chr(p);
    x:=x+c;
  end;
  Result:=x;
end;

function decodieren(s: string): string;
var i: integer;
    c: char;   // ein Zeichen
    p: integer;
    x: string; // das Zwischenergebnis
begin
  x:='';
  for i:=1 to Length(s) do
  begin
    c:=s[i];
    p:=ord(c);
    p:=(p-versatz) mod 256; // Minus statt Plus!
    c:=chr(p);
    x:=x+c;
  end;
  Result:=x;
end;

Man kann das natürlich auch zusammenfassen in z.B.
  x:=x+chr((ord(s[i])+/-versatz) mod 256); das macht's aber eigentlich nur unlesbar und bringt kaum Vorteile.


Wichtig:
der resultierende String enthält in der Regel auch unlesbare bzw. nicht druckbare Zeichen, was aber normalerweise nichts machen dürfte, weil man es ja nicht lesen soll.
Das gibt nur Probleme, wenn man es auch in einer Datei abspeichern will.
Da gibt es zwei Möglichkeiten:
1) Speichern in binärer Datei, dann machen die Steuerzeichen nichts
2) Speichern in Textdatei, dann muss man die Routine abwandeln derart, dass nur die lesbaren Zeichen umgewandelt werden, also von #32 bis #255
Hierzu muss zunächst einmal eine Abbildung von #32..#255 auf #0..223 erfolgen, danach der gleiche Algorithmus, aber mit modulo 224, und danach wieder eine Abbildung von #0..#223 auf #32..#255 ... das war's!