Liste mit beliebig langen Stellen

[VirusMaker]

verdammt -.-

hab was falsch mit bekommen!
wir sollten sie mit buchstaben ausgeben, also aaa-zzz
ist da viel umzuschreiben?
und es sollte bis zu 10 Stellen gehen o.O

[Bashar]

Erinnert mich irgendwie an das Thema, das wir gerade hatten:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-256645.html

[volkard]

VirusMaker schrieb:

verdammt -.-

hab was falsch mit bekommen!
wir sollten sie mit buchstaben ausgeben, also aaa-zzz
ist da viel umzuschreiben?

Fast nichts.
for(char i='a';i<='z';++i)
läuft von a bis z.
Denn chars sind in C eigrntlich auch nur ints. Nur beim Ausgeben unterscheidet man, z.B. %c statt %d. Und in ARRays und sio brauchen sie weniger Speicher, was uns hier aber weit am, also nicht wirklich von Interesse ist.

Aber max 10 Stellen klingt wieder naxch Zählwerk irgendwie. Fragen über Fragen. Ein Teufelskreis.

[rüdiger]

@volkard
man kann's natürlich auch mit printf hacken.

#include <stdio.h>

unsigned exp10(unsigned p) {
  unsigned ret = 1;
  for(; p > 0; --p) {
    ret *= 10;
  }
  return ret;
}

int main() {
  unsigned stellen;
  fputs("Anzahl der Stellen: ", stdout);
  scanf("%ud", &stellen);
  for(unsigned zahl = 0; zahl < exp10(stellen); ++zahl) {
    printf("%0*u\n", stellen, zahl);
  }
}

edit: arg. war zu langsam. Hab zu lange nachgedacht ob es einen schlauen Weg für exp10 gibt

[VirusMaker]

nicht maximal, sondern mindestens 10 stellen solls können!
mehr sollte es aber auch können!

und es wär super, wenn das aktuelle wort dann so ist, das man es an ein unterprogramm übergeben kann, wenns möglich wäre

könnte mir da wer nen code posten?

das wär echt super!

[volkard]

VirusMaker schrieb:

nicht maximal, sondern mindestens 10 stellen solls können!
mehr sollte es aber auch können!

Ups, das sollte nwp2s Code ausschließen. Dann hänge ich wieder der rekursiven Vermutung an.

[volkard]

rüdiger schrieb:

edit: arg. war zu langsam. Hab zu lange nachgedacht ob es einen schlauen Weg für exp10 gibt

Das ist ja wie Blitzschach hier. :xmas1:

[hinweis]

VirusMaker schrieb:

nicht maximal, sondern mindestens 10 stellen solls können!

26^10 = 141.167.095.653.376

[nwp2]

#include <stdio.h>
unsigned long long int hoch26(int x){
	unsigned long long int r;
	for (r = 1; x>0; x--) r*=26;
	return r;
}

int main(){
	printf("%d\n", sizeof(unsigned long long int));
	int stellen;
	scanf("%d", &stellen);
	unsigned long long int grenze = hoch26(stellen);
	for (unsigned long long int i = 0; i<grenze; i++){
		for (int j = stellen-1; j>=0; j--)
			printf("%c", 'a'+(char)(i/hoch26(j)%26));
		printf("\n");
	}
	return 0;
}

Funktioniert bis 13 Stellen. Überprüfe vorher ob als erstes eine 8 ausgegeben wird. Wenn es eine 4 ist gehts so nicht, wenn es eine 16 ist probiere es mit einem long weniger.

Ist in vernünftiger Zeit aber eh nicht ausgebbar.

Wenn du unbegrenzt viele Stellen willst solltest du wirklich ein Zählwerk benutzen.

Edit: 2^64 > 26^13

[VirusMaker]

muss das so kompliziert sein?

ich dachte da eher an ein groß genuges Feld von chars, das mit AAA... initialisiert wird, und dann mit einer Anzahl-Variable abgeschnitten wird...

und dann bräuchte ich nur noch ein Zählwerk, damit ich das übergeben kann!

ginge das nicht so, und wenn ja, wie dann in c?

mfg

[nwp2]

#include <stdio.h>
#include <stdlib.h>
int main(){
	int stellen;
	scanf("%d", &stellen);
	char *zahl = (char*) malloc(stellen+1);
	for (int i = 0; i<stellen-1; i++) zahl[i] = 'a'; //zahl mit a's initialisieren
	zahl[stellen-1] = 'a'-1; //vorher anfangen weil zuerst hochgezählt wird
	zahl[stellen] = '\0'; //braucht man damit printf weiß wo schluss ist
	int position = 0; //aktuelle ziffer in zahl
	while (position>=0){ //Zählwerk zählt bis wir einen Überlauf über die letzte Stelle haben
		for (position = stellen-1; position>=0; position--){ //wir gehen Ziffernweise durch, erhöhen die Ziffer und kucken ob wir einen Überlauf haben
			if (zahl[position]=='z'){ //überlauf
				zahl[position] = 'a'; //ziffer resetten
				continue; //nächste ziffer erhöhen
			}
			else{ //kein überlauf
				zahl[position]++; //ziffer erhöhen
				printf("%s\n", zahl); //ziffer ausgeben
				break; //schleife abbrechen, keine weiteren ziffern müssen erhöht werden
			}
		}
	}
}

Klappt bis 2147483647 Stellen. Aber 2GB 26^2147483647 mal auf der Konsole ausgeben sollte man vielleicht lassen.

Man kann übrigens mal eine 1456 oder so eingeben, klappt

[volkard]

VirusMaker schrieb:

muss das so kompliziert sein?
...
ginge das nicht so, und wenn ja, wie dann in c?

Kannste das Zählwerk von 22:36 während des Wochenendes aufbohren, daß es auch Buchstaben kann?
Der Code geht aber nur, wenn Du GCC benutzt und nicht mit Microsoft. Bei MS müßtest Du den Speicher mit malloc anlegen.
Oh, nwp hat aufgerüstet.

[VirusMaker]

So, ich habs nun geschaft:

sA ist die Länge des Strings und schw ist der String mit A..Z initialisiert!

int done=0,done2=0;
	while(done==0)
	{
    	done2=0;

    	for(int m=sA-1;m>=0&&done2==0;m--)
    	{
        	if(schw[m]<'Z')
        	{
            	schw[m]=look(schw,schw[m]);
            	done2=1;
        	}  
        	else 
        	{
            	//schw[m]='A';
            	schw[m]=look(schw,'A'-1);
        	}
    	}
    	if(schw[0]=='Z') done=1;
	}
	of.close();
}

char look(char schw[26],int m)
{
	register char a=m-1;
	int gef;

	do
	{
    	gef=0;
    	a++;
        	for(register int y=sA-1;y>=0;y--)
            	if(schw[y]==a)
            	{
                	gef=1;
            	}
	}
	while(gef==1);

	return a;
}

einzige problem, das er wenn man 5 annimmt, er ABCDE ausgibt, wie gewünscht, aber dass er 2 buchstaben nie wechselt! also nach A an erster Stelle kommt immer E und nicht B

Was ist falsch?

mfg

[nwp2]

Meins magste nich? Hmm. Ich seh nicht durch bei deinem Code, ein paar mehr Kommentare was wo warum passiert wären günstig. Vor allem, was tut denn look?

[;fricky]

oder sowas:

#include <stdio.h>

#define LENGTH 100 // laenge des 'strings'
#define LIMIT 35  // zeichensatzlaenge-1

char mem[LENGTH];  // speicher
char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";  // zeichensatz

void count (char *p)
{
   if (p < mem)
      return;
   (*p)++;
   if (*p > LIMIT)
   {    
      *p = 0;
      count (p-1);
   }
}

int main()
{
   char *p;
   for (;;)
   {
      // ausgeben
      p = mem;
      while (p < mem+LENGTH)
          putchar (digits[*p++]);
      puts ("");

      // zaehlen
      count (mem+LENGTH-1);
   }
}

^^ ohne malloc, beliebige länge und zeichensatz frei definierbar *fg*

[volkard]

laß den benutzer schon die stellenzahl eingeben.

[;fricky]

volkard schrieb:

laß den benutzer schon die stellenzahl eingeben.

kann er doch, er brauch nur 'nen c-compiler *fg*
ne, ist ja nur 'ne demo, kann man natürlich leicht umbauen, dass der user die stellenzahl eingeben darf.

[volkard]

;fricky schrieb:

volkard schrieb:

laß den benutzer schon die stellenzahl eingeben.

kann er doch, er brauch nur 'nen c-compiler *fg*
ne, ist ja nur 'ne demo, kann man natürlich leicht umbauen, dass der user die stellenzahl eingeben darf.

mach das doch mal kurz.

[;fricky]

ok, mal eine interaktive version:

#include <stdio.h>

#define LIMIT 35  // zeichensatzlaenge-1

int length; // vom benutzer gewaehlt
char mem[4096];  // speicher
char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";  // zeichensatz
int done; // abbruchflag 

void count (char *p)
{
   if (p < mem)
   {
      done = 1;
      return;
   }
   (*p)++;
   if (*p > LIMIT)
   {    
      *p = 0;
      count (p-1);
   }
}

int main()
{
   retry:
   printf ("wie lang? ");
   scanf ("%d", &length);
   if (length > sizeof (mem))
   {
      printf ("nicht laenger als %d\n", sizeof(mem));
      goto retry;
   }

   while (!done)
   {
      // ausgeben
      char *p = mem;
      while (p < mem+length)
          putchar (digits[*p++]);
      puts ("");

      // zaehlen
      count (mem+length-1);
   }
}

^^ wenn schon benutzerfreundloch, dann sollte man den user auch noch den zeichensatz eingeben lassen.

[nwp2]

Dein Code gefällt mir garnicht.

char mem[4096];  // speicher

Sowas macht man nicht. Niemals.

if (length > sizeof (mem)){
    printf ("nicht laenger als %d\n", sizeof(mem));
    goto retry;
}

Das hatte ich in dem anderen Thread angesprochen. "Fehler: Programmierer ist zu blöd nen ordentliches Programm zu schreiben". Vom goto ganz zu schweigen.

3 #define LIMIT 35  // zeichensatzlaenge-1
7 char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";  // zeichensatz

Böööööööse.

char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";  // zeichensatz
int limit = sizeof(digits)-1;

So gehört sich das.

Ich frage mich echt ob du jemals mehr als 1000 Zeilen Code geschrieben hast. Das ist in etwa die Grenze wo solcher Code unkontrollierbar wird. Das ist einfach zusammengehackt und erfüllt die Aufgabe nur manchmal, aber man braucht ewig bis man es merkt.

Dein Kommentar den Nutzer das Alphabet eingeben zu lassen war gut. Und nun?

char alphabet[142];
scanf("%s", &alphabet);

Schon mit miserablem Code angefangen, da kann man auch gleich so weitermachen.
Oder noch besser:

#define MAXALPHABET 142
char alphabet[MAXALPHABET];
retry2:
if (scanf("%*s", MAXALPHABET-1, &alphabet)==MAXALPHABET-1){
    fprintf(stderr, "Fehler, eingegebenes Alphabet ist länger als der Programmierer dachte, versuchen Sie's doch nochmal";
    goto retry2;
}

Wobei ich sagen muss dass das neu versuchen schon Luxus ist, man kann nämlich endlos neu versuchen, es stürzt nicht nach dem 137. mal ab weil der Programmierer dachte es versucht eh niemand mehr als 137 mal. Das muss man noch irgendwie begrenzen, das geht so nicht.

Ich bleibe dabei, buffer[wirdschonreichen] ist eine ganz schlechte Idee.