teilweise permutation

[ajaxson]

hy!

ich suche einen algorithmus mit dem nur bestimmte buchstaben eines strings vertauscht werden.

z.b. ABCDEFG
ABCDFEG
ABCEDFG
ABCEFDG
etc.

es soll also jeweils der erste und letzte buchstabe stehen bleiben. die stringlänge kann variieren (also z.b.auch nur ABCDE).
weiß nicht recht wie ich das machen soll. ich hab an eine permutation gedacht.

hoffe ihr könnt mir helfen!

:dp: thx im voraus! :dp:

MfG ajaxson

[Kroko1999]

bilde die Permutationen über die Mitte und füge den ersten und letzten wert dazu

[ajaxson]

tut mir leid das versteh ich jetzt nicht ganz.

wie meinst du das "über die mitte"?

(muss dazu sagen das ich noch anfänger im umgang mit delphi bin)

[Kroko1999]

permutiere den String über alle Zeichen in der Mitte (vom zweiten bis zum vorletzten) und füge den ersten und letzten zum Ergebnis hinzu:

Bsp:
BCD -> ABCDE
BDC -> ADBCE
CBD -> ACBDE
CDB -> ACDBE
DBC -> ADBCE
DCB -> ADCBE

[grenzgaenger]

so in etwa ...

Delphi-Quellcode:

while solangeduwillst do
  ergebnis = copy(sourcestring,1,1) + permutation(copy(sourcestring,2,length(sourcestring)-2) + copy(sourcestring,length(sourcestring)-1,1);

[ajaxson]

ok thx..da werd ich mal versuchen das umzusetzten. :thumb:

[r2c2]

Falls du das mit der "englischen Universität" und der angeblichen Lesbarkeit von permutierten Wörtern, bei denen nur der 1. und letzte Buchstabe stimmen, umsetzen willst, muss ich dich leider enttäuschen: Das is n Hoax. ==> es funktioniert nur in Ausnahmefällen. Ich habs zuerst auch geglaubt und irgendwann mal gelesen, dass das n Hoax sein soll. Google bestätigte das dann...

mfg

Christian

[ajaxson]

ne das ist für eine andere aufgabe gedacht ;)

[Nicolai1234]

Zitat:

Zitat von r2c2

Falls du das mit der "englischen Universität" und der angeblichen Lesbarkeit von permutierten Wörtern, bei denen nur der 1. und letzte Buchstabe stimmen, umsetzen willst, muss ich dich leider enttäuschen: Das is n Hoax. ==> es funktioniert nur in Ausnahmefällen. Ich habs zuerst auch geglaubt und irgendwann mal gelesen, dass das n Hoax sein soll. Google bestätigte das dann...

Wieso muss man glauben, dass das ein Hoax ist und das bei google überprüfen?

Das Thema war ja mal ne Weile in den Medien (etwas übertrieben gesagt) und man konnte solche Artikel auch in der Zeitung lesen und das war eigentlich kein Problem. Ich denke nicht, dass das spezielle Wörter waren...

[r2c2]

Zitat:

Zitat von Nicolai1605

Zitat:

Zitat von r2c2

Falls du das mit der "englischen Universität" und der angeblichen Lesbarkeit von permutierten Wörtern, bei denen nur der 1. und letzte Buchstabe stimmen, umsetzen willst, muss ich dich leider enttäuschen: Das is n Hoax. ==> es funktioniert nur in Ausnahmefällen. Ich habs zuerst auch geglaubt und irgendwann mal gelesen, dass das n Hoax sein soll. Google bestätigte das dann...

Wieso muss man glauben, dass das ein Hoax ist und das bei google überprüfen?

Man muss nicht glauben, dass es ein Hoax ist. Wie gesagt: Ich hab es zuerst auch geglaubt, dass die Studie wirklich existiert. Wenn ich aber schon höre, dass es ein Hoax sein könnte[1], ist das für mich schonmal ein Zeichen dafür kritisch zu sein. Dann mache zumindest ich folgendes: a) Suchen(z.B. mit google) und b) selber denken. Und dann komme ich auf sowas wie das hier:
http://www.delphi-forum.de/viewtopic.php?p=281016

Zitat:

Das Thema war ja mal ne Weile in den Medien (etwas übertrieben gesagt) und man konnte solche Artikel auch in der Zeitung lesen und das war eigentlich kein Problem. Ich denke nicht, dass das spezielle Wörter waren...

Nicht spezielle Wörter, aber vergleichsweise einfache Texte, vergleichsweise kurze Wörter und einfache Permutationen. Das schließt natürlich nicht aus, dass das ein oder andere Wort komplizierter, länger, etc. ist, aber in der Gesamtheit wird es so sein.

[1] im konkreten Fall war es dieser Post, der mich daraf aufmerksam gemacht hat.

mfg

Christian

P.S.: Pssst! Ich glaub wir werden etwas OT...

[ajaxson]

um jetzt mal wieder zu mir zurück zu kommen :lol:

procedure permutation(eingabe:string);
var ergebnis:string;
begin
while x=length(eingabe) -2 do
begin
ergebnis := copy(eingabe,1,1) + permutation(copy(eingabe,2,length(eingabe)-2)) + copy(eingabe,length(eingabe)-1,1);<----die zeile wird als fehler markiert
x:=x+1;
end;
end;

er gibt mir folgende fehlermeldung:[Pascal Fehler] Unit1.pas(79): E2010 Inkompatible Typen: 'string' und 'procedure, untyped pointer or untyped parameter'

[Namenloser]

"permutation" ist als procedure deklariert und hat keinen Rückgabewert. Daher der Fehler.

[ajaxson]

:wall: ok thx^^

[ajaxson]

Code:

function permutation(eingabe:string):string;
var ergebnis:string;
begin
while x<>length(eingabe) -2 do
 begin
  x:=x+1;
  ergebnis := copy(eingabe,1,1) + permutation(copy(eingabe,2,length(eingabe)-2)) + copy(eingabe,length(eingabe)-1,1);

  form1.Memo1.Lines.Add(ergebnis);
 end;
  end;

irgendwie funktioniert das nicht...das programm bricht nach ner zeit ab(overflow) und gibt nur ad aus(bei eingabe abcde).
hat jemand schon einmal jemand einen ähnlichen algorithmus geschrieben? Beispiele wären hilfreich. :( :( :(

[Medium]

Wenn du jetzt noch "ergebnis" einfach mal nach Englisch übersetzt, und aus der Variablendeklaration heraus nimmst, bist du schon mal ein großes Stück weiter. Ob ein ordentliches Abbruchkriterium erreicht wird kann ich dank Müdigkeit gerade nicht sehen, ich finde es aber schon seltsam eine while-Schleife in einer Rekursion dort einzusetzen, in der die Rekursion statt findet. Darüber hinaus scheint "x" irgendwo deklariert zu sein, und ist somit wohl auch noch für alle rekursiven Aufrufe das selbe. Macht auf mich grad einen recht planlosen Eindruck, will aber nicht ausschließen dass auch ich morgen nach ein paar Stunden Schlaf erkenne was du da machst ;)

Edit: Also... irgendwie... WAS zum Geier soll da passieren!? Du rufst eine Funktion auf, die die inneren Zeichen eines Strings herauskopiert, und damit rufst du die Funktion nochmal auf. Das tust du sogar noch so oft, wie der String lang ist minus 2. Die rekursiv aufgerufenen Funktionen tun das selbe, nur mit den verkürzten Strings, und gibst diese dann zurück, und schreibst das in ein Memo. Ganz nebenbei zählst du eine Variable irgendwie hoch, die nachher irgendwas wildes enthalten dürfte, aber niemals zum Terminieren der Rekursion führen wird. Das ist von vorne bis hinten Unsinn. Ich empfehle mindestens die Wikipedia-Einträge zur Rekursion und Permutation zu lesen (und verinnerlichen), und zudem ein paar Pascal-Grundlagen ("result" anyone?). Weil wenn wir so weiter machen, wirds ein Geschustere, und am Ende wird irgendwer entnervt einfach eine fertige Funktion posten die du kopieren kannst, aber mehr wissen wirste dann auch nicht.

[omata]

Hier mal ein Vorschlag...

Delphi-Quellcode:

procedure permutation(mitte:string; Liste:TStrings);

  procedure permut(links, mitte, rechts:string);
  var i:integer;
      temp:string;
  begin
    if mitte = '' then
      Liste.Append(links + rechts)
    else
      for i:=1 to length(mitte) do begin
        temp:=mitte;
        delete(temp, i, 1);
        permut(links + mitte[i], temp, rechts);
      end;
  end;

var links, rechts:string;
begin
  Liste.Clear;
  links:=copy(mitte, 1, 1);
  delete(mitte, 1, 1);
  rechts:=copy(mitte, length(mitte), 1);
  delete(mitte, length(mitte), 1);
  permut(links, mitte, rechts);
end;

procedure TForm.ButtonClick(Sender: TObject);
begin
  permutation('ABCDEFG', Memo.Lines);
end;

Gruss
Thorsten