String Code überprüfen

[lemomo]

Hallo Leute,
Ich fange mit Delphi noch mal nach fast 8 Jahren pause und ich habe ein Problem. Ich möchte eine Procedure die ein Datei.txt liest und überprüft ob ein String richtig ist, schreiben. Der String kommt merhmal vor und hat ein Teil als Integer (O1--,O2+-, ... O123++ ) so sehen die String aus. Es muss auch überprüft werden ob unser String auf die erste Reihe geschrieben ist und ob sein Integer Teil sich richtig inkrementiert. Der Rest Teil +- , -- oder ++ muss nicht geprüft werden . Datei lesen ist ok aber für die Überprüfunh weisse ich nicht wie ich anfangen muss. Danke schön
Beispiel datei.txt :
W1
Ich möchte ein Procedur schreiben die ein Datei.txt liest und überprüft
W1
O1-+
A
das Nichtvorliegen unrechtsausschlieáender
A
O2—
A
Zur Bestandes soll erforderlich sein:
A
O3++

[Bummi]

ich habe die Anforderung leider überhaupt nicht verstanden ...:cry:

Crosspost: http://www.entwickler-ecke.de/viewtopic.php?t=109844

[Klaus01]

Guten Morgen,

die könntest zuerst alle Ox Zeilen filtern und in eine StringList schreiben.
Dann überprüfst Du ob x aus Zeile[i] größer ist als x aus Zeile[i-1], bzw die Differenz
beider Zahlen = 1 ist.
Zu extractNumbers gibt es meines Wissens auch in diesem Forum eine Routine.

Grüße
Klaus

[p80286]

Da Deine Frage ein wenig verworren formuliert ist, wäre es gut wenn Du einmal ein paar Zeilen Deiner Datei posten würdest.
Als Stichworte würde mir copy,trystrtoint einfallen.

Gruß
K-H

[idefix2]

Statt sich mit copy, trystrtoint und dergleichen herumzuschlagen, ist es praktisch immer viel bequemer, eine Regex Unit einzubinden und die String-Prüfungen und Zerlegungen über reguläre Ausdrücke zu machen. Das reduziert den nötigen Code und den Programmieraufwand auf ein Bruchteil. Ganz am Anfang natürlich etwas gewöhnungsbedürftig, aber es zahlt sich wirklich aus.

Mich erstaunt, dass sich noch immer relativ wenige Programierer dieser Möglichkeit bewusst sind.

[Bummi]

bewusst schon, aber ich empfinde es als unleserlich und mühsam...

[p80286]

@Idefix2
Nichts gegen reguläre Ausdrücke, aber ich habe den Eindruck das der TE damit leicht überfordert wäre.

Gruß
K-H

[lemomo]

Danke für die Antworte ich werde mich heute nochmal mit der Aufgabe setzen , und nachher euch berichtet was ich schon oder nicht geschafft habe. Aber zuerst nochmal eine Erklärung mit beispiel (als Anhang ein beispiel Datei )


ich möchte ein Datei lesen, und danach überprüfen ob:

1-. O1- oder O2 ohne Leerzeichen geschrieben ist d.h vor der O1- oder O3 muss nicht leer sein oder gar nicht geschrieben sein.
2-. O1- , O2+ , O3 sich immer nach 1 erhöhen weil es kann passiert dass nach O45- man zum beispiel O47+ geschrieben hat

die + und - nach der O1 oder O4 sind egal müssen nicht überprüft werden

mfg Lemomo

[idefix2]

Zitat:

Zitat von Bummi (Beitrag 1174971)

bewusst schon, aber ich empfinde es als unleserlich und mühsam...

Ich habe geschrieben "gewöhnungsbedürftig", aber es zahlt sich eben wirklich aus. Unleserlich ist es nur ganz am Anfang - wie so ziemlich alles, was neu ist, auch ein gut geschriebenes Delphi Programm ist für einen Programmieranfänger grösstenteils unverständlich. Wenn man sich einmal mit ihnen angefreundet hat, lässt sich mit regulären Ausdrücken weitaus mehr anfangen, als man auf den ersten Blick meinen sollte, und das eigentlich immer mit einem Bruchteil des Aufwands, der für einen "klassischen" Programmieransatz nötig ist. Insofern ist es alles andere als mühsam. Give it a try :)

[p80286]

So wie die Daten aussehen, würde ich Idefix' Ansatz bevorzugen.
Die sehr konservative Möglichkeit wäre z.b.

Delphi-Quellcode:

  readln(f,Satz);
  if (length(satz)>0) and (Satz[1]='O') then begin
    if pos('-',satz)>0 then
      satz:=copy(satz,2,pos('-',satz)-1);
    if pos('-',satz)>0 then
      satz:=copy(satz,2,pos('+',satz)-1);
    pruflist.add(satz);
 end;

wobei pruflist eine Stringliste ist.
Du solltst diese dan von 0.. .count durchgehen und die entsprechenden integerwerte vergleichen.

Eine andere Möglichkeit ist es zB. mit altsatz und aktsatz zu operieren.

Gruß
K-H

[DeddyH]

Zitat:

Zitat von p80286 (Beitrag 1175207)

Du solltst diese dan von 0.. .count durchgehen

0.. .count - 1 :zwinker:

[idefix2]

Mit dem regex "^O(\d+)" habe ich alle Prüfungen erschlagen und schon den reinen Ziffernstring in match[1] gespeichert, dann einfach ein strtoint(match[1]) (nicht einmal trystrtoint ist nötig, weil in match[1] steht sicher eine Ziffernfolge, wenn regexmatch erfolgreich war). Wenn man will, kann man sogar leicht die Anzahl der Ziffern auf maximal 4, 5 oder irgend etwas sinnvolles beschränken, gefolgt vom Zeilenende oder einem Zeichen, das keine Ziffer ist, um sicherzustellen, dass kein Überlauf bei der String-Konvertierung erfolgt, es könnte ja auch eine Zeile: O1234567891234567891234567891234567891234567891234 56789+- dazwischenrutschen. Der Regex schaut dann einfach so aus: "^O(\d{1,5})(\D|$)"

Wie mühsam das Ganze auf die Klassische Art ist (und in Wirklichkeit auch insofern schlecht lesbar, als nicht auf den 1. Blick sichtbar ist, was genau in Sonderfällen passiert), siehst Du schon daran, dass auch diese schon recht komplizierte Variante nicht ausreicht: Was ist, wenn weder "+" noch "-" auf die Zahl, sondern ein anderes Zeichen folgt - es geht übrigens aus der Beschreibung nicht klar hervor, ob z.B. O17abc-+ erlaubt oder verboten wäre?

Wenn nur + oder - oder das Zeilenende auf die Ziffern folgen darf, aber kein anderes Zeichen, dann ändere ich den Regex einfach auf "$O(\d{1,5})([+-]|$)". Wenn ich so eine Änderung mit klassischer Programmierung machen will, dann muss ich bei jeder Kleinigkeit am code selbst basteln und über die richtige Abfolge der Abfragen tüfteln.

Noch dazu ist die klassische Programmierung durch die schiere Codemenge fehleranfälliger, hier müsste z.B. die letzte Abfrage

Delphi-Quellcode:

if pos('+',satz)>0 then

statt

Delphi-Quellcode:

if pos('-',satz)>0 then

lauten, das ist sicher beim copy & paste untergegangen.

[p80286]

Zitat:

Zitat von DeddyH (Beitrag 1175211)

Zitat:

Zitat von p80286 (Beitrag 1175207)

Du solltst diese dan von 0.. .count durchgehen

0.. .count - 1 :zwinker:

Omnia mea culpa, omnia maxima culpa

salve

Carolus

[DeddyH]

Wer ohne Fehler ist, der werfe das erste Schwein (oder so ähnlich) :mrgreen:

[Amateurprofi]

Hallo lemomo,

wie Bummi schon ausdrückte ist deine Beschreibung des Problems recht dürftig.

Du schriebst in #1
"Es muss auch überprüft werden ob unser String auf die erste Reihe geschrieben ist"
In #8 schriebst du
"d.h vor der O1- oder O3 muss nicht leer sein"

Den Satz aus #1 interpretiere ich so, dass die "Oxx" linksbündig angeordnet sein müssen.
Dagegen den Satz aus #8 verstehe ich so, dass davor Leerzeichen stehen dürfen.

Wie auch immer, da mich das interessierte, habe ich eine Prozedur geschrieben, die die Prüfungen ausführt.

Ist etwas länger, dafür recht flink. Für eine 25 MB Datei < 100 ms.

Delphi-Quellcode:

PROCEDURE CheckText(const s:string; CheckLeadingBlanks:boolean);
var p:PChar;
PROCEDURE NextLine;
begin
   while not CharInSet(p^,[#0,#10,#13]) do inc(p);
   while CharInSet(p^,[#10,#13]) do inc(p);
end;
FUNCTION ReadNumber:integer;
const max1=MaxInt div 10; max2=MaxInt-max1*10;
var c:integer;
begin
   result:=0;
   while CharInSet(p^,['0'..'9']) do begin
      c:=Ord(p^)-Ord('0');
      if (result>max1) or ((result=Max1) and (c>max2)) then
         raise Exception.Create('Zahlenüberlauf');
      result:=result*10+c;
      inc(p);
   end;
end;
FUNCTION Find_Ox(var value:integer):boolean;
var HasLeadingBlanks:boolean;
begin
   repeat
      hasleadingblanks:=p^=' ';
      while p^=' ' do inc(p); // Blanks am Zeilenanfang übergehen
      if p^='O' then begin  // O gefunden
         inc(p);
         if CharInSet(p^,['0'..'9']) then begin
            value:=ReadNumber;
            if CheckLeadingBlanks and HasLeadingBlanks then
               raise Exception.Create('"O'+IntToStr(value)+'" ist nicht linksbündig.');
            NextLine;
            Exit(true);
         end else begin
            raise Exception.Create('Keine Ziffer hinter "O".');
         end;
      end;
      NextLine;
   until p^=#0;
   result:=false;
end;
var n,k:integer; ss:string;
begin
   p:=@s[1];  // Zeigt auf erstes Zeichen im String
   try
      if not Find_Ox(n) then
         raise Exception.Create('Kein "O" gefunden, dem eine Zahl folgt');
      while Find_Ox(k) do
         if k=n+1 then begin
            n:=k
         end else begin
            ss:='Nach "O'+IntToStr(n)+'" folgt "O'+IntToStr(k)+'".';
            raise Exception.Create(ss);
         end;
      ShowMessage('OK');
   except
      on E:Exception do ShowMessage(E.Message);
   end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var list:TStrings;
begin
   list:=TStringList.Create;
   try
      try
         list.LoadFromFile('text1.txt');
         CheckText(list.Text,false);
      except
         On E:Exception do ShowMessage(E.Message);
      end;
   finally
      list.free;
   end;
end;

[idefix2]

Und unter Verwendung von regex wird daraus dann ungefähr so etwas:

Delphi-Quellcode:

PROCEDURE Checkfile(const fn:string);

var 
rgx: TRegexpr;
newnumber,oldnumber: integer;
f: textfile;
s: string;

begin
assign(f,fn); reset(f);
rgx:=TRegexpr.Create;
rgx.Expression:='^O(\d{1,5})([+-]|$)';
oldnumber:=0;

while not eof(f) do
  begin readln(f,s);
  if rgx.exec(s)
  then begin 
       newnumber := StrToInt(rgx.Match[1]);
       if newnumber <> oldnumber+1
       then Showmessage ('Out of sequence: '+rgx.Match[1]);
       oldnumber := newnumber;
       end;
  end;
rgx.free;
end;

[Amateurprofi]

Zitat:

Zitat von idefix2 (Beitrag 1175492)

Und unter Verwendung von regex wird daraus dann ungefähr so etwas:

Delphi-Quellcode:

PROCEDURE Checkfile(const fn:string);

var 
rgx: TRegexpr;
newnumber,oldnumber: integer;
f: textfile;
s: string;

begin
assign(f,fn); reset(f);
rgx:=TRegexpr.Create;
rgx.Expression:='^O(\d{1,5})([+-]|$)';
oldnumber:=0;

while not eof(f) do
  begin readln(f,s);
  if rgx.exec(s)
  then begin 
       newnumber := StrToInt(rgx.Match[1]);
       if newnumber <> oldnumber+1
       then Showmessage ('Out of sequence: '+rgx.Match[1]);
       oldnumber := newnumber;
       end;
  end;
rgx.free;
end;

In #5 sagtest du "ist es praktisch immer viel bequemer, eine Regex Unit einzubinden".
Frage : Welche denn ?
Ich habe versucht das nachzuvollziehen und habe die System.RegularExpressions eingebunden.
Die kennt aber kein "TRegexpr.Create" (aber ein TRegEx.Create, bei dem als Parameter der Suchtext mitgegeben wird).
Sie kennt auch kein "rgx.Match[1]".

Mal unabhängig davon, wird damit nicht das erreicht, was lemomo wollte.
Zum Beispiel kann nicht geprüft werden, ob da vielleicht ein Oxx nicht am Zeilenanfang steht.
Ein weiteres Problem, nämlich Oxx zu finden, bei denen das xx nicht direkt dem "O" folgt wird ebenfalls nicht gelöst.

Aber trotzdem würde ich das gern mal testen, deshalb die Bitte, mal das "eine RegEx Unit" zu präzisieren. Danke.

[dunningkruger]

Wurde in idefix2 #16 nicht ein FileClose vergessen?

Interessiere mich so langsam auch für einen RegEx-Link (unit oder Komponente mit Doku) für Delphi 5.

Ggf. Danke!

[idefix2]

Ich weiss nicht mehr, wo genau ich diese Regex Implementierung gefunden habe. Sie ist gratis und darf frei verteilt werden, ich habe sie jetzt hochgeladen. Sie kann leider nicht alles, was die Perl Regex Syntax erlaubt, aber die Einschränkungen sind nicht schlimm. Ich bin z.B. einmal darüber gestolpert, dass (?:...) nicht möglich ist. Nicht auszuschliessen, dass die Version, die bei Delphi-XE2 dabei ist, besser ist (aber wohl auch etwas anders in der Handhabung). Dass der Regex-String gleich beim Create als Parameter mitgegeben werden kann, gefällt mir z.B. besser als bei meiner Regex-Klasse. Ich habe nur Delphi 2009, da ist von Emba aus kein Regex dabei.

Zitat:

Zum Beispiel kann nicht geprüft werden, ob da vielleicht ein Oxx nicht am Zeilenanfang steht.

Wenn ein Oxx nicht am Zeilenanfang steht, wird es ignoriert, und ich denke, das ist in Ordnung, weil es könnte ja irgendwo mitten im Text zufällig Oxx vorkommen, das gilt dann eben nicht. Wenn es doch gelten sollte und irrtümlich nicht am Zeilenanfang steht, würde dann das nächste Oxx einen Out-of-Sequence Fehler produzieren.

Zitat:

Ein weiteres Problem, nämlich Oxx zu finden, bei denen das xx nicht direkt dem "O" folgt wird ebenfalls nicht gelöst.

Sollte das laut Beschreibung erlaubt sein? Wenn ja, könnte man das mit einer einfachen Änderung des regex-Strings lösen (Einfügen von \D* nach dem O), ohne am Programm irgend etwas zu verändern.

Zitat:

Wurde in idefix2 #16 nicht ein FileClose vergessen?

Ja, wurde. Mea culpa.

Ob die Unit mit D5 kompatibel ist, kann ich leider nicht sagen. Ich verwende D2009. Ich fürchte, da wird die geänderte String-Implementierung Probleme schaffen.

[dunningkruger]

@idefix2: Danke, schau ich mir an!

[Furtbichler]

Wie man ernsthaft (hier) *gegen* den Einsatz von RegEx sein kann, ist mir ein Rätsel. Man kann das natürlich per Hand auskodieren, aber RegEx ist einfach zu einfach :stupid:

Die Fragestellung zielt ganz klar in Richtung Mustererkennung. "Anfang der Zeile", "O<Ziffern><PlusOderMinus>". Ergo ist ein Zeichen-Mustererkenn-O-Mat, aka 'regular expression', das richtige Werkzeug.

Die erkannten regulären Ausrücke (O<Zahl><PlusMinus>) müssen dann nur noch hinsichtlich der 'Zahl' geprüft werden (um 1 inkrementierend).

Der reguläre Ausdruck kann natürlich im Einzelfall ziemlich komplex und sehr(!) schlecht zu lesen sein, aber es gibt mittlerweile RegEx-formatierer und -Kommentierer, die selbst den perversesten Ausdruck verständlich darstellen können.

Hier sind dann übrigens im Einzelfall Kommentare angebracht, obwohl ich sonst kein Freund davon bin.

@Amateurprofi: Googel mal nach "Delphi regEx", druck dir die Ergebnisse aus, stell dich in 100m Entfernung vor den Ausdruck, nimm einen Dartpfeil und werfe rückwärts mit geschlossenen Augen. Du triffst *garantiert* etwas Brauchbares ;-)

Oder Du bist Pazifist und suchst in der DP

Es geht ja nicht konkret um die exakte Unit, sondern das Verfahren.

Zitat:

Zitat von Amateurprofi (Beitrag 1175512)

Zum Beispiel kann nicht geprüft werden, ob da vielleicht ein Oxx nicht am Zeilenanfang steht...Ein weiteres Problem, nämlich Oxx zu finden, bei denen das xx nicht direkt dem "O" folgt wird ebenfalls nicht gelöst.

Wir lesen die Aufgabenstellung:

Zitat:

Zitat von lemomo (Beitrag 1174866)

Es muss auch überprüft werden ob unser String auf die erste Reihe geschrieben ist und ob sein Integer Teil sich richtig inkrementiert.

[idefix2]

Zitat:

Der reguläre Ausdruck kann natürlich im Einzelfall ziemlich komplex und sehr(!) schlecht zu lesen sein,

Das ist richtig. Fairerweise muss man aber dazu sagen, dass dann der Fall sein wird, wenn das zu erkennende Muster ziemlich komplex ist, und dass ein Programm, das die Erkennung eines so komplexen Musters ausprogrammiert, noch um ein Vielfaches schwieriger zu lesen sein wird als der regex-String.

[Furtbichler]

Manchmal ist ein DEA einfacher zu verstehen. Heißt aber nicht, das ein Regex abzulehnen wäre.

[Amateurprofi]

Zitat:

Zitat von Furtbichler (Beitrag 1175535)

Wie man ernsthaft (hier) *gegen* den Einsatz von RegEx sein kann, ist mir ein Rätsel. Man kann das natürlich per Hand auskodieren, aber RegEx ist einfach zu einfach :stupid:

Die Fragestellung zielt ganz klar in Richtung Mustererkennung. "Anfang der Zeile", "O<Ziffern><PlusOderMinus>". Ergo ist ein Zeichen-Mustererkenn-O-Mat, aka 'regular expression', das richtige Werkzeug.

Die erkannten regulären Ausrücke (O<Zahl><PlusMinus>) müssen dann nur noch hinsichtlich der 'Zahl' geprüft werden (um 1 inkrementierend).

Der reguläre Ausdruck kann natürlich im Einzelfall ziemlich komplex und sehr(!) schlecht zu lesen sein, aber es gibt mittlerweile RegEx-formatierer und -Kommentierer, die selbst den perversesten Ausdruck verständlich darstellen können.

Hier sind dann übrigens im Einzelfall Kommentare angebracht, obwohl ich sonst kein Freund davon bin.

@Amateurprofi: Googel mal nach "Delphi regEx", druck dir die Ergebnisse aus, stell dich in 100m Entfernung vor den Ausdruck, nimm einen Dartpfeil und werfe rückwärts mit geschlossenen Augen. Du triffst *garantiert* etwas Brauchbares ;-)

Oder Du bist Pazifist und suchst in der DP

Es geht ja nicht konkret um die exakte Unit, sondern das Verfahren.

Zitat:

Zitat von Amateurprofi (Beitrag 1175512)

Zum Beispiel kann nicht geprüft werden, ob da vielleicht ein Oxx nicht am Zeilenanfang steht...Ein weiteres Problem, nämlich Oxx zu finden, bei denen das xx nicht direkt dem "O" folgt wird ebenfalls nicht gelöst.

Wir lesen die Aufgabenstellung:

Zitat:

Zitat von lemomo (Beitrag 1174866)

Es muss auch überprüft werden ob unser String auf die erste Reihe geschrieben ist und ob sein Integer Teil sich richtig inkrementiert.

Genau, wir lesen die Aufgabestellung

Zitat:

Zitat von lemomo (Beitrag 1174866)

Es muss auch überprüft werden ob unser String auf die erste Reihe geschrieben ist und ob sein Integer Teil sich richtig inkrementiert.

[/QUOTE]

Und genau das wird eben nicht gelöst.
Wenn zum Beispiel in der Datei die Zeilen
"O27"
"..."
" O28"
"..."
"O28"
stehen, dann würde das eingerückte "O28" übergangen, der Fehler also nicht bemerkt.
Lemomo will ja nicht nur die "Oxx" finden die korrekt sind, sonder er möchte eine komplette Prüfung seiner Datei.
In der Tat!

[Furtbichler]

Dann wird die Regex eben erweitert.
Um genau 2 Zeichen. Oder ein paar mehr.
WTF

Die semantische Prüfung der aufsteigenden Werte erfolgt über einen Dreizeiler.

[idefix2]

Zitat:

Zitat von Amateurprofi (Beitrag 1175570)

Wenn zum Beispiel in der Datei die Zeilen
"O27"
"..."
" O28"
"..."
"O28"

Ja, das stimmt. Aber jedes O, das irgendwo im Text vorkommt, und das nicht von einer passenden Zahl gefolgt wird, als Fehler auszuweisen, kann es sicher auch nicht sein. Die Aufgabenstellung ist sehr schwammig formuliert, und der TE hat sich ja schon lange nicht mehr gemeldet. Wir können also nur darüber spekulieren, wie in so einem Sonderfall vorzugehen ist, und das ist wohl nicht sonderlich sinnvoll.

Mir ist es nur darum gegangen, aufzuzeigen, wie einfach die Lösung derartiger Probleme mit Hilfe von regex ist, verglichen mit dem sturen Ausprogrammieren der Mustererkennung.

Zitat:

Manchmal ist ein DEA einfacher zu verstehen

Ich verstehe Bahnhof.

[Furtbichler]

Zitat:

Zitat von idefix2 (Beitrag 117557)

Ich verstehe Bahnhof.

Man kann das Erkennen von regulären Ausdrücken auch über einen Zustandsautomaten abbilden. Das ist dann eine Schleife über den Eingabetext mit einer Case-Anweisung.

Um auch O's im Text zu erkennen, kann man ein zweites Muster angeben, das diesen Fall abdeckt.

[omata]

Zitat:

Zitat von Amateurprofi (Beitrag 1175512)

Frage : Welche denn ?

Zitat:

Zitat von dunningkruger (Beitrag 1175517)

Interessiere mich so langsam auch für einen RegEx-Link (unit oder Komponente mit Doku) für Delphi 5.

siehe auch hier.

[Amateurprofi]

QUOTE=idefix2;1175578]

Zitat:

Zitat von Amateurprofi (Beitrag 1175570)

Wenn zum Beispiel in der Datei die Zeilen
"O27"
"..."
" O28"
"..."
"O28"

Ja, das stimmt. Aber jedes O, das irgendwo im Text vorkommt, und das nicht von einer passenden Zahl gefolgt wird, als Fehler auszuweisen, kann es sicher auch nicht sein. Die Aufgabenstellung ist sehr schwammig formuliert, und der TE hat sich ja schon lange nicht mehr gemeldet. Wir können also nur darüber spekulieren, wie in so einem Sonderfall vorzugehen ist, und das ist wohl nicht sonderlich sinnvoll.

Mir ist es nur darum gegangen, aufzuzeigen, wie einfach die Lösung derartiger Probleme mit Hilfe von regex ist, verglichen mit dem sturen Ausprogrammieren der Mustererkennung.

Zitat:

Manchmal ist ein DEA einfacher zu verstehen

Ich verstehe Bahnhof.[/QUOTE]

Genau das macht die von mir vorgeschlagene Prozedur eben nicht!
Nur "O"s, die das erste Non-Blank in einer Zeile sind, werden überprüft. "O"s, die irgendwo im Text stehen, selbstverständlich nicht.
Was in meiner Prozedur noch fehlt, ist die Angabe der Zeilennummer, in der ein Fehler vorkommt.
Weiterhin fehlt dir Prüfung ob einem "O" ein oder mehrere Blanks und diesen eine Zahl folgt. Anstatt wird ein "O" am Zeilenanfang, dem keine Ziffer folgt, als Fehler erkannt.

Was die "schwammige" Aufgabenstellung betrifft, sind wir exakt einer Meinung.

[Furtbichler]

Ich bin auch ein Freund von basisfunktionaler Programmierung, d.h. ohne 'Schnickschnack' wie RegEx usw.

Das heißt aber nicht, das ich mich nicht damit beschäftigte und dann, wenn es sinnvoll(er) ist, diese auch einzusetzen.

Hier könnte man eine kleine Sprache definieren, die aus den Symbolen (nennen wir sie 'On+'), Zeilenanfängen und sonstigem Text besteht.

Das macht man mit einem Lexer/Tokenizer, dessen Grundlage i.a. ein RegEx ist.

Man *kann* das auch handcodiert machen, aber -ehrlich gesagt- ich nehme gerne die Dienste von DHL, UPS o.ä. in Anspruch, auch wenn ich das Paket selbst abliefern könnte, vermutlich sogar etwas schneller, aber: WTF.

Mit Standardanbietern/-tools ist es einfach bequemer und ich weiss eins sicher: Es funzt.


Ach: Eins noch: Deine speziell implementierte Variante hat ein Problem: Sie ist nicht allgemeingültig. Du musst jedesmal das Rad neu erfinden. Macht Spass, aber ist auch irgendwie langweilig.

[idefix2]

Zitat:

Genau das macht die von mir vorgeschlagene Prozedur eben nicht!
Nur "O"s, die das erste Non-Blank in einer Zeile sind, werden überprüft. "O"s, die irgendwo im Text stehen, selbstverständlich nicht.
Was in meiner Prozedur noch fehlt, ist die Angabe der Zeilennummer, in der ein Fehler vorkommt.
Weiterhin fehlt dir Prüfung ob einem "O" ein oder mehrere Blanks und diesen eine Zahl folgt. Anstatt wird ein "O" am Zeilenanfang, dem keine Ziffer folgt, als Fehler erkannt.

Na gut. Ich habe in die schwammige Aufgabenstellung eine Aufgabe hineininterpretiert, die ich gelöst habe. Du hast eine etwas andere Aufgabe hineininterpretiert, die Du gelöst hast. Wir können uns jetzt noch beliebige Zusatzaufgaben ausdenken, Zeilennummern ausgeben, die durchschnittliche Zeichenzahl pro Zeile berechnen, oder was auch immer. Oder wir können es bleiben lassen :)

Übrigens nebenbei: Wenn ich z.B. alle Os, die das erste non-Blank in einer Zeile sind, mitberücksichtigen will, und vielleicht noch abfragen will, ob es Blanks am Anfang gibt, dann setze ich einfach

Code:

(\b*)

vor das O in den regex Ausdruck, und dann kann ich mit der Abfrage

Delphi-Quellcode:

if rgx.Match[1]=''

feststellen, ob das O linksbündig ist (Das bisherige Match[1] muss ich dann natürlich auf Match[2] ändern). Will ich zwischen dem O und der Ziffernfolge Leerstellen erlauben, dann setze ich eben hinter das O die Zeichenfolge

Code:

\b*

Sonst brauche ich am Programm nichts zu ändern. Das ist es, was mir an der Programmierung mit Regex so gut gefällt.