Algorithmus

[Curby]

Kann jemand diese Frage beantworten?
Ich versteh zwar die Frage, weiß aber nicht, wie man sowas proggt.

Erstellen Sie einen Algorithmus, der in einem übergebenen Text die Häufigkeit eines übergebenen Zeichens bestimmt und zurückliefert. Schreiben Sie den Algorithmus als Pascal-Unterprogramm (Funktion und Prozedur)!
Notieren Sie zu beiden Unterprogrammen jeweils einen Aufruf in einem anderen Programmteil und die dazu notwendigen Variablendeklarationen.

[neolithos]

Zitat:

Notieren Sie zu beiden Unterprogrammen jeweils einen Aufruf in einem anderen Programmteil und die dazu notwendigen Variablendeklarationen.

Wieso beiden ich sehe bloß eines!

[Phoenix]

Hrm. Ich würde da auch nur eine einzelne Funktion draus machen:

Delphi-Quellcode:

function GetCharCount(source: string; token: char): integer;
var
   i: integer;
begin
   result := 0;
   for i := 0 to length(source) - 1 do
      if source[i] = token then
         inc(result);
end;

[negaH]

Delphi-Quellcode:

type
  TCharEntropie = array[Char] of Integer;

function CharEntropie(const Value: String): TCharEntropie;
var
  I: Integer;
begin
  FillChar(Result, SizeOf(Result));
  for I := 1 to Length(Value) do
    Inc(Result[Value[I]]);
end;

begin
  WriteLn( 'Häufigkeit von A ist ', CharEntropie('hAllAlilo')['A'] );
end;

Gruß Hagen

[Chewie]

Zitat:

Zitat von neolithos

Zitat:

Notieren Sie zu beiden Unterprogrammen jeweils einen Aufruf in einem anderen Programmteil und die dazu notwendigen Variablendeklarationen.

Wieso beiden ich sehe bloß eines!

Auch wenns recht sinnlos ist, ich nehme an, das ist gemeint:

Zitat:

Schreiben Sie den Algorithmus als Pascal-Unterprogramm (Funktion und Prozedur)!

[neolithos]

Wer lesen kann ist klar im Vorteil:

Delphi-Quellcode:

function CountChar(const asValue : String; acCh : Char) : Integer;
var I : Integer;
begin
  Result := 0;
  for I := 1 to Length(asValue) do
      if asValue[I] = acCh then
         Inc(Result);
end;

und

Delphi-Quellcode:

procedure CountChar(const asValue : String; acCh : Char; var iCount : Integer);
var I : Integer;
begin
  iCount := 0;
  for I := 1 to Length(asValue) do
      if asValue[I] = acCh then
         Inc(iCount);
end;

[Curby]

Ist "acCh" eine Variable oder ein fester Begriff?

"acCh : Char" --> "acCh := Char"
Fehlt da nicht das Gleichheitszeichen?

[RomanK]

Hoi,
acCh ist ein Zeichen(Char) und dieses wird deiner Funktion/Procedure übergeben.

[himitsu]

:arrow: Erstellen Sie einen Algorithmus, der in einem übergebenen Text die Häufigkeit eines übergebenen Zeichens bestimmt und zurückliefert. Schreiben Sie den Algorithmus als Pascal-Unterprogramm (Funktion und Prozedur)!

Delphi-Quellcode:

Function CountChar(asValue: String; acCh: Char): Integer;
  Var I: Integer;

  Begin
    { Zeichen zählen }
    Result := 0;
    For I := 1 to Length(asValue) do
      If asValue[I] = acCh Then Inc(Result);
  End;

Procedure CountChar(asValue: String; acCh: Char; Var iCount: Integer);
  Var I: Integer;

  Begin
    { Zeichen zählen }
    iCount := 0;
    For I := 1 to Length(asValue) do
      If asValue[I] = acCh Then Inc(iCount);
  End;

:arrow: Notieren Sie zu beiden Unterprogrammen jeweils einen Aufruf in einem anderen Programmteil und die dazu notwendigen Variablendeklarationen.

Delphi-Quellcode:

Procedure Test:
  Var asValue: String;  { Variablendeklarationen }
    acCh: Char; 
    iCount: Integer;

  Begin
    asValue := 'Test Test Test...'; { zu testender String  }
    acCh := 't';                    { zu zählendes Zeichen }

    { Aufruf der Funktion }
    iCount := CountChar(asValue, acCh);

    { Aufruf der Prozedur }
    CountChar(asValue, acCh, iCount);

    { iCount = Anzahl der Zeichen }
  End;

***
Da aber nicht gesag wird, das auf Groß-/Kleinschreibung geachtet werden soll. Ist hier noch eine andere Lösung.
(Wenn z.B. nach "a" gesucht wird, werden alle "a" und "A" gezählt)

Delphi-Quellcode:

Function CountChar(asValue: String; acCh: Char): Integer;
  Var I: Integer;

  Begin
    { in Kleinschreibung umwandeln }
    acCh := LowerCase(acCh);
    asValue := LowerCase(asValue);
    { Zeichen zählen }
    Result := 0;
    For I := 1 to Length(asValue) do
      If asValue[I] = acCh Then Inc(Result);
  End;

Procedure CountChar(asValue: String; acCh: Char; Var iCount: Integer);
  Var I: Integer;

  Begin
    { in Kleinschreibung umwandeln }
    acCh := LowerCase(acCh);
    asValue := LowerCase(asValue);
    { Zeichen zählen }
    iCount := 0;
    For I := 1 to Length(asValue) do
      If asValue[I] = acCh Then Inc(iCount);
  End;

Procedure Test:
  Var asValue: String;  { Variablendeklarationen }
    acCh: Char; 
    iCount: Integer;

  Begin
    asValue := 'Test Test Test...'; { zu testender String }
    acCh := 't';                    { zu suchendes Zeichen }

    { Aufruf der Funktion }
    iCount := CountChar(asValue, acCh);

    { Aufruf der Prozedur }
    CountChar(asValue, acCh, iCount);

    { iCount = Anzahl der Zeichen }
  End;

:idea: Das "VAR" in der Variablendeklarationen der Prozedur bestimmt das der nachfolgende Parameter geändert und übergeben werden kann. Das ist dazu, um den Wert (hier ist es Anzahl der gefunden Zeichen) aus der Prozedur heraus zu bekommen.
Wenn das "VAR" fehlt kannst du den Wert ändern wie du willst, bekommst ihn aber nie zurückgeliefert.

[Jens Schumann]

Hallo,
ich habe hier noch einen Vorschlag

Delphi-Quellcode:

TSignArray = Array [0..255] of Double; // Entspricht dem Ordinalwert der ASCII-Zeichen

procedure TForm1.DoIt(aText: TStrings; var aArray: TSignArray);
var
  iCnt : Integer;
begin
  // Array löschen
  For iCnt:=Low(aArray) to High(aArray) do
    aArray[iCnt]:=0.0;
  // Berechne über den Ordinalwert des ASCII-Zeichens den Index im Array
  // und erhöhe den Wert an dieser Stelle um 1
  For iCnt:=1 to Length(aText.Text) do
    aArray[Ord(aText.Text[iCnt])]:=aArray[Ord(aText.Text[iCnt])]+1.0;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  MyArray : TSignArray;
  iCnt    : Integer;
  Gesamt  : Double;
begin
  DoIt(Memo1.Lines,MyArray);
  Gesamt:=0.0;
  // Berechne die Anzahl der Zeichen im Text
  Gesamt:=Length(Memo1.Lines.Text);
  // Die Anzahl eines einzelnen Zeichen geteilt durch die Gesamtanzahl
  // ergibt die Häufigkeit
  For iCnt:=Low(MyArray) to High(MyArray) do
    MyArray[iCnt]:=MyArray[iCnt]/Gesamt;
  // TChart befüllen
  Series1.Clear;
  For iCnt:=Low(MyArray) to High(MyArray) do
    Series1.Add(MyArray[iCnt],IntToStr(iCnt),clRed);

  Gesamt:=0.0;
  // Test, ob die Summe der Häufigkeiten 1 ergibt
  For iCnt:=Low(MyArray) to High(MyArray) do
    Gesamt:=Gesamt+MyArray[iCnt];
  ShowMessage(FloatToStr(Gesamt));

  // Rechne die Häufigkeiten in Prozent um
  For iCnt:=Low(MyArray) to High(MyArray) do
    MyArray[iCnt]:=MyArray[iCnt]*100;
  Gesamt:=0.0;
  // Test, ob die Summe der Häufigkeiten 100% ergibt
  For iCnt:=Low(MyArray) to High(MyArray) do
    Gesamt:=Gesamt+MyArray[iCnt];
  ShowMessage(FloatToStr(Gesamt));
end;

Der Algorithmus verwendet ein Array um die Anzahl der einzelnen zu ermitteln.
Dabei entspricht der Index im Array dem Ordinalwert des ASCII-Zeichens.
Jetzt kann für jedes Zeichen im Text der Ordinalwert berechnet werden. Dieser Ordinalwert wird als
Index für das Array verwendet, um den Wert an der Position um 1 zu erhöhen. Anschließend wird jedes Element im Array durch die Gesamtanzahl der Zeichen geteilt. Damit steht im Array die Häufigkeit des jeweiligen Zeichens. Über MyArray[Ord('a')] erhält man dann die Häufigkeit des Zeichens a.
Wüsste evt. jemand wie es noch schneller gehen könnte alle Häufigkeiten in einem Text zu berechnen?