CaseCorrection d. Permutataion / BruteForce d. 2. Dimension

[Harry M.]

Hallöchen ich bins wieder :mrgreen:

Ich versuche alle Möglichkeiten von %s zu finden. Aber nich wie gewöhlich a..z sondern a..A

Mein ungefährer Ansatz:
Ich nehme an der "Mod" Operator "verrechnet" im wahrsten Sinne de Worts die 2. Spalte aus der Beispiel Matix.
Oder wie seht Ihr das?

Delphi-Quellcode:

program Demo;

{$APPTYPE CONSOLE}

uses
  SysUtils;

function CaseCorrection(var AStr: String; ACharToCase: Integer): String;
var
  S: String;
  X: Integer;
begin
  if ACharToCase > Length(AStr) then
    ACharToCase := ACharToCase mod Length(Astr);

  S := AStr[ACharToCase];
  if S = LowerCase(S) then
    S := UpperCase(S)
    else
    S := LowerCase(S);

  Insert(S, AStr, ACharToCase);
  Delete(AStr, ACharToCase+1, 1);
  Result := Trim(AStr);
end;

const
  StrToCorrection = 'ABC';
  // aBC, abC, abc
  // AbC, Abc, aBc
  // AbC, ABc, ABC
var
  S: String;
  I, iCount: Integer;
begin
  S := StrToCorrection;
  iCount := Length(StrToCorrection) * Length(StrToCorrection);

  for I := 1 to iCount do
    writeln( CaseCorrection(S, I) );

  readln;
end.

[Flocke]

Zitat:

Zitat von Harry M.

Ich nehme an der "Mod" Operator "verrechnet" im wahrsten Sinne de Worts die 2. Spalte aus der Beispiel Matix.

Der Operator mod liefert Werte zwischen 0 und Length(Astr)-1, du brauchst aber Werte zwischen 1 und Length(Astr).

Also:

Delphi-Quellcode:

  if ACharToCase > Length(AStr) then
    ACharToCase := 1 + (ACharToCase - 1) mod Length(Astr);

[Harry M.]

Nach dem 6. Durchgang beginnen wiederholungen :(

aBC <-
abC
abc
Abc
ABc
ABC
aBC <-
abC
abc

[marabu]

Hallo Harry,

ein Wort mit drei Buchstaben hat mitnichten 9 (3 * 3) Variationen:

Delphi-Quellcode:

uses
  StrUtils;

procedure VariateCase(s: string; sl: TStrings);
var
  i, n: Integer;
begin
  sl.BeginUpdate;
  sl.Clear;
  for n := 0 to Pred(1 shl Length(s)) do
  begin
    for i := Length(s) downto 1 do
      s[i] := IfThen(Odd(n shr Pred(i)), AnsiUpperCase(s[i]), AnsiLowerCase(s[i]))[1];
    sl.Add(s);
  end;
  sl.EndUpdate;
end;

Grüße vom marabu

[Harry M.]

Hallo marabu,

Das sieht schon mal nicht schlecht aus. Nur Zahlen funzen irgenwie nicht.
"Mitnichten" wie muss ich das verstehen. Wären es nun 3² oder 2³. 3 Zeichen x Ihre Grossbuchstaben. :roll:

[marabu]

Hallo Harry,

natürlich sind es nicht 3 * 3 Möglichkeiten, sondern 2 * 2 * 2.

Wenn das Wort auch Zeichen enthält, bei denen Uppercase(char) = Lowercase(char) ist, dann müsste ich an meinem Code zwei kleine Änderungen machen.

Freundliche Grüße

[Harry M.]

Ich nehme an eine dieser Änderungen wären ungefähr so:

Delphi-Quellcode:

 IfThen(Odd(n shl i), s[i], s[Pred(i)])[1]

Geht das in die richtige Richtung?

[marabu]

Haarscharf daneben:

Delphi-Quellcode:

procedure VariateCase(s: string; sl: TStrings);
const
  LETTERS: set of Char = ['a'..'z','A'..'Z', 'ä', 'Ä', 'ö', 'Ö', 'ü', 'Ü'];
var
  i, skip, n, len: Integer;
begin
  len := 0;
  for i := 1 to Length(s) do
    Inc(len, Ord(s[i] in LETTERS));
  sl.BeginUpdate;
  sl.Clear;
  for n := 0 to Pred(1 shl len) do
  begin
    skip := 0;
    for i := 1 to len do
    begin
      while not (s[i + skip] in LETTERS) do
        Inc(skip);
      s[i + Skip] := IfThen(Odd(n shr Pred(i)), AnsiUpperCase(s[i + skip]), AnsiLowerCase(s[i + skip]))[1];
    end;
    sl.Add(s);
  end;
  sl.EndUpdate;
end;

[Harry M.]

Hm...Sieht irgenwie genial aus :thumb: Sei Dir gedankt.

Ich versteh max die Hälfte. Aber ich werd mir das noch oft genug ansehen.
Villeicht kannst Du mir das nich mit ein paar Worten erklären.

[marabu]

Hallo Harry,

die Idee hinter meinem Code ist einfach: Ein Wort mit n Buchstaben kann ordnungserhaltend (Position der Zeichen darf nicht verändert werden) auf zwei (Zahl der Freiheitsgrade, Upper- oder Lowercase) hoch n (Zahl der Buchstaben) verschiedene Arten geschrieben werden. Wenn ich die Buchstabenpositionen als die Stellen einer Dualzahl betrachte und festlege, dass für jedes 1-Bit ein Großbuchstabe und für jedes 0-Bit ein Kleinbuchstabe gesetzt wird, dann sollte mein Code aus Beitrag #4 verständlich sein. Die Prozedur hat einen String als Eingabeparameter und eine StringList als Ausgabeparameter. Für den Fall, dass die StringList Teil einer visuellen Komponente ist, wird noch die Aktualisierung während der Schleifendurchläufe unterdrückt.

Für Wörter mit Zeichen, deren Schreibweise nicht variiert, sind genau zwei Änderungen nötig gewesen: Die Bestimmung von n ist nicht mehr einfach die Länge des Wortes - Zeichen mit invarianter Schreibweise dürfen nicht mitgezählt werden. Deshalb die Längenberechnung zu Beginn des Codes in Beitrag #8. In der Schleife müssen genau die invarianten Zeichen übersprungen werden, deshalb der berechnete Index (i + skip).

Gute Nacht