Моя первая попытка создать список слов,
Я пытаюсь создать список слов, который содержит все комбинации букв (прописные и строчные) и некоторые символы. В основном большая часть таблицы ASCII.
Меня просто интересовало, сколько памяти займет текстовый файл. Я думаю, что я буду использовать некоторые другие функции, чтобы удалить ненужные слова. Но сейчас я молюсь, чтобы мой жесткий диск объемом 1 ТБ не взорвался. Я не знаю, является ли этот метод правильным методом, использующим вложенные циклы for с подписанным массивом, возможно, я должен использовать связанный список для лучшей производительности. Тем временем я могу создавать функции, которые удаляют строки с большим количеством символов, чем некоторые.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define PATH "wordlist.txt"
#define SIZE 68
void Write(char * word[], FILE * f, int N)
{
for(int i = 0; i <= N; i++)
{
fprintf(f,"%s", word[i]);
}
fprintf(f,"\n");
}
void thirteen_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
for(int q = 0; q < SIZE; q++)
{
word[8] = letters[q];
for(int r = 0; r < SIZE; r++)
{
word[9] = letters[r];
for(int s = 0; s < SIZE;s++)
{
word[10] = letters[s];
for(int t = 0; t < SIZE; t++)
{
word[11] = letters[t];
for(int u = 0; u < SIZE; u++)
{
word[12] = letters[u];
Write(word, f, 12);
}
}
}
}
}
}
}
}
}
}
}
}
}
fclose(f);
}
void twelve_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
for(int q = 0; q < SIZE; q++)
{
word[8] = letters[q];
for(int r = 0; r < SIZE; r++)
{
word[9] = letters[r];
for(int s = 0; s < SIZE;s++)
{
word[10] = letters[s];
for(int t = 0; t < SIZE; t++)
{
word[11] = letters[t];
Write(word, f,11);
}
}
}
}
}
}
}
}
}
}
}
}
}
void eleven_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
for(int q = 0; q < SIZE; q++)
{
word[8] = letters[q];
for(int r = 0; r < SIZE; r++)
{
word[9] = letters[r];
for(int s = 0; s < SIZE;s++)
{
word[10] = letters[s];
Write(word, f,10);
}
}
}
}
}
}
}
}
}
}
}
}
void ten_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
for(int q = 0; q < SIZE; q++)
{
word[8] = letters[q];
for(int r = 0; r < SIZE; r++)
{
word[9] = letters[r];
Write(word, f,9);
}
}
}
}
}
}
}
}
}
}
}
void nine_Digits(char * word[], char * letters[] ,FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
for(int q = 0; q < SIZE; q++)
{
word[8] = letters[q];
Write(word, f, 8);
}
}
}
}
}
}
}
}
}
}
void eight_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
for(int p = 0; p < SIZE; p++)
{
word[7] = letters[p];
Write(word, f, 7);
}
}
}
}
}
}
}
}
}
void seven_Digits(char * word[], char * letters[] ,FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
for(int o = 0; o < SIZE; o++)
{
word[6] = letters[o];
Write(word, f, 6);
}
}
}
}
}
}
}
}
void six_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
for(int n = 0; n < SIZE; n++)
{
word[5] = letters[n];
Write(word, f, 5);
}
}
}
}
}
}
}
void five_Digits(char * word[],char * letters[] , FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
for(int m = 0; m< SIZE; m++)
{
word[4] = letters[m];
Write(word, f, 4);
}
}
}
}
}
}
void four_Digits(char * word[], char * letters[] ,FILE * f)
{
for(int i = 0; i < SIZE; i++)
{
word[0] = letters[i];
for(int j = 0; j < SIZE ;j++)
{
word[1] = letters[j];
for(int k = 0; k < SIZE; k++)
{
word[2] = letters[k];
for(int l = 0; l < SIZE;l++)
{
word[3] = letters[l];
Write(word, f, 3);
}
}
}
}
}
int main()
{
FILE *f;
if(!(f=fopen(PATH, "a")))
{
perror("Errore");
exit(-1);
}
char * letters[SIZE] = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z",
"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z",
".","_","1","2","3","4","5","6","7","8","9","0","!","@","$","§"};
char * word13[] = {"A","A","A","A","A","A","A","A","A","A","A","A","A"};
char * word12[] = {"A","A","A","A","A","A","A","A","A","A","A","A"};
char * word11[] = {"A","A","A","A","A","A","A","A","A","A","A"};
char * word10[] = {"A","A","A","A","A","A","A","A","A","A"};
char * word9[] = {"A","A","A","A","A","A","A","A","A"};
char * word8[] = {"A","A","A","A","A","A","A","A"};
char * word7[] = {"A","A","A","A","A","A","A"};
char * word6[] = {"A","A","A","A","A","A"};
char * word5[] = {"A","A","A","A","A"};
char * word4[] = {"A","A","A","A"};
four_Digits(word4,letters, f);
five_Digits(word5,letters, f);
six_Digits(word6,letters, f);
seven_Digits(word7,letters, f);
eight_Digits(word8,letters, f);
nine_Digits(word9,letters, f);
ten_Digits(word10, letters,f);
eleven_Digits(word11,letters, f);
twelve_Digits(word12, letters,f);
thirteen_Digits(word13,letters, f);
exit(EXIT_SUCCESS);
}
Я буду признателен за любую помощь для ускорения алгоритма.
1 ответ
Эта программа не закончится за всю вашу жизнь - и она заполнит ваш жесткий диск задолго до этого.
Существует 6813 = 6 × 1023 возможных комбинаций из тринадцати символов, выбранных из набора из 68 символов. Для каждого из 14 байтов (13 символов + одна новая строка) их хранение в файле займет примерно 9,3 × 1024 байта или 9,3 триллиона терабайт. Это на несколько порядков больше, чем объем хранимых данных на планете.
Вам нужно пересмотреть то, что вы пытаетесь сделать здесь. Это явно не сработает.
С точки зрения реализации, однако, есть более простой способ приблизиться к этому, чем использование вложенных циклов:
void permute(int length, int maximum_digit)
{
int *digits = calloc(length, sizeof(int));
do {
print_digits(digits, length);
} while (increment(digits, length, maximum_digit));
free(digits);
}
Эта функция создает массив с переменным количеством цифр (устанавливается length) и "увеличивает" этот массив на каждом шаге, пока он не достигнет максимального значения (maximum_digit).
Мы можем реализовать это увеличение, пройдя через массив; для каждой цифры мы увеличиваем ее и останавливаем, если она меньше максимального значения, или обнуляем ее и продолжаем в противном случае:
int increment(int *digits, int length, int maximum_digit)
{
for (int i = 0; i < length; i++) {
if (digits[i] + 1 == maximum_digit) {
digits[i] = 0;
} else {
digits[i]++;
return 1;
}
}
return 0;
}
Реализация print_digits() оставлено для читателя.