Auflistung aller Groß-Kleinschreibungsmöglichkeiten eines Strings

crispin kenton

ich bring auch mal ein pferd ins rennen sollte knapp auf dem 2. platz landen

void bit_combos2(char *str){
	size_t len = strlen(str);
    size_t *pos = malloc(sizeof(size_t)*len);
    if(pos){
        size_t ll = 0;

        len = 0;

        char *s = str;
        for(;*s;s++){
            *s = tolower(*s);
            if(islower(*s)){
				ll <<= 1;
				ll |= 1;
                pos[len++] = s - str;
            }
        }

		size_t l;
		ll >>= 3;
		puts(str);
		for(;ll--;){
			for(l = 0;(str[pos[l]] & 32) == 0;l++){
				str[pos[l]] = str[pos[l]] ^ 32;
			};
			str[pos[l]] ^= 32;

#define toggle(x) str[pos[len - 1 - x]]  ^= 32
			puts(str); toggle(0);                       // 000
			puts(str); toggle(0); toggle(1);            // 001
			puts(str); toggle(0);                       // 010
			puts(str); toggle(0); toggle(1); toggle(2); // 011
			puts(str); toggle(0);                       // 100
			puts(str); toggle(0); toggle(1);            // 101
			puts(str); toggle(0);                       // 110
			puts(str); toggle(0); toggle(1); toggle(2); // 111
#undef toggle
		}

        free(pos);
    }
}

@edit: so kommt das mäuschen fast sogar auf die 1

crispin kenton

EOP schrieb:

SeppJ schrieb:

Meine Methode ist sicherlich etwas einfacher zu verstehen und die Rekursionsmethode hat eben ihre eigene Eleganz (auch wenn ich persönlich kein Fan von Rekursion bin^*).

Mit 13 effektiver Zeilen code (flip kann man als 14. hinzufugen) spiele ich wohl ganz oben mit.

void bit_combos3(char *str){
	size_t len = 0,ll = -1,l=strlen(str),*pos;
    if(l && (pos = malloc(sizeof(size_t) * l))){
		char *s = str;
		for(;*s;s++){
            if(isupper((*s = toupper(*s)))){
                pos[len++] = s - str;
            }
        }
		for(ll = ~(ll<<len) + 1;ll--;){
			puts(str);
			for(l = len;l-- && ((str[pos[l]] ^= 32) & 32) == 0;);
		}
		free(pos);
	}
}

verdammt, schon wieder verloren