#include
#include
#include
#include
unsigned long long int arrayZuZahl(int, int, char[]);
char * zahlZuArray(int, int, char[]);
int kontrolle(char*, int, int);
char * zahlZuArray(int m, int d, char zahl[]) {
int i = 0;
int hilfe=0;
char arr[m];
for(i=0; i<=m; i++) {
if(i<=d) {
arr[i]='0';
}
else {
arr[i]=zahl[hilfe];
hilfe++;
}
}
strcpy(zahl, arr);
return zahl;
}
int kontrolle(char *x, int m, int n) {
//Überprüfen wie oft jede Ziffer in der aktuellen Zahl vorkommt
int null0=0, eins=0, zwei=0, drei=0, vier=0, fuenf=0, sechs=0, sieben=0, acht=0, neun=0;
int ergebnis=1;
int i=0;
for(i=0; i<=m; i++) {
switch(*(x+i)) { {
case '0':
null0++;
break;
case '1':
eins++;
break;
case '2':
zwei++;
break;
case '3':
drei++;
break;
case '4':
vier++;
break;
case '5':
fuenf++;
break;
case '6':
sechs++;
break;
case '7':
sieben++;
break;
case '8':
acht++;
break;
case '9':
neun++;
break;
}
}
//Überprüfen ob die aktuelle Zahl dem Parameter n entspricht
if(null0 > n|| eins > n || zwei > n || drei > n || vier > n || fuenf > n || sechs > n || sieben > n || acht > n || neun > n) {
ergebnis=0;
} }
return ergebnis;
}
unsigned long long int arrayZuZahl(int help, int m, char nullzahlfunkt[]) {
int o = 0;
unsigned long long int temp = 0;
for(o = 0; o <= m; o++) {
temp += (unsigned long long int) nullzahlfunkt[help]*(unsigned long long int) pow(10, (double) o);
help--;
}
return temp;
}
int main()
{
int d; //Beinhaltet die Menge der Nullen, welche vorangestellt werden müssen, um n zu erfüllen
int i; //Schleifenvariable
int m = 1; //Länge der generierten Zahl, maximal 19, Bei Veränderung Wunschlänge-1, da das Array bei [0] beginnt
int a = 0; //Wird benötigt um nullzahlarr[] und endzahlarr[] zu erzeugen
int zahl = 0; //Wird zur Erzeugung von nullzahlarr[] und endzahlarr[] benötigt
int n = 1; //Häufigkeit, mit der eine einzelne Ziffer vorkommen darf (Ziffer = 0 - 9)
unsigned long long int druckerzahl, startzahl, endzahl, differenz, e; //Variablen, die zu hochzählen der aktuellen Zahl und Ausgabe dieser genutzt werden (druckerzahl => Ausgabe)
char *p; //Pointer, mit dem die aktuelle druckerzahl als Array zu finden ist
int legal; //Beinhaltet 0 oder 1 aus der "kontrolle"-Funktion, erlaubt die Ausgabe der Zahl, wenn sie n entspricht
char datei[50]; //Array, das den Pfad zur Datei beinhaltet
int stream; //Wird benötigt, um die Datei zu schreiben (siehe Z. 160)
printf("Bitte die Anzahl der Stellen des Keys angeben (maximal 18): ");
scanf("%d", &m);
if(m > 18 || m < 1) {
printf("Die Zahl muss zwischen 1 und 18 liegen!\n");
return 0;
}
m = m-1;
printf("\nBitte die Häufigkeit angeben, mit der eine Ziffer (Zahl von 0 bis 9) vorkommen darf: ");
scanf("%d", &n);
if(n < 1 || (n*10) printf("Die Zahl muss mindestens 1 sein und groß genug, damit der Key auch gefüllt werden kann ((zahl*10)>=Stellen)!\n");
return 0;
}
printf("\nBitte das Verzeichnis und Dateinamen angeben, in dem die generierten Keys angelegt werden sollen (Format: /pfad/zur/datei.endung): ");
scanf("%s", &datei);
char nullzahlarr[m]; //Array, dass die Niedrigste mit den gegebenen Parametern (m, n) mögliche Zahl beinhaltet
char momentanZahl[m]; //Array, dass beim Hochzählen die aktuelle Zahl (druckerzahl) als Array beinhaltet und auf die Einhaltung von n überprüft wird
char endzahlarr[m]; // Array, dass die Höhste mit den gegebenen Parametern (m, n) mögliche Zahl beinhaltet
//Mit dieser for-Schleife wird die niedrigste mögliche Zahlenkombination erzeugt, welche m Stellen hat und n erfüllt
for(i = 0; i <= m; i++) {
nullzahlarr[i] = zahl;
a++;
if(a==n) {
zahl++;
a=0;
}
}
//Umdefinition von zahl und zurücksetzen von a um die höchstmögliche Zahl zu erzeugen, welche m und n entspricht
zahl=9;
a=0;
for(i=0; i<=m; i++) {
endzahlarr[i] = zahl;
a++;
if(a==n) {
zahl--;
a=0;
}
}
//Umwandlung des Arrays nullzahllarr[] zu einem 'unsigned long long int', der später zum Hochzählen benötigt wird
startzahl = arrayZuZahl(m, m, nullzahlarr);
//Umwandlung des Arrays endzahl[] zu einem 'unsigned long long int', der die Maximalgrenze der Generierung der Keys bildet
endzahl = arrayZuZahl(m, m, endzahlarr);
//Differenz der beiden Zahlen zur Regulierung, wie oft die 'Generierungs-for-Schleife' durchlaufen muss
differenz = endzahl-startzahl;
printf("%llu\n", startzahl);
printf("%llu\n", endzahl);
druckerzahl = startzahl;
stream = open(datei, O_WRONLY|O_CREAT|O_APPEND);
//'Generierungs-for-Schleife', generiert den aktuellen Key, und gibt ihn aus
for(e=0; e<=differenz; e++){
//Überprüfen, wie viele Ziffern druckerzahl enthält um die Menge an Nullen, welche vorangestellt werden müssen zu generieren
d = (druckerzahl == 0 ? 1 : (int)(log10(druckerzahl)+1));
d = m-d;
//Schreiben der druckerzahl in ein Array, welches
sprintf(momentanZahl, "%llu", druckerzahl);
//Schreiben der momentanzahl in einen int-Pointer
p = zahlZuArray(m, d, momentanZahl);
//Überprüfung, ob die Zahl ausgegeben werden darf, also n erfüllt
legal = kontrolle(p, m, n);
if(legal==1){
if(d>=0) {
//Auffüllen der ersten Stellen mit Nullen
for(i=0; i<=d; i++){
// printf("0");
}
}
//Möchte man die Zahlen sehen, welche grad geschrieben werden kann man die nächsten 2 Zeilen nutzen, dies verlangsamt das Programm jedoch enorm!
// printf("%llu", druckerzahl);
// printf("\n");
if(write(stream, momentanZahl, (sizeof(momentanZahl)+1)) == -1 || write(stream, "\r\n", 2) == -1) {
printf("Fehler beim Schreiben in die Datei\n");
return 0;
}
}
druckerzahl++;
}
close(stream);
return 0;
}