Erstellung einer Funktion

[Mo53]

Hallo, ich muss für die Uni eine Anzahl von Funktionen mit Testteil erstellen, eine Funktion davon macht mir das Leben Schwer und ich komm nicht drauf wie ich dies erstellen könnte. Arrays darf ich noch nicht verwenden.
Hätte jemand eine Idee.

function longestNumber(s : string) : word;

Sucht die längste Ziffernfolge (aus Ziffern von '0' bis '9') im String s. Gibt es mehrere gleich lange, wird davon die erste zurückgegeben. Sind keine Ziffern enthalten, gibt die Funktion den Wert 0 zurück.

Hinweis: Die längste Ziffernfolge muß nicht unbedingt die größte Zahl in s sein! Eine so gefundene Ziffernfolge darf auch mit einer oder mehreren '0' beginnen.

[Monday]

Und wo ist das Problem?

[DieDolly]

Zitat:

Zitat von Monday (Beitrag 1490601)

Und wo ist das Problem?

Zitat:

Arrays darf ich noch nicht verwenden.

Da fängt es schon an. Mir persönlich wäre es herzlich egal was man darf und was nicht. Systematisch werden die Studenten bei euch wohl klein gehalten ...

[runningsoft]

Wie sieht denn dein String, der der Funktion übergeben wird aus? Und was hast du schon an code?

[TiGü]

Zitat:

Zitat von DieDolly (Beitrag 1490602)

Systematisch werden die Studenten bei euch wohl klein gehalten ...

Hast du studiert?

[Mo53]

Ich habe die anderen Funktionen bis zu der oben genannten schonmal erstellt, bin dann bei der Funktion hängen geblieben.
Der String der der Funktion übergeben wird wäre z.B. 123Hallo65378

Delphi-Quellcode:

{$APPTYPE CONSOLE}

{$R+,Q+,X-}

uses
  System.SysUtils;

var
  s : string;

function countDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : inc(number);
      end;
      countDigits := number;
    end;
  end;

function countEvenDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
      begin
        case s[run] of
          '0','2','4','6','8' : inc(number);
        end;
        countEvenDigits := number;
      end;
  end;

function countOddDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
      begin
        case s[run] of
          '1','3','5','7','9' : inc(number);
        end;
        countOddDigits := number;
      end;
  end;

function countNonDigits(s : string) : byte;
var run, number : byte;
  begin
    number := length(s);
    for run := 1 to length(s) do
      begin
        case s[run] of
          '0'..'9' : dec(number);
        end;
        countNonDigits := number;
      end;
  end;

function longestNumber(s : string) : word;
var run , number : byte;
    zifferGefunden : boolean;
begin
  number := 0;
  zifferGefunden := FALSE;
  for run := 1 to length(s) do
    begin

    end;
    longestNumber := number;
end;



begin
  write('Bitte satz eingeben');
  readln(s);
  writeln('Ziffern: ',countDigits(s));
  writeln('gerade Ziifern: ',countEvenDigits(s));
  writeln('ungerade Ziffern: ',countOddDigits(s));
  writeln('zählt keine Ziffern von 0 bis 9: ',countNonDigits(s));
  readln;

end.



procedure deleteDigits(var s : string);
procedure printInfos(s : string);

[Daniel]

Bitte bleibt beim Thema - eine Diskussion über die Vorgaben des Profs sind an dieser Stelle überflüssig.

[Delphi.Narium]

Zitat:

Zitat von DieDolly (Beitrag 1490602)

Zitat:

Zitat von Monday (Beitrag 1490601)

Und wo ist das Problem?

Zitat:

Arrays darf ich noch nicht verwenden.

Da fängt es schon an. Mir persönlich wäre es herzlich egal was man darf und was nicht. Systematisch werden die Studenten bei euch wohl klein gehalten ...

Es geht um systematisches Lernen und nicht um einfach: Mach mal was, mal sehen was rauskommt und wenn nix rauskommt ist auch egal.

Es geht halt darum das Programmieren zu lernen. Hier wird halt zufällig Delphi genutzt.

Nach Abschluss des Studiums soll die Fähigkeit zu programmieren so ausgebildet sein, dass die Programiersprache, die Entwicklungsumgebung, ... absolut nachrangig ist.
Es geht darum Aufgabenstellungen, Probleme, ... zu analysieren und diese dann mit den jeweils zur Verfügung stehenden Mitteln zu lösen. Und da hilft es durchaus, nicht immer nur den gerade einfachsten Weg zu gehen, sondern auch mal einen komplizierten, um eben auch mal die über den Tellerrand zu schauen.

Und bei der momentanen Aufgabenstellung ist der vorgegebene Weg eventuell ja nicht unbedingt der einfachste, aber der Lerneffekt, zu dem die erfolgreiche Lösungssuche führt, dürfte deutlich höher sein.

Immer dieses unreflektierte Rumpöbeln gegen alle Bildungseinrichtungen, jedwedes Lehrpersonal, ... ist einfach nur ätzend.

Zitat:

Zitat von TiGü (Beitrag 1490605)

Zitat:

Zitat von DieDolly (Beitrag 1490602)

Systematisch werden die Studenten bei euch wohl klein gehalten ...

Hast du studiert?

Vermutlich nicht, sonst würde sie verstehen, warum so vorgegangen wird, wie wir es momentan bei Mo53s "Studienbeleitung" erleben.

Und wenn man Mo53 Fortschritte beobachtet, so scheint der gewählte Weg ja durchaus effektiv zu sein.

[runningsoft]

Du könntest in einem

Delphi-Quellcode:

try ... except

Block zeichenweise prüfen, ob das betreffende Zeichen in deinem string eine Ziffer ist oder nicht, und mitzählen, wieviele Ziffern du bereits aufeinanderfolgend hattest.
Kommst du auf eine Nicht-Ziffer, setzt du deinen Zähler wieder auf 0 zurück.

Hier mein Lösungsvorschlag:

Delphi-Quellcode:

function longestNumber(s : string) : word;
var run , number, tempresult, ziffer : byte;
    zifferGefunden : boolean;
    test : string;
begin
  number := 0;
  tempresult := 0;
  zifferGefunden := FALSE;
  for run := 1 to length(s) do
    begin
    test := s[run];
    try
    ziffer := strtoInt(test);
    inc(tempresult);
    if number < tempresult then
      number := tempresult;
    except
    tempresult := 0;
    end;
    end;
  longestNumber := number;
end;

[Delphi.Narium]

Versuch' bitte mal vom Prinzip sowas in der Art:

Die Funktion bekommt den String übergeben, dann gehst Du in einer Schleife darüber, solange ein Zeichen keine Zahl ist, wird es ignoriert.

Ist es eine Zahl, so wird das Zeichen an eine Variabel angehängt, so dass diese Variabel dann alle Ziffern enthält, bis das erste Zeichen kommt, das keine Ziffer ist.

Erhälst Du nun bei weiterem Fortlauf über die Zeichenfolge wieder eine Ziffer, so wird in einer weiteren Variabel wie oben vorgegangen. Beim ersten Zeichen, das keine Ziffer ist, wird nun eine "Zwischenprüfung" gemacht, indem Du die Variabeln mit den Zeichenfolgen vergleichst, nach Länge ...

Der Inhalt der Variabel, die hier als kleiner herauskommt kann verworfen werden und die Variabel für die nächste (eventuell vorhanden) Ziffernfolge genutzt werden.

Du brauchst also zur übergebenen Zeichenfolge und der Laufvariabel für die Schleife, noch zwei Stringvariabel, in denen Du die bisher längste und die gerade aktuelle Ziffernfolge vorhälst.

Eine Abwandlung bzw. Erweiterung Deiner Funktion countDigits könnte da schon ausreichend sein, sie muss sich halt zusätzlich noch die Ziffernfolgen merken und deren Vergleich durchführen. Das case ... end benötig dazu "nur" einen Else-Zweig.

[Mo53]

@runningsoft @Delphi.Narium Vielen Dank für eure Lösungsvorschläge, try und except, hatten wir noch nicht behandelt in den Vorlsungen deshalb bin ich mir da unsicher ob ich das benutzen darf, ich werde da mal nachfragen:)

[Delphi.Narium]

Eventuell könnte dashier schon reichen, ist aber ungetestet:

Delphi-Quellcode:

function longestNumber(s : string) : byte;
var run, number : byte;
  begin
    longestNumber := 0;
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : inc(number);
      else
        begin
          if number > longestNumber then longestNumber := number;
          number := 0;
        end;
      end;
    end;
    if number > longestNumber then longestNumber := number;
  end;

[Mo53]

@Delphi.Narium da wird leider die Fehlermeldung ''nicht genügend wirkliche Parameter angezeigt''

[Delphi.Narium]

An welcher Stelle wird der Fehler angezeigt?

In PascalScript funktioniert diese Variante:

Delphi-Quellcode:

function longestNumber(s : string) : byte;
var run, number : byte;
  begin
    Result := 0;
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : number := number + 1;
      else
        begin
          if number > Result then Result := number;
          number := 0;
        end;
      end;
    end;
    if number > Result then Result := number;
  end;

Oder alternativ:

Delphi-Quellcode:

function longestNumber(s : string) : byte;
var run, number, longNum : byte;
  begin
    longNum := 0;
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : inc(number);
      else
        begin
          if number > longNum then longNum := number;
          number := 0;
        end;
      end;
    end;
    if number > longNum then longNum := number;
    longestNumber := longNum;
  end;

[Sinspin]

Zitat:

Zitat von Delphi.Narium (Beitrag 1490622)

In PascalScript funktioniert diese Variante:

Dir ist schon klar dass Du da gerade Hausaufgaben machst?
Ist klar, helfen macht Spass. Aber Hilfe zur Selbsthilfe ist besser. ....und macht übrigens auch Spass.

Im Studium habe ich öfter jemandem bei den Projekten geholfen. Leider auch ein paar mal so wie Du jetzt. Allerdings haben wir danach den Quelltext besprochen in der Hoffnung das etwas Verständnis aufkommt :wink:

[Fritzew]

Also schauen wir doch mal die Aufgabenstellung an:

„Sucht die längste Ziffernfolge (aus Ziffern von '0' bis '9') im String s. Gibt es mehrere gleich lange, wird davon die erste zurückgegeben. Sind keine Ziffern enthalten, gibt die Funktion den Wert 0 zurück.“

Daraus ergibt sich für mich als erstes:
Die Signatur der Funktion ist falsch müsste so aussehen:

Delphi-Quellcode:

function longestNumber(s : string) : string;

Ansonsten wird die Bedingung : „Gibt es mehrere gleich lange, wird davon die erste zurückgegeben“ nicht erfüllt.

Beispiele:
Input: „123 1234 12345 “ Result : „12345“
Input: „333 4444 5555 “ Result : „4444“ da erstes Vorkommen
Input : „ABCDEF“ : Result 0;

Und dann pseudo Code:
startfunc

Result ‚0‘

tempResult „“

Scheife 1 bis länge Input

Prüfe ob Input[schleife] ist eine Ziffer

Ja : hänge input[schleife] an tempresult;
Nein:

block
Wenn länge tempresult > länge result dann setze result auf tempresult
Tempresult wieder auf „“ setzen
endblock

Schleifenende

Noch einmal prüfen:
Wenn länge tempresult > länge result dann setze result auf tempresult

endfunc

[mmw]

hallo,
der Fehler duerfte hier auftreten

Delphi-Quellcode:

 if number > longestNumber then longestNumber := number;

Gruß

[Mo53]

Das Programm ist jetzt so gut wie fertig, ist nur noch ein kleines Problem bei der Ausgabe der Prozedur 'deleteDigits', ich habe herausgefunden das es so nicht zulässig ist, bin jedoch nach langem herumexperimentieren immernoch nicht darauf gekommen.

Delphi-Quellcode:

{$APPTYPE CONSOLE}

{$R+,Q+,X-}

uses
  System.SysUtils;

var
  s : string;

function countDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : inc(number);
      end;
      countDigits := number;
    end;
  end;

function countEvenDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
      begin
        case s[run] of
          '0','2','4','6','8' : inc(number);
        end;
        countEvenDigits := number;
      end;
  end;

function countOddDigits(s : string) : byte;
var run , number : byte;
  begin
    number := 0;
    for run := 1 to length(s) do
      begin
        case s[run] of
          '1','3','5','7','9' : inc(number);
        end;
        countOddDigits := number;
      end;
  end;

function countNonDigits(s : string) : byte;
var run, number : byte;
  begin
    number := length(s);
    for run := 1 to length(s) do
      begin
        case s[run] of
          '0'..'9' : dec(number);
        end;
        countNonDigits := number;
      end;
  end;

 function longestNumber(s : string) : byte;
var run, number, longNum : byte;
  begin
    longNum := 0;
    number := 0;
    for run := 1 to length(s) do
    begin
      case s[run] of
       '0'..'9' : inc(number);
      else
        begin
          if number > longNum then longNum := number;
          number := 0;
        end;
      end;
    end;
    if number > longNum then longNum := number;
    longestNumber := longNum;
  end;

 procedure deleteDigits(var s: string);
var
  run, number, savedRun, deleted: byte;
  endNotFound :boolean;
begin
  run := length(s);
  savedRun := length(s);
  endNotFound := TRUE;

  while endNotFound do
  begin
    repeat
      case s[run] of
        '0' .. '9': delete(s,run,1);
      end;
      dec(run);
    until run = 0 ;
    endNotFound := TRUE;
    end;
end;

procedure printInfos(s: string);
begin
  writeln('String: ', s, ' Ziffern: ', countDigits(s), ' Gerade: ',
    countEvenDigits(s), ' Ungerade: ', countOddDigits(s), ' Andere: ', countNonDigits(s),
    ' Längste: ',longestnumber(s),' Ohne: ',deleteDigits(s));
end;




begin
  write('Bitte Satz eingeben: ');
  readln(s);
  printInfos(s);
  readln;

end.

[haentschman]

Moin...:P

Zitat:

Das Programm ist jetzt so gut wie fertig

:thumb:

Info:
Zum Programmieren, egal welche Sprache, gehört zum Lernen ein Styleguide dazu. :wink:
Delphi: https://www.delphi-treff.de/object-pascal/styleguide/

Du machst das schon gut. :zwinker:

[noisy_master]

Zitat:

Zitat von Mo53 (Beitrag 1490636)

Das Programm ist jetzt so gut wie fertig, ist nur noch ein kleines Problem bei der Ausgabe der Prozedur 'deleteDigits', ich habe herausgefunden das es so nicht zulässig ist, bin jedoch nach langem herumexperimentieren immernoch nicht darauf gekommen.

Delphi-Quellcode:

procedure deleteDigits(var s: string);
var
  run, number, savedRun, deleted: byte;
  endNotFound :boolean;
begin
  run := length(s);
  savedRun := length(s);
  endNotFound := TRUE;

  while endNotFound do
  begin
    repeat
      case s[run] of
        '0' .. '9': delete(s,run,1);
      end;
      dec(run);
    until run = 0 ;
    endNotFound := TRUE;
    end;
end;

dürfte meiner Meinung nach für immer laufen, weil deine Bedingung für das while immer gültig bleibt....

ich würde es so versuchen:

Delphi-Quellcode:

procedure deleteDigits(var s: string);
var
  run byte;
begin
   for run := length(s) downto 1 do
     case s[run] of
       '0'..'9' : delete(s,run,1);
     end;
end;

[runningsoft]

Kanns grad nicht testen, aber in deiner repeat - Schleife löschst Du ein Zeichen deines Strings wenn es sich um eine Ziffer handelt und verkürzt anschließend deinen Zähler (run) trotzdem noch um 1. Somit überspringst du für den Fall, dass du bereits vorher eine Ziffer gelöscht hast, ein Zeichen in deinem string.

Delphi-Quellcode:

while endNotFound do
 begin
    repeat
      case s[run] of
        '0' .. '9': delete(s,run,1);
      end;
      dec(run);
    until run = 0 ;
   endNotFound := TRUE;
   end;

Ich würde das ganze mit einer for..do - Schleife lösen

Delphi-Quellcode:

for i = length(s) downto 0 do
  begin
  //prüfe hier, ob das betreffende Zeichen eine Ziffer ist, wenn ja. lösche es
  //damit prüfst du tatsächlich alle Zeichen deines Strings und überspringst durch das löschen keines
  end

Wie gesagt, ungetestet.

Edit:
Mist, zu langsam getippt :wink:

[DieDolly]

Delphi-Quellcode:

while endNotFound do
 begin
  repeat
   case s[run] of
    '0' .. '9': delete(s,run,1);
   end;
   
   dec(run);
  until run = 0 ;

  endNotFound := TRUE;
 end;

Fällt dir denn da nichts auf, warum es nicht funktioniert?

[Mo53]

Ich hatte vergessen zu erwähnen das das Problem eine Fehlermeldung in der Ausgabe unten ist bei

Delphi-Quellcode:

''procedure printInfos(s: string);
begin
  writeln('String: ', s, ' Ziffern: ', countDigits(s), ' Gerade: ',
    countEvenDigits(s), ' Ungerade: ', countOddDigits(s), ' Andere: ', countNonDigits(s),
    ' Längste: ',longestnumber(s),' Ohne: ',deleteDigits(s));
end;

Die Fehlermeldung wird genau bei 'deleteDigits(s) angezeigt und lautet: E2054 Ungültiger Typ in write/writeln Anweisung.

[TiGü]

Zitat:

Die Fehlermeldung wird genau bei 'deleteDigits(s) angezeigt und lautet: E2054 Ungültiger Typ in write/writeln Anweisung.

Schau mal genau hin.
von countDigits(s) bis longestnumber(s) hast du FUNKTIONEN, die etwas zurückgeben.
Diese Rückgabe kann Writeln darstellen.
Dein deleteDigits(s) ist aber nur eine PROZEDUR, die nichts zurückgibt, also kein Result hat.
Demzufolge kann Writeln nichts damit anfangen.

[freimatz]

Debuggen ist nicht erlaubt?

[Mo53]

Ok hab das mit der Fehlermeldung gelöst, ich würde jetzt gerne dafür sorgen das diese Funktion nicht mehr die Anzahl der längsten Ziffernfolge ausgibt sondern die längste Ziffernfolge selbst, anscheinend ist es schwerer als gedacht oder übersehe ich einfach etwas

Delphi-Quellcode:

function longestNumber(s: string): byte;
var
  run, number, longNum: byte;
begin
  longNum := 0;
  number := 0;
  for run := 1 to length(s) do
  begin
    case s[run] of

      '0' .. '9':
        inc(number)

    else
      begin
        if number > longNum then
          longNum := number;
        number := 0;
      end;
    end;
  end;
  if number > longNum then
  begin
    longNum := number;
    longestNumber := longNum;
  end;
end;

[Delphi.Narium]

Naja, momentan speicherst Du halt die Länge der längsten Nummer und gibst dann eine Zahl (Byte) zurück.

An der Stelle, an der Du Dir die längste Nummer merkst, musst Du Dir dann wohl "einfach" nur diese Nummer merken und diese dann zurückgeben. Da es sich bei den Nummern um Zeichenfolgen handelt, wird der Rückgabewert wohl besser ein String sein, damit auch (wie oben gefordert) führende Nullen erhalten bleiben.

Die grundsätzliche Logik ist aber identisch.

Achso: Bei Deiner derzeitigen Variante wird das Ergebnis nicht immer richtig sein. Es dürfte nur dann stimmen, wenn zufällig die letzte Ziffernfolge länger als die zuvor gemerkten Länge ist und die Zeichenfolge auf jeden Fall mit einer Ziffer endet.

Mein grober Test ergab:

Code:

a -> 00000
a1a -> 00000
a22aa333aa -> 00000
a22a333a22aa -> 00000
123 -> 00003
a11111a -> 00000
a1 -> 00001
a1aa22aaa333 -> 00003
aaaa4444aaaaa55555aaaaaa -> 00000
1234567890aaaaaaaaaa -> 00000

Von 10 Testfällen sind weniger als 50% richtig. Da ist noch Luft nach oben ;-)

[Mo53]

@Delphi.Narium es soll die längste Ziffernfolge (Zahlenfolge) ausgegeben werden, irrelevant ist dabei die Größe der einzelnen Zahlen.

[Delphi.Narium]

Zitat:

Zitat von Mo53 (Beitrag 1490704)

@Delphi.Narium es soll die längste Ziffernfolge (Zahlenfolge) ausgegeben werden, irrelevant ist dabei die Größe der einzelnen Zahlen.

Ja, das ist klar.

Und wie lang ist bei

Delphi-Quellcode:

1234567890aaaaaaaaaa -> 00000

die längste Ziffernfolge?

Deine Routine sagt: Die Länge der längsten Ziffernfolge ist 0. Das ist wohl kaum richtig.

Bei Deiner Routine wäre auch bei

Delphi-Quellcode:

0000000000aaaaaaaaaa

die Länge der längsten Ziffernfolge = 0, ebenso bei

Delphi-Quellcode:

9999999999aaaaaaaaaa

und selbst bei

Delphi-Quellcode:

0 (hier bitte eine unendliche Anzahl von Nullen einfügen) 0a

wäre die Länge = 0.

Oder anders: Das Ergebnis Deiner Rouitne entspricht nicht der von Dir genannten Vorgabe:

Zitat:

es soll die längste Ziffernfolge (Zahlenfolge) ausgegeben werden, irrelevant ist dabei die Größe der einzelnen Zahlen.

Das Ergebnis der jetzigen Routine zur Längenermittlung ist schlicht und einfach falsch. Wird diese Routine nun so geändert, dass statt der Länge der längsten Ziffernfolge die längste Ziffernfolge zurückgegeben wird, bleibt das Ergebnis trotzdem falsch. Deine Logik enthält einen grundsätzlichen Fehler.

Der Fehler war übrigens in Deinem Post https://www.delphipraxis.net/1490636-post18.html noch nicht enthalten.

[Mo53]

Zitat:

Zitat von Delphi.Narium (Beitrag 1490706)

Der Fehler war übrigens in Deinem Post https://www.delphipraxis.net/1490636-post18.html noch nicht enthalten.

Achso Danke für den Hinweis, dann war der Fehler wohl das Begin und End, ich weiß ehrlich gesagt auch nicht mehr wie es den Weg dahin gefunden hat:lol:

[Mo53]

Ich benötige dafür copy und pos wahrscheinlich und müsste dann zwischen den copys vergleichen, welche davon größer ist, bin mir aber nicht sicher, stimmt das so ?

[Delphi.Narium]

Nö, das geht auch ohne Copy und Pos:

Du hast eine Stelle, an der Du momentan unter einer gewissen Bedingung Number hochzählst. Dort kannst Du das Zeichen, das zum Hochzählen führt, auch an einen String dranhängen. Damit wird ein String dann jeweils solange um eine Ziffer verlängert, wie auch Number hochgezählt wird.
Ist ein Zeichen keine Ziffer, speicherst Du Number in LongNum. Dort kannst Du analog auch einen String in 'ner weiteren Variabel speichern.

Am Ende gibst Du dann statt Number den dann längsten String zurück.

Du brauchst also nur zwei Stringvariabeln zusätzlich. Der Rest ist nur eine marginale Änderung der bisherigen Funktion. Zusätzliche Abfragen, zu den bisher implementierten, sind dazu nicht nötig.
Nur der intelligente Einsatz zusätzlicher begin und end sowie der Zuweisung zu Stringvariabeln. Die Funktion dürfte dadurch um grob ein Dutzend Zeilen länger werden ;-)

[Mo53]

Zitat:

Zitat von Delphi.Narium (Beitrag 1490724)

Dort kannst Du das Zeichen, das zum Hochzählen führt, auch an einen String dranhängen.

Wie genau funktioniert das dranhängen, das habe ich nicht ganz verstanden.
:?:

[Delphi.Narium]

Delphi-Quellcode:

s := s + 'A';

oder

Delphi-Quellcode:

NumberString := NumberString + s[run];

[Mo53]

Ist dann mit 'A' die Zahl gemeint ?
Und wenn ich dann die zweite Variante nehme muss ich dann unten bei longestNumber := NumberString eintragen ? das funktioniert ja nicht da longestNumber vom Datentyp byte ist und NumberString ein string.

Sorry für die dummen Fragen, ich komme da einfach nicht weiter.:drunken:

[Delphi.Narium]

Nein, 'A ist als Beispiel für das Anhängen eines einzelnen Zeichens an einen String gedacht.

Delphi-Quellcode:

StringVariabel := StringVariabel + 'String';

oder

Delphi-Quellcode:

StringVariabel := StringVariabel + AndereStringVariabel;

Wenn der Rückgabewert von LongestNumber ein String sein soll, dann muss halt LongestNumber vom Typ String sein. Man ersetze byte durch string.

[Michael II]

Da der zu durchsuchende String beim Aufruf der Funktion vollständig bekannt ist: Verzichte möglichst auf "teure" Additionen von Strings: Es macht zum Beispiel genau 0 Sinn, wenn du jede auftretende Ziffernfolge aufaddierst, diese abspeicherst, nur um sie später wieder zu verwerfen, wenn du eine längere Folge gefunden hast. - Stringoperationen kosten viel, Integerops wenig.

Merke dir also nur Start und Länge der jeweils "maximalen" Folge und nicht den Zeichensalat.

Beispiel:
A0022DJIOE390220DJIWOEDJ390J3

An Position i=1 liest du A und tust nix.
An i=2 liest du 0. Du merkst dir start=2, dann liest du 0, 2, 2.
Bei i=6 liest du "D"; also keine Ziffer mehr. Du hast die erste Ziffernfolge gefunden: Laenge = i-start = 6-2 = 4. Du merkst dir die momentan längste Folge, indem du maxstart=start=2 und maxlaenge=laenge=4 speicherst.

Es folgen keine Ziffern bis und mit i=10. Du tust nix.
Bei i=11 liest du eine 3. Du merkst dir start=11. Bei i=17 "D" ist die Ziffernfolge zu Ende. Die Laenge = i-start beträgt Laenge=17-11 = 6. Laenge=6 ist grösser als die bisherige maxlaenge=4 => Du merkst dir maxstart=11 maxlaenge=6 usw.

Am Ende weisst du, dass eine längste Folge bei maxstart beginnt und maxlaenge lang ist.

Auf dem zehnjährigen 2,2GHz Prozessor i7-3620QM können so 1000 1Mio Zeichen lange Strings in 4,4 Sekunden durchsucht werden.

Delphi-Quellcode:

function LaengsteZiffernFolgeDerWelt( s : string ) : string;
var
  len_s,
  maxlaenge, maxstart, laenge, start, i: Integer;

begin
  start := 0;
  maxlaenge := 0;
  maxstart := 0;
  i := 1;
  len_s := length(s);
  while i <= len_s do
  begin
    if ( s[i] in ['0'..'9'] ) then
    begin
      if start = 0 then start := i
    end
    else
    begin
      if start > 0 then
      begin
        laenge := i-start;
        if laenge > maxlaenge then
        begin
          maxlaenge := laenge;
          maxstart := start;
        end;
        start := 0;
      end;
    end;
    inc(i);
  end;

  if start > 0 then // *
  begin
    laenge := i-start;
    if laenge > maxlaenge then
    begin
      maxlaenge := laenge;
      maxstart := start;
    end;
  end;

  if maxlaenge > 0 then Result := Copy( s, maxstart, maxlaenge )
  else Result := '';
end;

* Wenn s[length(s)] eine Ziffer ist, dann müssen wir noch prüfen, ob diese letzte Ziffernfolge in s die längste ist. Du könntest auch gleich nach dem "begin" der Funktion an s ein "Nichtzifferzeichen" anhängen. Also s := s+'A'; Dann kannst du auf diesen Check (if start > 0 then begin... end) verzichten. In den allermeisten Fällen wäre das sicher auch ok...

[Amateurprofi]

Oder so:

Delphi-Quellcode:

FUNCTION LongestCipherSequence(const S:String):Integer;
var N:Integer; P:PChar;
begin
   Result:=0;
   P:=PChar(S);
   if P<>Nil then
      repeat
         case P^ of
            #0       :  Break;
            '0'..'9' :  begin
                           N:=1;
                           Inc(P);
                           while P^ in ['0'..'9'] do begin
                              Inc(N);
                              Inc(P);
                           end;
                           if N>Result then Result:=N;
                        end;
            else        Inc(P);
         end;
      until False;
end;

Oder um Michaels Hinweis aufzugreifen:

Delphi-Quellcode:

FUNCTION LongestCipherSequence2(const S:String):Integer;
var P,PS:PChar;
begin
   Result:=0;
   P:=PChar(S);
   if P<>Nil then
      repeat
         case P^ of
            #0       :  Break;
            '0'..'9' :  begin
                           PS:=P;
                           Inc(P);
                           while P^ in ['0'..'9'] do Inc(P);
                           if P-PS>Result then Result:=P-PS;
                        end;
            else        Inc(P);
         end;
      until False;
end;

Delphi-Quellcode:

PROCEDURE TMain.Test;
const S='1A22B333C4444D55555E';
begin
   ShowMessage(IntToStr(LongestCipherSequence(S)));
   ShowMessage(IntToStr(LongestCipherSequence2(S)));
end;

[Michael II]

Zitat:

Zitat von Amateurprofi (Beitrag 1490743)

Oder so:

Nicht "oder so", sondern nur so wie Profi ;-).
Es gibt allerdings einen Unterschied: #37 liefert wie in #26 verlangt den String, #38 die Position.
Zeitlich bewegen wir uns im gleichen Rahmen. Profi nutzt aus, dass Strings Null-terminiert sind, muss aber die =#0 Abfrage bei jedem Zeichen ausführen, #37 "einmal" am Schluss *.

[Mo53]

Wirklich sehr Interessant, Vielen Dank für eure Mühe:-D