Liste mit beliebig langen Stellen

[;fricky]

nachtrag:

;fricky schrieb:

unsigned char use[N];
unsigned res[N];

mach da mal 'int' draus, sonst kriege ich wieder mecker von nwp2.

[VirusMaker]

;fricky schrieb:

mix (i+1);
use[k] = 0;

das kann ja iwie nicht funzen!

[;fricky]

VirusMaker schrieb:

;fricky schrieb:

mix (i+1);
use[k] = 0;

das kann ja iwie nicht funzen!

was geht nicht bei dir? zeig mal fehlermeldungen, oder ist die ausgabe nicht nach deinen wünschen?
benutzt du einen C++- statt eines C-compilers?

[nwp2]

Hmm, kein Plan was fricky da macht.

Ich hab da soone Idee.
Man bastle sich eine rekursive Funktion permutation(char liste[]), die bei nur einem Element in liste nur die liste zurückgibt und ansonsten die liste um 1 kürzt, permutieren lässt und dann das entfernte Element an allen Stellen einsetzt.

Ich habe das mal in python zusammengehackt:

alphabet = ["a", "b", "c", "d"]
def permutationen(liste):
    if len(liste)==1: return [liste] #bei nur einem Element gibt es nur eine Möglichkeit
    else:
        resultat = [] #sammelliste für permutationen
        for l in permutationen(liste[1:]): #das erste element sparen wir uns und packen es dann an alle stellen
            for i in range(0, len(liste)): #i ist die stelle an der das element eingefügt werden soll
                r = l[:i]
                r.extend(liste[0])
                r.extend(l[i:])
                resultat.append(r)
    return resultat

for liste in permutationen(alphabet):
    print liste

Da kommt dann sortiert sowas raus:

['a', 'b', 'c', 'd']
['a', 'b', 'd', 'c']
['a', 'c', 'b', 'd']
['a', 'c', 'd', 'b']
['a', 'd', 'b', 'c']
['a', 'd', 'c', 'b']
['b', 'a', 'c', 'd']
['b', 'a', 'd', 'c']
['b', 'c', 'a', 'd']
['b', 'c', 'd', 'a']
['b', 'd', 'a', 'c']
['b', 'd', 'c', 'a']
['c', 'a', 'b', 'd']
['c', 'a', 'd', 'b']
['c', 'b', 'a', 'd']
['c', 'b', 'd', 'a']
['c', 'd', 'a', 'b']
['c', 'd', 'b', 'a']
['d', 'a', 'b', 'c']
['d', 'a', 'c', 'b']
['d', 'b', 'a', 'c']
['d', 'b', 'c', 'a']
['d', 'c', 'a', 'b']
['d', 'c', 'b', 'a']

Ist es das was du wolltest?

In C kann man nicht so schön mit Listen hantieren, aber der Algorithmus sollte klar sein.

[volkard]

nwp2 schrieb:

Ich habe das mal in python zusammengehackt:

alphabet = ["a", "b", "c", "d"]
def permutationen(liste):
    if len(liste)==1: return [liste] #bei nur einem Element gibt es nur eine Möglichkeit
    else:
        resultat = [] #sammelliste für permutationen
        for l in permutationen(liste[1:]): #das erste element sparen wir uns und packen es dann an alle stellen
            for i in range(0, len(liste)): #i ist die stelle an der das element eingefügt werden soll
                r = l[:i]
                r.extend(liste[0])
                r.extend(l[i:])
                resultat.append(r)
    return resultat

for liste in permutationen(alphabet):
    print liste

Da kommt dann sortiert sowas raus:

['a', 'b', 'c', 'd']
['a', 'b', 'd', 'c']
['a', 'c', 'b', 'd']
['a', 'c', 'd', 'b']
['a', 'd', 'b', 'c']
['a', 'd', 'c', 'b']
['b', 'a', 'c', 'd']
['b', 'a', 'd', 'c']
['b', 'c', 'a', 'd']
['b', 'c', 'd', 'a']
['b', 'd', 'a', 'c']
['b', 'd', 'c', 'a']
['c', 'a', 'b', 'd']
['c', 'a', 'd', 'b']
['c', 'b', 'a', 'd']
['c', 'b', 'd', 'a']
['c', 'd', 'a', 'b']
['c', 'd', 'b', 'a']
['d', 'a', 'b', 'c']
['d', 'a', 'c', 'b']
['d', 'b', 'a', 'c']
['d', 'b', 'c', 'a']
['d', 'c', 'a', 'b']
['d', 'c', 'b', 'a']

Das wäre in C++ mit fricky-Erweiterungen

#include <stdio.h>
#include <algorithm>

#define FIRST 'a'  // erstes zeichen
#define LAST 'z'   // letztes zeichen
#define N (LAST-FIRST+1)  // zeichenbereich
#define LIMIT 5  // laenge der ausgabe

unsigned char use[N];

int main()
{
	for(int i=0;i<LIMIT;++i)
		use[i]=FIRST+i;
	do
		printf("%s\n",use);
	while(std::next_permutation(use,use+LIMIT));
}

und rauskommen tut

abcd
abdc
acbd
acdb
adbc
adcb
bacd
badc
bcad
bcda
bdac
bdca
cabd
cadb
cbad
cbda
cdab
cdba
dabc
dacb
dbac
dbca
dcab
dcba

nwp2 schrieb:

Ist es das was du wolltest?

Ja, das ist hier die Frage.

[;fricky]

volkard schrieb:

Das wäre in C++ mit fricky-Erweiterungen...

damit die fricky-erweiterung eure outputs erzeugt, müsst ihr sie so parametrisieren:

#define FIRST 'a'  // erstes zeichen
#define LAST 'd'   // letztes zeichen
#define N (LAST-FIRST+1)  // zeichenbereich 
#define LIMIT N  // laenge der ausgabe

aber mein permutator-hack zählt ja (im beispiel da oben) jede stelle von 'a' bis 'z' durch, hört also, (bei 'ner länge von 3) mit 'xyz' auf, so wie's der OP scheinbar haben will.
btw, ist sowas auch mit std::next_permutation möglich, oder sollte man dazu doch besser C nehmen *fg*

[VirusMaker]

EDIT:

Leute, ihr seit die Besten!!!

#include <stdio.h>
#include <algorithm>
#include <conio.h>

unsigned char use[26]="ABCDEFGHIKLMNOPQRSTUVWXYZ";

int main()
{
    int stellen;
    printf("Stellen: ");
    scanf("%d",&stellen);
    use[stellen]='\0';
    do
        printf("%s\n",use);
    while(std::next_permutation(use,use+stellen));
    getch();
}

Mit dem funktionierts!

THX AN:

• nwp2 für die Permutions-Idee
• volkard der mir gezeigt hat, wie mans in C einbaut
• ;fricky fürs mithelfen

Ihr seit einfach die besten

Schöne Weihnachten euch allen :xmas1:

[;fricky]

VirusMaker schrieb:

...volkard der mir gezeigt hat, wie mans in C einbaut

*räusper* std.next_permutation() gibts nicht in C.

[VirusMaker]

;fricky schrieb:

VirusMaker schrieb:

...volkard der mir gezeigt hat, wie mans in C einbaut

*räusper* std.next_permutation() gibts nicht in C.

echt? aja, klassen gibts ja erst ab C++ -.-

ist mir aber echt wurscht jetzt
vielleicht kann ein mod verschieben oder was, ich bin glücklich und zufrieden

MFG

[;fricky]

VirusMaker schrieb:

vielleicht kann ein mod verschieben oder was

wohin? einen trashcan gibts hier nicht. und im C++ forum werden sie über dich herfallen, weil du printf/scanf statt cout/cin nimmst. *fg*
wofür brauchst du das eigentlich? hausaufgabe oder nur so zum spass? wenn ersteres, dann poste doch mal den text der aufgabe. deinen vielen widersprüchlichen beschreibungen nach glaube ich nämlich, dass du sie immer noch nicht verstanden hast.

[VirusMaker]

;fricky schrieb:

VirusMaker schrieb:

vielleicht kann ein mod verschieben oder was

wohin? einen trashcan gibts hier nicht. und im C++ forum werden sie über dich herfallen, weil du printf/scanf statt cout/cin nimmst. *fg*
wofür brauchst du das eigentlich? hausaufgabe oder nur so zum spass? wenn ersteres, dann poste doch mal den text der aufgabe. deinen vielen widersprüchlichen beschreibungen nach glaube ich nämlich, dass du sie immer noch nicht verstanden hast.

die erweiterung mach ich nur, um mich weiterzubilden!

leider gehts so auch nicht, wie ich vorher geschrieben hat
ich bin im moment voll verzweifelt!
wie soll ich dass machen?

also wenn er 5 stellen hat, müsst er doch zuerst die ersten 5 permutieren, dann 6, dann 7 usw, damit er auch alles, wirklich alles permutiert hat

bitte helft mir

MFG

EDIT:

char schwS[26];
    printf("Anzahl: ");
    scanf("%d",&sA);
    int i=sA;

    char schw[26];
    strcpy(schw,"ABCDEFGHIKLMNOPQRSTUVWXYZ");

    do
    {
        do
	    {
            strcpy(schwS,schw);
            schwS[sA]=0;
            printf("%s\n",schw);   
	    }
        while(std::next_permutation(schw,schw+sA));

//HIER FEHT WAS!?!

    } while(schw[0]!='Z'); //es sollte bei 5 mit ZYXWV aufhöhren
}

soweit hab ichs schonmal

[Big Brother]

;fricky schrieb:

wofür brauchst du das eigentlich?

Das sieht nach einem Passwort Brutforce Programm aus, um das System zu hacken und einen schwulen Virus einzuschleusen.

[;fricky]

VirusMaker schrieb:

die erweiterung mach ich nur, um mich weiterzubilden!

das ist gut und lobenswert, dann haste ja auch keinen stress, irgendwas fertiges abgeben zu müssen.

VirusMaker schrieb:

also wenn er 5 stellen hat, müsst er doch zuerst die ersten 5 permutieren, dann 6, dann 7 usw, damit er auch alles, wirklich alles permutiert hat.

mal was zum begriff permutation: bei permutationen gibts eigentlich keine reihenfolge. es bedeutet nur vertauschen der elemente von durchnumerierten dingen. z.b. abcd wird zu bdca, das ist dann *eine* permutation. willst du irgendwie sowas wie 'alle permutationen einer menge ohne wiederholung', also sowas wie nwp2's python-code und volkards std_nextPermutation(), oder willst du alle möglichen kombinationen der buchstaben a bis z, auf n stellen begrenzt, ohne dass im resultset elemente mehrfach auftauchen (was mein code hoffenlich macht)?

volkard featuring nwp2 für 3 elemente (vollständig):

abc
acb
bac
bca
cab
cba

mein beispiel (3-stellige ausgabe, a...z):

abc
abd
abe
abf
abg
abh
abi
abj
abk
abl
abm
abn
abo
abp
abq
abr
abs
abt
abu
abv
abw
abx
aby
abz
acb
acd
ace
acf
acg
ach
... usw...

ach ja, und für welche programmiersprache soll es sein? wie gesacht, nextPermutation() hat C nicht, müssteste dir selber bauen oder so.

[VirusMaker]

c oder c++ solls sein, lernen wir halt gerade!

und deins würde schon passen, jop!

und mit der permutation:
wenn 5, dann:
abcde-edcba
das ist das letzte ergebnis wenn man die permutieren lässt!

um jetzt die anden buchstaben des alphabets auch noch dazunehmen will, müsste man doch a-f als nächstes permutieren lassen...
iwie pack ichs aber nicht

[;fricky]

Big Brother schrieb:

Das sieht nach einem Passwort Brutforce Programm aus, um das System zu hacken und einen schwulen Virus einzuschleusen.

ok, aber dafür sind ja wiederholungen der zeichen in den wörtern nötig. dann wären wir ja doch wieder beim mod(irgendwas) -counter.

[VirusMaker]

;fricky schrieb:

Big Brother schrieb:

Das sieht nach einem Passwort Brutforce Programm aus, um das System zu hacken und einen schwulen Virus einzuschleusen.

ok, aber dafür sind ja wiederholungen der zeichen in den wörtern nötig. dann wären wir ja doch wieder beim mod(irgendwas) -counter.

ja, iwie will ich einfach eine liste machen, und verstehen, wie sowas gehen soll, hat nix mit hacken oder was weiß ich!

[;fricky]

VirusMaker schrieb:

und deins würde schon passen, jop!

dann nimm das doch, aber denk daran, erstmal wortlisten zu benutzen. eine reine brute-force attacke kann verdammt lange dauern *fg*

[;fricky]

VirusMaker schrieb:

ja, iwie will ich einfach eine liste machen, und verstehen, wie sowas gehen soll, hat nix mit hacken oder was weiß ich!

ob du hacken/cracken/sonstwas willst oder nicht, ist mir ziemlich wumpe (bin selbst extremer raubkopierer und file-sharer etc.). am besten, du postest hier mal eine folge von mindestens 50 strings hin, die so ein programm erzeugen soll, damit wir überhaupt wissen, was du möchtest. *fg* aus deinen erklärungen werde ich jedenfalls nicht schlau.

[VirusMaker]

;fricky schrieb:

VirusMaker schrieb:

ja, iwie will ich einfach eine liste machen, und verstehen, wie sowas gehen soll, hat nix mit hacken oder was weiß ich!

ob du hacken/cracken/sonstwas willst oder nicht, ist mir ziemlich wumpe (bin selbst extremer raubkopierer und file-sharer etc.). am besten, du postest hier mal eine folge von mindestens 50 strings hin, die so ein programm erzeugen soll, damit wir überhaupt wissen, was du möchtest. *fg* aus deinen erklärungen werde ich jedenfalls nicht schlau.

ich hab einen string:
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

bei 3 stellen soll er aus dem string ALLE kombis machen:

abc
abd
abe
abf
abg
abh
abi
abj
abk
abl
abm
abn
abo
abp
abq
abr
abs
abt
abu
abv
abw
abx
aby
abz
acb
acd
ace
acf
acg
ach
bishin zu:
zab
zac
zad
...
zxy
usw!

er sollte aber alle aus dem char[] string machen, damit ich die danach auch ändern kann!

also z.b. beim String "WAT":
1 Stelle:
W
A
T
2 Stellen
WA WT AW AT TW TA
und bei 3:
WAT WTA AWT ATW TAW TWA

also alle kombis, so das aber 2 chars nicht gleichzeitig sein können! also nicht WAA orso!

ich hoffe das ist jetzt klar

[;fricky]

VirusMaker schrieb:

ich hoffe das ist jetzt klar

ok, ich versuche es nochmal:

#include <stdio.h>

char source[] = "WAT"; // <--- dein string dessen, permutationen ausgegeben werden sollen
#define N (sizeof(source)-1)
#define LIMIT N  // <--- anpassen, 1...N

int use[N];
int res[N];

void mix (int i)
{ 
   int k;
   // ausgabe
   if (i >= LIMIT) 
   {
      for (k=0; k<LIMIT; k++) 
         putchar (source[res[k]]);
      puts("");
      return;
   }
   // neu mischen
   for (k=0; k<N; k++)
   { 
      if (use[k] == 0)
      { 
         use[k] = 1; 
         res[i] = k;
         mix (i+1);
         use[k] = 0;
      }
   }
}

int main()
{ 
   mix(0);
}

^^schau oben, LIMIT steht auf N, setze es auf (N-1) und es gibt dir

WA
WT
AW
AT
TW
TA

aus. ist nur 'ne leichte modifikation meines vorschlags von vorhin, die 'fricky-extension' bewährt sich scheinbar. *fg*