String nach bestimmten Zeichen(Buchstaben) absuchen

[G4schi]

Hallo, ich bin ein Neuling in der Kultur der Programmierer und hänge gerade an einer kleinen Aufgabe.


Das Konzept:

Ich gebe ein Wort in ein Textfeld ein. Drücke auf einen Button und die Anzahl der Buchstaben im Textfeld werden gezählt,
dann in einem Label mit '*' ausgegeben, in der Anzahl der Buchstaben.

Jetzt möchte ich weitere Buttons einrichten mit einzelnen Buchstaben.

Wenn ich auf einen Buchstaben klicke und dieser in diesem Wort nicht vorhanden ist, soll ein Zähler die Fehler zählen, das mache ich selbst.
Später wird das noch erweitert aber erstmal nur das.

Mit welcher Funktion oder Anweisung kann ich diesen Buchstaben abgleich machen?
Ich denke mir, dass es in die Richtung mit "if....then....else" gehen sollte.



MfG G4schi

[mkinzler]

Z.B. Pos/PosEx oder StrScan

[Sherlock]

Der Inhalt des Textfeldes muss Zeichen für Zeichen durchgegangen werden, für jedes Zeichen auf das man dabei trifft prüft man ob man dieses Zeichen bereits gesehen hat und erhöht in dem Fall den entsprechenden Zähler, ansonsten merkt man sich dieses neue Zeichen.

Das spannendste dabei ist, wie man sich diese Zeichen/Anzahl Kombination merkt. Das ist vermutlich die Paradesituation für ein TDictionary.
Der Rest ist mit einer For-Schleife und den bereits von Dir angerissenen If-Konstrukt zu erledigen.

Viel Spaß

Edith ist gespannt, wie das mit Pos oder PosEx gelöst wird.

Sherlock

[Blup]

Eine einfache for-Schleife tuts hier eigentlich auch. Wenn nach Zeichenfolgen gesucht werde soll, lässt sich mit PosEx schon was basteln.

Delphi-Quellcode:

function ZaehleFundstellen(const ASubStr, AText: string): Integer;
{---}
  function FindNext(const ASubStr, AText: string; var AIndex: Integer): Boolean; inline;
  begin
    // ab der Position AIndex nach dem Buchstaben suchen, AIndex auf die nächste Fundstelle setzen
    AIndex := PosEx(ASubStr, AText, AIndex);
    // wenn der Buchstaben nicht mehr gefunden wurde ist AIndex = 0
    Result := (AIndex > 0);
  end;
{---}
var
  i: Integer;
begin
  Result := 0;
  // i zeigt auf den ersten Buchstaben
  i := 1;
  while FindNext(ASubStr, AText, i) do
  begin
    // Fundstelle zählen
    Inc(Result);
    // i auf den nächsten Buchstaben nach der Fundstelle
    Inc(i, Length(ASubStr));
  end;
end;

procedure TForm1.ButtonClick(Sender: TObject);
var
  sText, sSuchtext: string
  iAnzahl: Integer;
begin
  sSuchtext := TButton(Sender).Caption;
  sText := Edit1.Text;
  iAnzahl := ZaehleFundstellen(sSuchtext, sText);
  Memo1.Lines.Add(Format('"%s" %d x gefunden', [sSuchtext, iAnzahl]));
end;

[hoika]

Hallo,

Zitat:

Wenn ich auf einen Buchstaben klicke und dieser in diesem Wort nicht vorhanden ist, soll ein Zähler die Fehler zählen

Dafür reicht ja wirklich Pos.

Delphi-Quellcode:

if Pos('A','CDE')=0 then
begin
  // hier geht's rein
end;

[himitsu]

ContainsStr
ContainsText

[madas]

Wenn es wirklich nur um die Anzahl der einzelnen Buchstaben geht, dann geht man den String zeichenweise durch und inkrementiert den Eintrag eines Int Arrays an der Stelle Ord(Zeichen) um 1. Dann schmeißt man z.B. an den Button für A als Tag die 65 und fragt diesen beim Klick darauf ab, um damit beim Int Array an der Stelle 65 den Wert für die Anzahl von As abzurufen.

[Luckie]

Ich glaube, ihr denkt zu kompliziert. Für mich klingt das nach einer Schulaufgabe zum Verständnis von Schleifen und if-Abfragen oder so.

Deswegen die einfache Lösung:
in einer Schleife die einzelnen Zeichen einer Zeichenkette durch gehen. Ein einzelnes Zeichen einer Zeichenkette lässt sich über den Index ansprechen: [i]Zeichenkette Jetzt kann man mit dem Zähler der for-Schleife jedes einzelne Zeichen "ansprechen" und mit einem vorgegebenen Buchstaben vergleichen. Wenn gleich, dann Zähler erhöhen.
Das war es eigentlich schon.
Zur Übung kann man das ganze mit einer for-Schleife, while-Schleife und repoeat-until-Schleife dann umsetzen. Und wenn es für die schule ist, wird es darauf hinaus laufen.

[p80286]

Falls wir uns im ASCII/Ansi - Bereich bewegen, schlage ich folgendes vor:

Delphi-Quellcode:

var 
  abstb: Array [0..255]of integer;

begin
  fillchar(abstb,#0,sizeof(abstb));
  for i:=1 to length(instr) do inc(abstb[Byte(instr[i])],1);
end
...
if abstb[buttonchar]>1 then found else error;

Gruß
K-H

[G4schi]

Nun denn, ich habe es bis jetzt soweit geschafft mit dem Code:

Delphi-Quellcode:

implementation

{$R *.dfm}
var s_Wort: string;


procedure TForm1.bt_HClick(Sender: TObject);

const bt_H = 'h';

begin
  s_Wort := (ed_Eingabe.Text);
  if StrScan(s_Wort, 'h') <> nil
  then Lb_zaehler.Caption := Lb_zaehler.Caption + '1';
end;

Das ist jetzt nur der Teil mit dem Button. Ich wollte es erstmal so angehen, dass ich dem Button eine Konstante gegeben habe
der Buchstaben 'h' und wenn der ihm s_Wort vorhanden ist, soll einfach erstmal eine '1' im Label stehen.

Jetzt kriege ich 2 Fehlermeldungen:
[dcc32 Fehler] Geigenmännchen.pas(40): E2250 Es gibt keine überladene Version von 'StrScan', die man mit diesen Argumenten aufrufen kann

[dcc32 Warnung] Geigenmännchen.pas(40): W1000 Symbol 'StrScan' ist veraltet: 'Moved to the AnsiStrings unit'

Was kann ich damit anfangen?

[Luckie]

Die Warnung lassen wir mal außen vor. Darum kümmern wir uns später.

Zitat:

Es gibt keine überladene Version von 'StrScan', die man mit diesen Argumenten aufrufen kann

Bedeutet, dass die Aufrufparameter von StrScan nicht stimmen. Guck in der Hilfe, mit welchen Parametern StrScan aufgerufen werden muss.

[Sherlock]

Danke, daß Du jetzt endlich das "Geigenmännchen" (nennt man das Galgenmännchen heute wirklich so?) in den Raum gestellt hast. -.-

Das hätte die Aufgabe deutlich erleichtern können, wenn das gleich vorher gekommen wäre ("Ich möchte ein Galgenmännchen programmieren"). Ich hab mir aus dem ersten Teil des Konzepts halt die Buchstabenzählerei zusammengereimt. Klar ist Pos, PosEx, StrScan der richtige Weg, um zu bestimmen, ob der geratene Buchstabe im versteckten Wort zu finden ist.

Mußt Dir halt jetzt noch überlegen, wie Du das zu erratene Wort darstellen kannst. Im Prinzip reicht es einfach in dem Label die gleiche Anzahl Sternchen auszugeben wie es Buchstaben im Wort gibt. Du mußt dann später die gefundenen Buchstaben offenbaren, also die Sternchen durch den richtigen Buchstaben ersetzen. Beachte, daß Großbuchstaben sich von Kleinbuchstaben unterscheiden!

Sherlock

[TigerLilly]

gelöscht

[freimatz]

Zitat:

Zitat von Sherlock (Beitrag 1379327)

Das hätte die Aufgabe deutlich erleichtern können, wenn das gleich vorher gekommen wäre ("Ich möchte ein Galgenmännchen programmieren").

Nu ja, vielleicht möchte er nur zweitrangig ein Galgenmännchen programmieren sondern erstrangig programmieren lernen. :twisted:
Da fand ich die Frage und die Diskussion dann schon hilfreicher als eine fertig Lösung. :wink:

[Codehunter]

Zitat:

Zitat von G4schi (Beitrag 1379268)

Ich gebe ein Wort in ein Textfeld ein. Drücke auf einen Button und die Anzahl der Buchstaben im Textfeld werden gezählt,
dann in einem Label mit '*' ausgegeben, in der Anzahl der Buchstaben.

Der erste, einfache Teil in aller Kürze:

Delphi-Quellcode:

Label1.Caption:= StringOfChar('*', Length(Edit1.Text));

Nun wirds ein wenig komplizierter. Ein String ist sozusagen eine Liste von Buchstaben und ggf. Steuerzeichen wie Zeilenumbruch etc. Ich sage bewusst nicht Array, denn ein Array of Char ist nicht gleichbedeutend mit String. Daher sollte man wissen, dass bei String-Iterationen immer bei 1 begonnen wird, bei Array-Iterationen dagegen bei 0. Oder aber man überlässt es gleich der Container-Iteration mit for-in:

Delphi-Quellcode:

var 
  C: Char;
  S: String;
  PositivZaehler, NegativZaehler: Integer;
begin
  S:= Edit1.Text;
  for C in S do
  begin
    // Positiv-Prüfung, ob ein Zeichen im String enthalten ist
    if C = 'a' then
      Inc(PositivZaehler);
    // Negativ-Prüfung, ob ein Zeichen NICHT im String enthalten ist
    if C <> 'a' then
      Inc(NegativZaehler);
  end;
end;

Die verschiedenen Vergleichsoperatoren wie "=" und "<>" in diesem Beispiel findest du in der Delphi-Hilfe. Natürlich geht das mit if-then-else auch und besser. Ich wollte hier nur die unterschiedlichen Operatoren erklären.

Wenn du aber beim Lehrer auf dicke Hose machen willst, geht das Ganze auch ohne Schleifen:

Delphi-Quellcode:

var 
  C: Char;
  S: String;
  PositivZaehler, NegativZaehler: Integer;
begin
  S:= Edit1.Text;
  PositivZaehler:= S.CountChar('a');
  NegativZaehler:= Length(S) - PositivZaehler;

Was da jetzt passiert ist eigentlich selbsterklärend: S.CountChar ist eine Hilfsfunktion, die der String selbst über den TStringHelper bereitstellt. Damit kannst du schon mal die Positivprüfung ganz easy machen. Mit Length(S) ermittelst du, wie viele Zeichen insgesamt im String enthalten sind, egal welche. Wenn du davon nun die Anzahl der positiv geprüften Zeichen abziehst, erhältst du logischerweise die Anzahl der negativ geprüften Zeichen. Und das ganz ohne jedes Zeichen einzeln mit if in einer Schleife getestet zu haben.

Wofür ist eine solche indirekte Zählung nütze? Sie läuft schneller. Ist wie bei Computerspielen: Je schneller desto besser. Der Programmierer sagt dazu Performanceoptimierung. Bei Strings die du manuell in ein Edit eingibst, wirst du noch keinen großen Unterschied merken. Aber vielleicht hast du es irgendwann mit viel größeren Datenmengen zu tun und da ist der Anwender der dein Programm letztlich nutzen wird, immer dankbar wenn die Eieruhr so kurz wie möglich erscheint.

Apropos Eieruhr: Die funktioniert so:

Delphi-Quellcode:

begin
  Screen.Cursor:= crHourGlass; // oder crAppStart
  try
    // Irgendwas machen das lang rechnet
  finally
    Screen.Cursor:= crDefault;
  end;
end;

Der try-finally-Block ist in Delphi sehr wichtig. Damit stellst du sicher, dass falls zwischen try und finally irgendein Fehler passiert, der Code zwischen finally und end immer ausgeführt wird. Ansonsten kanns dir passieren, dass deine Eieruhr bis zum Sanktnimmerleinstag (bzw. dem Programm-Ende) am Mauszeiger pappen bleibt.

Neben dem try-finally-Block gibt es auch einen try-except-Block, der funktioniert fast genauso. Der einzige Unterschied ist, dass der Code zwischen except und end nur dann ausgeführt wird, wenn zwischen try und except ein Fehler aufgetreten ist. Das ist nützlich, um Fehlermeldungen ausgeben zu können.