API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 21st, 2017
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 100.74 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <cstdlib>
  3. #include <cstring>
  4. #include <cstdio>
  5. #include <ctime>
  6. #include <cmalloc>
  7.  
  8.  
  9. using namespace std;
  10.  
  11. const char *szNumeroUnderline[] =
  12. {
  13.     "_00",  "_01",  "_02",  "_03",  "_04",  "_05",  "_06",  "_07",  "_08",  "_09",
  14.     "_10",  "_11",  "_12",  "_13",  "_14",  "_15",  "_16",  "_17",  "_18",  "_19",
  15.     "_20",  "_21",  "_22",  "_23",  "_24",  "_25",  "_26",  "_27",  "_28",  "_29",
  16.     "_30",  "_31",  "_32",  "_33",  "_34",  "_35",  "_36",  "_37",  "_38",  "_39",
  17.     "_40",  "_41",  "_42",  "_43",  "_44",  "_45",  "_46",  "_47",  "_48",  "_49",
  18.     "_50",  "_51",  "_52",  "_53",  "_54",  "_55",  "_56",  "_57",  "_58",  "_59",
  19.     "_60",  "_61",  "_62",  "_63",  "_64",  "_65",  "_66",  "_67",  "_68",  "_69",
  20.     "_70",  "_71",  "_72",  "_73",  "_74",  "_75",  "_76",  "_77",  "_78",  "_79",
  21.     "_80",  "_81",  "_82",  "_83",  "_84",  "_85",  "_86",  "_87",  "_88",  "_89",
  22.     "_90",  "_91",  "_92",  "_93",  "_94",  "_95",  "_96",  "_97",  "_98",  "_99"
  23. };
  24.  
  25. const char *szNumeroCSV[] =
  26. {
  27.     ";00",  ";01",  ";02",  ";03",  ";04",  ";05",  ";06",  ";07",  ";08",  ";09",
  28.     ";10",  ";11",  ";12",  ";13",  ";14",  ";15",  ";16",  ";17",  ";18",  ";19",
  29.     ";20",  ";21",  ";22",  ";23",  ";24",  ";25",  ";26",  ";27",  ";28",  ";29",
  30.     ";30",  ";31",  ";32",  ";33",  ";34",  ";35",  ";36",  ";37",  ";38",  ";39",
  31.     ";40",  ";41",  ";42",  ";43",  ";44",  ";45",  ";46",  ";47",  ";48",  ";49",
  32.     ";50",  ";51",  ";52",  ";53",  ";54",  ";55",  ";56",  ";57",  ";58",  ";59",
  33.     ";60",  ";61",  ";62",  ";63",  ";64",  ";65",  ";66",  ";67",  ";68",  ";69",
  34.     ";70",  ";71",  ";72",  ";73",  ";74",  ";75",  ";76",  ";77",  ";78",  ";79",
  35.     ";80",  ";81",  ";82",  ";83",  ";84",  ";85",  ";86",  ";87",  ";88",  ";89",
  36.     ";90",  ";91",  ";92",  ";93",  ";94",  ";95",  ";96",  ";97",  ";98",  ";99"
  37. };
  38.  
  39. int GerarQuina5Numeros()
  40. {
  41. //    char szTemp[4096];
  42.  
  43.  
  44.     int iContadorArquivo = 0;
  45.     int iContadorLinha = 0;
  46.  
  47.  
  48.     time_t tempoInicial, tempoFinal;
  49.     tempoInicial = time(&tempoInicial);
  50.  
  51.     // Vamos calcular cada linha, cada linha está neste formato:
  52.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  53.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  54.     int iQuantidade = strlen("QUINA;5;_01_02_03_04_05;01;02;03;04;05") + 1;
  55.  
  56.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  57.     // iremos alocar primeiramente este espaço.
  58.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  59.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  60.  
  61.     // Agora, iremos, alocar um ponteiro para ponteiro.
  62.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  63.  
  64. //    char *ptTeste = szLinhas[0];
  65.  
  66.     // Agora, vamos apontar cada ponteiro.
  67.     for(int iA = 0; iA < 1000000; iA++)
  68.     {
  69.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  70.     }
  71.  
  72.     for(int uA = 1; uA <= 80; uA++)
  73.         for(int uB = uA+1; uB <= 80; uB++)
  74.             for(int uC = uB + 1; uC <= 80; uC++)
  75.                 for(int uD = uC + 1; uD <= 80; uD++)
  76.                     for(int uE = uD + 1; uE <= 80; uE++)
  77.                         //for(int uF = uE + 1; uF <= 80; uF++)
  78.                         //for(int uG = uF + 1; uG <= 80; uG++)
  79.                     {
  80.                         char *pt = &szLinhas[iContadorLinha][0];
  81. //                        char *ptUm = &szLinhas[iContadorLinha][0];
  82.  
  83.                         // Devemos definir o primeiro caractere nulo.
  84.                         // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  85.                         // o arranjo várias vezes.
  86.                         *pt = '\0';
  87.  
  88.                         strcat(pt, "QUINA;5;");
  89.                         strncat(pt, szNumeroUnderline[uA], 3);
  90.                         strncat(pt, szNumeroUnderline[uB], 3);
  91.                         strncat(pt, szNumeroUnderline[uC], 3);
  92.                         strncat(pt, szNumeroUnderline[uD], 3);
  93.                         strncat(pt, szNumeroUnderline[uE], 3);
  94.                         //strncat(pt, szNumeroUnderline[uF], 3);
  95.                         //strncat(pt, szNumeroUnderline[uG], 3);
  96.  
  97.                         strncat(pt, szNumeroCSV[uA], 3);
  98.                         strncat(pt, szNumeroCSV[uB], 3);
  99.                         strncat(pt, szNumeroCSV[uC], 3);
  100.                         strncat(pt, szNumeroCSV[uD], 3);
  101.                         strncat(pt, szNumeroCSV[uE], 3);
  102.                         //strncat(pt, szNumeroCSV[uF], 3);
  103.                         //strncat(pt, szNumeroCSV[uG], 3);
  104.  
  105.                         // Coloca o caractere '\n' ao invés do nulo. '\0'.
  106.                         // Pois ao salvar, devemos gravar o caractere nulo.
  107.                         pt = strchr(pt, '\0');
  108.                         *pt = '\n';
  109.  
  110.                         iContadorLinha++;
  111.  
  112.                         if(iContadorLinha==1000000)
  113.                         {
  114.                             iContadorLinha = 0;
  115.  
  116.                             char szTemp[20];
  117.                             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  118.  
  119.                             char szArquivo[1024];
  120.                             char *pt = szArquivo;
  121.                             *pt = '\0';
  122.                             strcat(pt, "/mnt/Gerador_de_Palavras/quina_5_numeros_arq_");
  123.                             pt = strchr(szArquivo, '\0');
  124.  
  125.                             iContadorArquivo++;
  126.                             sprintf(pt, "%.10d", iContadorArquivo);
  127.                             strcat(pt, "_inicio_");
  128.                             strcat(pt, szTemp);
  129.                             strcat(pt, "_fim_");
  130.  
  131.                             time(&tempoFinal);
  132.                             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  133.                             strcat(pt, szTemp);
  134.                             strcat(pt, ".txt");
  135.  
  136.  
  137.                             printf("Abrindo arquivo:\n%s\n", szArquivo);
  138.                             FILE * fArquivo = fopen(szArquivo, "w");
  139.                             if(!fArquivo)
  140.                             {
  141.                                 fprintf(stderr, "Erro ao abrir arquivo.\n");
  142.                                 perror("Erro foi: ");
  143.                                 return -1;
  144.                             }
  145.  
  146.                             printf("Gravando...\t");
  147.  
  148.                             for(int uLinha = 0; uLinha < 1000000; uLinha++)
  149.                                 fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  150.                             fclose(fArquivo);
  151.  
  152.                             printf("Gravado.\n\n");
  153.                         }
  154.  
  155.                         time(&tempoInicial);
  156.  
  157.                     }
  158.  
  159.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  160.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  161.     // que há linhas ainda não gravadas.
  162.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  163.     // iContadorLinha é sempre 1 a mais
  164.     if(iContadorLinha != 0)
  165.     {
  166.         char szTemp[20];
  167.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  168.  
  169.         char szArquivo[1024];
  170.         char *pt = szArquivo;
  171.         *pt = '\0';
  172.         strcat(pt, "/mnt/Gerador_de_Palavras/quina_5_numeros_arq_");
  173.         pt = strchr(szArquivo, '\0');
  174.  
  175.         iContadorArquivo++;
  176.         sprintf(pt, "%.10d", iContadorArquivo);
  177.         strcat(pt, "_inicio_");
  178.         strcat(pt, szTemp);
  179.         strcat(pt, "_fim_");
  180.  
  181.         time(&tempoFinal);
  182.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  183.         strcat(pt, szTemp);
  184.         strcat(pt, ".txt");
  185.  
  186.  
  187.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  188.         FILE * fArquivo = fopen(szArquivo, "w");
  189.         if(!fArquivo)
  190.         {
  191.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  192.             perror("Erro foi: ");
  193.             return -1;
  194.         }
  195.  
  196.         printf("Gravando...\t");
  197.  
  198.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  199.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  200.         fclose(fArquivo);
  201.  
  202.         printf("Gravado.\n\n");
  203.     }
  204.  
  205.     time(&tempoInicial);
  206.  
  207.     printf("Executado com sucesso!!!");
  208.  
  209.     return 0;
  210. }
  211.  
  212.  
  213.  
  214. int GerarDuplaSena7Numeros()
  215. {
  216. //    char szTemp[4096];
  217.  
  218.  
  219.     int iContadorArquivo = 0;
  220.     int iContadorLinha = 0;
  221.  
  222.  
  223.     time_t tempoInicial, tempoFinal;
  224.     tempoInicial = time(&tempoInicial);
  225.  
  226.     // Vamos calcular cada linha, cada linha está neste formato:
  227.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  228.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  229.     int iQuantidade = strlen("DUPLASENA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07") + 1;
  230.  
  231.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  232.     // iremos alocar primeiramente este espaço.
  233.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  234.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  235.  
  236.     // Agora, iremos, alocar um ponteiro para ponteiro.
  237.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  238.  
  239. //    char *ptTeste = szLinhas[0];
  240.  
  241.     // Agora, vamos apontar cada ponteiro.
  242.     for(int iA = 0; iA < 1000000; iA++)
  243.     {
  244.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  245.     }
  246.  
  247.  
  248.  
  249.  
  250.  
  251.     for(int uA = 1; uA <= 50; uA++)
  252.         for(int uB = uA+1; uB <= 50; uB++)
  253.             for(int uC = uB + 1; uC <= 50; uC++)
  254.                 for(int uD = uC + 1; uD <= 50; uD++)
  255.                     for(int uE = uD + 1; uE <= 50; uE++)
  256.                         for(int uF = uE + 1; uF <= 50; uF++)
  257.                             for(int uG = uF + 1; uG <= 50; uG++)
  258.                             {
  259.                                 char *pt = &szLinhas[iContadorLinha][0];
  260. //                                char *ptUm = &szLinhas[iContadorLinha][0];
  261.  
  262.                                 // Devemos definir o primeiro caractere nulo.
  263.                                 // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  264.                                 // o arranjo várias vezes.
  265.                                 *pt = '\0';
  266.  
  267.                                 strcat(pt, "DUPLASENA;7;");
  268.                                 strncat(pt, szNumeroUnderline[uA], 3);
  269.                                 strncat(pt, szNumeroUnderline[uB], 3);
  270.                                 strncat(pt, szNumeroUnderline[uC], 3);
  271.                                 strncat(pt, szNumeroUnderline[uD], 3);
  272.                                 strncat(pt, szNumeroUnderline[uE], 3);
  273.                                 strncat(pt, szNumeroUnderline[uF], 3);
  274.                                 strncat(pt, szNumeroUnderline[uG], 3);
  275.  
  276.                                 strncat(pt, szNumeroCSV[uA], 3);
  277.                                 strncat(pt, szNumeroCSV[uB], 3);
  278.                                 strncat(pt, szNumeroCSV[uC], 3);
  279.                                 strncat(pt, szNumeroCSV[uD], 3);
  280.                                 strncat(pt, szNumeroCSV[uE], 3);
  281.                                 strncat(pt, szNumeroCSV[uF], 3);
  282.                                 strncat(pt, szNumeroCSV[uG], 3);
  283.  
  284.                                 // Coloca o caractere '\n' ao invés do nulo. '\0'.
  285.                                 // Pois ao salvar, devemos gravar o caractere nulo.
  286.                                 pt = strchr(pt, '\0');
  287.                                 *pt = '\n';
  288.  
  289.                                 iContadorLinha++;
  290.  
  291.                                 if(iContadorLinha==1000000)
  292.                                 {
  293.                                     // É a última linha, retira o caractere '\n'.
  294.                                     *pt = '\0';
  295.  
  296.                                     iContadorLinha = 0;
  297.  
  298.                                     char szTemp[20];
  299.                                     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  300.  
  301.                                     char szArquivo[1024];
  302.                                     char *pt = szArquivo;
  303.                                     *pt = '\0';
  304.                                     strcat(pt, "/mnt/Gerador_de_Palavras/duplasena_7_numeros_arq_");
  305.                                     pt = strchr(szArquivo, '\0');
  306.  
  307.                                     iContadorArquivo++;
  308.                                     sprintf(pt, "%.10d", iContadorArquivo);
  309.                                     strcat(pt, "_inicio_");
  310.                                     strcat(pt, szTemp);
  311.                                     strcat(pt, "_fim_");
  312.  
  313.                                     time(&tempoFinal);
  314.                                     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  315.                                     strcat(pt, szTemp);
  316.                                     strcat(pt, ".txt");
  317.  
  318.  
  319.                                     printf("Abrindo arquivo:\n%s\n", szArquivo);
  320.                                     FILE * fArquivo = fopen(szArquivo, "w");
  321.                                     if(!fArquivo)
  322.                                     {
  323.                                         fprintf(stderr, "Erro ao abrir arquivo.\n");
  324.                                         perror("Erro foi: ");
  325.                                         return -1;
  326.                                     }
  327.  
  328.                                     printf("Gravando...\t");
  329.  
  330.                                     for(int uLinha = 0; uLinha < 1000000; uLinha++)
  331.                                         fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  332.                                     fclose(fArquivo);
  333.  
  334.                                     printf("Gravado.\n\n");
  335.                                 }
  336.  
  337.                                 time(&tempoInicial);
  338.  
  339.                             }
  340.  
  341.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  342.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  343.     // que há linhas ainda não gravadas.
  344.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  345.     // iContadorLinha é sempre 1 a mais
  346.     if(iContadorLinha != 0)
  347.     {
  348.         char szTemp[20];
  349.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  350.  
  351.         char szArquivo[1024];
  352.         char *pt = szArquivo;
  353.         *pt = '\0';
  354.         strcat(pt, "/mnt/Gerador_de_Palavras/duplasena_7_numeros_arq_");
  355.         pt = strchr(szArquivo, '\0');
  356.  
  357.         iContadorArquivo++;
  358.         sprintf(pt, "%.10d", iContadorArquivo);
  359.         strcat(pt, "_inicio_");
  360.         strcat(pt, szTemp);
  361.         strcat(pt, "_fim_");
  362.  
  363.         time(&tempoFinal);
  364.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  365.         strcat(pt, szTemp);
  366.         strcat(pt, ".txt");
  367.  
  368.  
  369.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  370.         FILE * fArquivo = fopen(szArquivo, "w");
  371.         if(!fArquivo)
  372.         {
  373.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  374.             perror("Erro foi: ");
  375.             return -1;
  376.         }
  377.  
  378.         printf("Gravando...\t");
  379.  
  380.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  381.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  382.         fclose(fArquivo);
  383.  
  384.         printf("Gravado.\n\n");
  385.     }
  386.  
  387.     time(&tempoInicial);
  388.  
  389.     printf("Executado com sucesso!!!");
  390.  
  391.     return 0;
  392. }
  393.  
  394.  
  395.  
  396. int GerarDuplaSena6Numeros()
  397. {
  398. //    char szTemp[4096];
  399.  
  400.  
  401.     int iContadorArquivo = 0;
  402.     int iContadorLinha = 0;
  403.  
  404.  
  405.     time_t tempoInicial, tempoFinal;
  406.     tempoInicial = time(&tempoInicial);
  407.  
  408.     // Vamos calcular cada linha, cada linha está neste formato:
  409.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  410.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  411.     int iQuantidade = strlen("DUPLASENA;6;_01_02_03_04_05_06;01;02;03;04;05;06") + 1;
  412.  
  413.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  414.     // iremos alocar primeiramente este espaço.
  415.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  416.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  417.  
  418.     // Agora, iremos, alocar um ponteiro para ponteiro.
  419.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  420.  
  421. //    char *ptTeste = szLinhas[0];
  422.  
  423.     // Agora, vamos apontar cada ponteiro.
  424.     for(int iA = 0; iA < 1000000; iA++)
  425.     {
  426.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  427.     }
  428.  
  429.  
  430.  
  431.  
  432.  
  433.     for(int uA = 1; uA <= 50; uA++)
  434.         for(int uB = uA+1; uB <= 50; uB++)
  435.             for(int uC = uB + 1; uC <= 50; uC++)
  436.                 for(int uD = uC + 1; uD <= 50; uD++)
  437.                     for(int uE = uD + 1; uE <= 50; uE++)
  438.                         for(int uF = uE + 1; uF <= 50; uF++)
  439.                             //for(int uG = uF + 1; uG <= 80; uG++)
  440.                         {
  441.                             char *pt = &szLinhas[iContadorLinha][0];
  442. //                            char *ptUm = &szLinhas[iContadorLinha][0];
  443.  
  444.                             // Devemos definir o primeiro caractere nulo.
  445.                             // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  446.                             // o arranjo várias vezes.
  447.                             *pt = '\0';
  448.  
  449.                             strcat(pt, "DUPLASENA;6;");
  450.                             strncat(pt, szNumeroUnderline[uA], 3);
  451.                             strncat(pt, szNumeroUnderline[uB], 3);
  452.                             strncat(pt, szNumeroUnderline[uC], 3);
  453.                             strncat(pt, szNumeroUnderline[uD], 3);
  454.                             strncat(pt, szNumeroUnderline[uE], 3);
  455.                             strncat(pt, szNumeroUnderline[uF], 3);
  456.                             //strncat(pt, szNumeroUnderline[uG], 3);
  457.  
  458.                             strncat(pt, szNumeroCSV[uA], 3);
  459.                             strncat(pt, szNumeroCSV[uB], 3);
  460.                             strncat(pt, szNumeroCSV[uC], 3);
  461.                             strncat(pt, szNumeroCSV[uD], 3);
  462.                             strncat(pt, szNumeroCSV[uE], 3);
  463.                             strncat(pt, szNumeroCSV[uF], 3);
  464.                             //strncat(pt, szNumeroCSV[uG], 3);
  465.  
  466.                             // Coloca o caractere '\n' ao invés do nulo. '\0'.
  467.                             // Pois ao salvar, devemos gravar o caractere nulo.
  468.                             pt = strchr(pt, '\0');
  469.                             *pt = '\n';
  470.  
  471.                             iContadorLinha++;
  472.  
  473.                             if(iContadorLinha==1000000)
  474.                             {
  475.                                 iContadorLinha = 0;
  476.  
  477.                                 char szTemp[20];
  478.                                 strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  479.  
  480.                                 char szArquivo[1024];
  481.                                 char *pt = szArquivo;
  482.                                 *pt = '\0';
  483.                                 strcat(pt, "/mnt/Gerador_de_Palavras/duplasena_6_numeros_arq_");
  484.                                 pt = strchr(szArquivo, '\0');
  485.  
  486.                                 iContadorArquivo++;
  487.                                 sprintf(pt, "%.10d", iContadorArquivo);
  488.                                 strcat(pt, "_inicio_");
  489.                                 strcat(pt, szTemp);
  490.                                 strcat(pt, "_fim_");
  491.  
  492.                                 time(&tempoFinal);
  493.                                 strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  494.                                 strcat(pt, szTemp);
  495.                                 strcat(pt, ".txt");
  496.  
  497.  
  498.                                 printf("Abrindo arquivo:\n%s\n", szArquivo);
  499.                                 FILE * fArquivo = fopen(szArquivo, "w");
  500.                                 if(!fArquivo)
  501.                                 {
  502.                                     fprintf(stderr, "Erro ao abrir arquivo.\n");
  503.                                     perror("Erro foi: ");
  504.                                     return -1;
  505.                                 }
  506.  
  507.                                 printf("Gravando...\t");
  508.  
  509.                                 for(int uLinha = 0; uLinha < 1000000; uLinha++)
  510.                                     fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  511.                                 fclose(fArquivo);
  512.  
  513.                                 printf("Gravado.\n\n");
  514.                             }
  515.  
  516.                             time(&tempoInicial);
  517.  
  518.                         }
  519.  
  520.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  521.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  522.     // que há linhas ainda não gravadas.
  523.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  524.     // iContadorLinha é sempre 1 a mais
  525.     if(iContadorLinha != 0)
  526.     {
  527.         char szTemp[20];
  528.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  529.  
  530.         char szArquivo[1024];
  531.         char *pt = szArquivo;
  532.         *pt = '\0';
  533.         strcat(pt, "/mnt/Gerador_de_Palavras/duplasena_6_numeros_arq_");
  534.         pt = strchr(szArquivo, '\0');
  535.  
  536.         iContadorArquivo++;
  537.         sprintf(pt, "%.10d", iContadorArquivo);
  538.         strcat(pt, "_inicio_");
  539.         strcat(pt, szTemp);
  540.         strcat(pt, "_fim_");
  541.  
  542.         time(&tempoFinal);
  543.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  544.         strcat(pt, szTemp);
  545.         strcat(pt, ".txt");
  546.  
  547.  
  548.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  549.         FILE * fArquivo = fopen(szArquivo, "w");
  550.         if(!fArquivo)
  551.         {
  552.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  553.             perror("Erro foi: ");
  554.             return -1;
  555.         }
  556.  
  557.         printf("Gravando...\t");
  558.  
  559.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  560.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  561.         fclose(fArquivo);
  562.  
  563.         printf("Gravado.\n\n");
  564.     }
  565.  
  566.     time(&tempoInicial);
  567.  
  568.     printf("Executado com sucesso!!!");
  569.  
  570.     return 0;
  571. }
  572.  
  573. void GravarArquivo(const char *ptPalavras, int quantidadeCaracteres, int contadorArquivo, time_t tempoInicial)
  574. {
  575.     char szArquivo[4096];
  576.     char *pt = szArquivo;
  577.     char szTemp[20] = {0};
  578.     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S-", localtime(&tempoInicial));
  579.  
  580.     *pt = '\0';
  581.     strcat(pt, "/mnt/Gerador_de_Palavras/palavras_arq_");
  582.     pt = strchr(pt, '\0');
  583.     sprintf(pt, "%.10d_", contadorArquivo);
  584.     strcat(pt, "inicio_");
  585.     strcat(pt, szTemp);
  586.     strcat(pt, "_fim_");
  587.  
  588.     time(&tempoInicial);
  589.     szTemp[0] = '\0';
  590.     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  591.     strcat(pt, szTemp);
  592.     strcat(pt, ".txt");
  593.  
  594.     FILE * fArquivo = fopen(szArquivo, "w");
  595.     if(!fArquivo)
  596.     {
  597.         perror("O erro foi: ");
  598.         printf("szArquivo = '%s'\n", szArquivo);
  599.         exit(-3);
  600.         return;
  601.     }
  602.  
  603.     // Vamos gravar.
  604.     printf("\nGravando no arquivo:[%d] %s\n", contadorArquivo, szArquivo);
  605.     fwrite(ptPalavras, quantidadeCaracteres, 1, fArquivo);
  606.     printf("\nGravado.\n");
  607.     fclose(fArquivo);
  608.  
  609.  
  610.  
  611. }
  612.  
  613. // Vamos criar uma função recursiva.
  614. void GerarCaracteres(char *pt, char * const ptPalavra,  char * const ptPalavraCompleta, const char * const szCaracteres,
  615.                      int uNivel, int ultimoNivel, int uIndiceAnterior, int uIndiceMaximo,
  616.                      int * qtCaracteresGerados, int * qtLinhas, time_t *tempoInicial, int *contadorArquivo)
  617. {
  618.     ptPalavraCompleta[uNivel] = szCaracteres[uIndiceAnterior];
  619.  
  620.     for(int uA = 0; uA <= uIndiceMaximo; uA++)
  621.     {
  622.         for(int uIndice = 0; uIndice < uNivel; uIndice++)
  623.         {
  624.             *pt++ = ptPalavraCompleta[uIndice];
  625.         }
  626.         *pt++ = szCaracteres[uA];
  627.         *pt++ = '\n';
  628.         *qtCaracteresGerados += uNivel+ 1;
  629.         *qtLinhas += 1;
  630.  
  631.         // Vamos gravar um novo arquivo, se a quantidade de linhas foi preenchida.
  632.         if(*qtLinhas == 1000000)
  633.         {
  634.             // A última linha não pode ter um caractere de nova linhas, pois, se tiver,
  635.             // o arquivo será gerado com mais de 1000000 de linhas.
  636.             *pt = '\0';
  637.  
  638.             GravarArquivo(ptPalavra, *qtCaracteresGerados, ++(*contadorArquivo), *tempoInicial);
  639.  
  640.             // Todas as palavras foram gravadas, devemos retornar para o ínício da primeira palavra.
  641.             pt = &ptPalavra[0];
  642.             // Definir o primeiro caractere para nulo.
  643.             *pt = '\0';
  644.  
  645.             *qtCaracteresGerados = 0;
  646.             *qtLinhas = 0;
  647.             time( (time_t *)tempoInicial);
  648.         }
  649.  
  650.  
  651.  
  652. //
  653. //                        if(qtLinhas == 1000000)
  654. //            {
  655. //                // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  656. //                GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  657. //                qtCaracteresGerados = 0;
  658. //
  659. //                qtLinhas = 0;
  660. //                pt = &szPalavras[0];
  661. //                *pt = '\0';
  662. //                time(&tempoInicial);
  663. //            }
  664.  
  665.  
  666.  
  667.         if(uNivel != ultimoNivel)
  668.             GerarCaracteres(pt, ptPalavra, ptPalavraCompleta, szCaracteres, uNivel + 1, 4,
  669.                             uA, uIndiceMaximo, qtCaracteresGerados, qtLinhas, tempoInicial, contadorArquivo);
  670.     }
  671. }
  672.  
  673.  
  674.  
  675. int GerarPalavras2()
  676. {
  677.     char szCaracteres[256];
  678.  
  679.     // Carregar Lista.
  680.     char *pt = szCaracteres;
  681.     for(int uA = 33; uA <= 127; uA++)
  682.     {
  683.         // Vamos gravar somente se é imprimível.
  684.         if(isprint((char)uA))
  685.             *pt++ = (char)uA;
  686.     }
  687.  
  688.     // Define a quantidade máxima que o programa pode operar.
  689.     const unsigned long QT_MAX_PALAVRAS = 1000000;
  690.     const unsigned long QT_MAX_CARACTERES_POR_PALAVRA = 10;
  691.     const unsigned long QT_MAX_CARACTERES_POR_LINHA = QT_MAX_CARACTERES_POR_PALAVRA + 1;
  692.  
  693.     // Podemos gerar até 10 caracteres por palavra.
  694.     // Vamos alocar 1000000 de palavras.
  695.     char *szPalavras = (char*) malloc(sizeof(char) * QT_MAX_CARACTERES_POR_LINHA * QT_MAX_PALAVRAS);
  696.     *szPalavras = '\0';
  697.  
  698.     char *szPalavraCompleta = (char*) malloc(sizeof(char*) * QT_MAX_CARACTERES_POR_LINHA);
  699.  
  700.     // Quantidade de caracteres a ser gerado ao total.
  701.     int qtCaracteres = strlen(szCaracteres) - 1;
  702.     int contadorArquivo = 0;
  703.  
  704.     // Guarda a quantidade de caracteres já gerados.
  705.     int qtCaracteresGerados = 0;
  706.     int qtLinhas = 0;
  707.  
  708.     // Guarda o horário inicial.
  709.     time_t tempoInicial = 0;
  710.     time(&tempoInicial);
  711.  
  712.     // Aponta para o primeiro caractere da primeira palavra.
  713.     pt = szPalavras;
  714.  
  715.  
  716.     GerarCaracteres(pt, szPalavras, szPalavraCompleta, szCaracteres, 0, 4, 0,
  717.                     qtCaracteres, &qtCaracteresGerados, &qtLinhas, (time_t*)tempoInicial, &contadorArquivo);
  718.  
  719.  
  720.     return 1;
  721.  
  722.  
  723.  
  724.  
  725.  
  726.  
  727.     for(int uA = 0; uA <= qtCaracteres; uA++)
  728.     {
  729.         *pt++ = szCaracteres[uA];
  730.         *pt++ = '\n';
  731.         //strncat(pt, &szCaracteres[uA], 1);
  732.         //strncat(pt, "\n", 1);
  733.         //pt+=2;
  734.         qtCaracteresGerados += 2;
  735.         qtLinhas++;
  736.         //printf("%i\n", qtLinhas);
  737.         if(qtLinhas == 1000000)
  738.         {
  739.             // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  740.             GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  741.             qtCaracteresGerados = 0;
  742.  
  743.             qtLinhas = 0;
  744.             pt = &szPalavras[0];
  745.             *pt = '\0';
  746.             time(&tempoInicial);
  747.         }
  748.  
  749.         for(int uB = 0; uB <= qtCaracteres; uB++)
  750.         {
  751.             *pt++ = szCaracteres[uA];
  752.             *pt++ = szCaracteres[uB];
  753.             *pt++ = '\n';
  754.  
  755.             qtCaracteresGerados += 3;
  756.             qtLinhas++;
  757.             //printf("%i\n", qtLinhas);
  758.             if(qtLinhas == 1000000)
  759.             {
  760.                 // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  761.                 GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  762.                 qtCaracteresGerados = 0;
  763.  
  764.                 qtLinhas = 0;
  765.                 pt = &szPalavras[0];
  766.                 *pt = '\0';
  767.                 time(&tempoInicial);
  768.             }
  769.  
  770.  
  771.             for(int uC = 0; uC <= qtCaracteres; uC++)
  772.             {
  773.                 *pt++ = szCaracteres[uA];
  774.                 *pt++ = szCaracteres[uB];
  775.                 *pt++ = szCaracteres[uC];
  776.                 *pt++ = '\n';
  777.  
  778.                 qtCaracteresGerados += 4;
  779.                 qtLinhas++;
  780.                 //printf("%i\n", qtLinhas);
  781.                 if(qtLinhas == 1000000)
  782.                 {
  783.                     // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  784.                     GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  785.                     qtCaracteresGerados = 0;
  786.  
  787.                     qtLinhas = 0;
  788.                     pt = &szPalavras[0];
  789.                     *pt = '\0';
  790.                     time(&tempoInicial);
  791.                 }
  792.  
  793.                 for(int uD= 0; uD <= qtCaracteres; uD++)
  794.                 {
  795.                     *pt++ = szCaracteres[uA];
  796.                     *pt++ = szCaracteres[uB];
  797.                     *pt++ = szCaracteres[uC];
  798.                     *pt++ = szCaracteres[uD];
  799.                     *pt++ = '\n';
  800.  
  801.                     qtCaracteresGerados += 5;
  802.                     qtLinhas++;
  803.                     //printf("%i\n", qtLinhas);
  804.                     if(qtLinhas == 1000000)
  805.                     {
  806.                         // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  807.                         GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  808.                         qtCaracteresGerados = 0;
  809.  
  810.                         qtLinhas = 0;
  811.                         pt = &szPalavras[0];
  812.                         *pt = '\0';
  813.                         time(&tempoInicial);
  814.                     }
  815.  
  816.                     for(int uE= 0; uE <= qtCaracteres; uE++)
  817.                     {
  818.                         *pt++ = szCaracteres[uA];
  819.                         *pt++ = szCaracteres[uB];
  820.                         *pt++ = szCaracteres[uC];
  821.                         *pt++ = szCaracteres[uD];
  822.                         *pt++ = szCaracteres[uE];
  823.                         *pt++ = '\n';
  824.  
  825.                         qtCaracteresGerados += 6;
  826.                         qtLinhas++;
  827.  
  828.                         //printf("%i\n", qtLinhas);
  829.                         if(qtLinhas == 1000000)
  830.                         {
  831.                             // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  832.                             GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  833.                             qtCaracteresGerados = 0;
  834.  
  835.                             qtLinhas = 0;
  836.                             pt = &szPalavras[0];
  837.                             *pt = '\0';
  838.                             time(&tempoInicial);
  839.                         }
  840.  
  841.                         for(int uF= 0; uF <= qtCaracteres; uF++)
  842.                         {
  843.                             *pt++ = szCaracteres[uA];
  844.                             *pt++ = szCaracteres[uB];
  845.                             *pt++ = szCaracteres[uC];
  846.                             *pt++ = szCaracteres[uD];
  847.                             *pt++ = szCaracteres[uE];
  848.                             *pt++ = szCaracteres[uF];
  849.                             *pt++ = '\n';
  850.  
  851.                             qtCaracteresGerados += 7;
  852.                             qtLinhas++;
  853.  
  854.                             //printf("%i\n", qtLinhas);
  855.                             if(qtLinhas == 1000000)
  856.                             {
  857.                                 // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  858.                                 GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  859.                                 qtCaracteresGerados = 0;
  860.  
  861.                                 qtLinhas = 0;
  862.                                 pt = &szPalavras[0];
  863.                                 *pt = '\0';
  864.                                 time(&tempoInicial);
  865.                             }
  866.  
  867.                             for(int uG= 0; uG <= qtCaracteres; uG++)
  868.                             {
  869.                                 *pt++ = szCaracteres[uA];
  870.                                 *pt++ = szCaracteres[uB];
  871.                                 *pt++ = szCaracteres[uC];
  872.                                 *pt++ = szCaracteres[uD];
  873.                                 *pt++ = szCaracteres[uE];
  874.                                 *pt++ = szCaracteres[uF];
  875.                                 *pt++ = szCaracteres[uG];
  876.                                 *pt++ = '\n';
  877.  
  878.                                 qtCaracteresGerados += 8;
  879.                                 qtLinhas++;
  880.  
  881.                                 //printf("%i\n", qtLinhas);
  882.                                 if(qtLinhas == 1000000)
  883.                                 {
  884.                                     // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  885.                                     GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  886.                                     qtCaracteresGerados = 0;
  887.  
  888.                                     qtLinhas = 0;
  889.                                     pt = &szPalavras[0];
  890.                                     *pt = '\0';
  891.                                     time(&tempoInicial);
  892.                                 }
  893.                             }
  894.  
  895.                         }
  896.                     }
  897.                 }
  898.             }
  899.         }
  900.     }
  901.  
  902.     // Há linhas ainda, então devemos gravar as linhas restantes no arquivo.
  903.     if(qtLinhas != 0)
  904.     {
  905.         printf("Ultimo arquivo:\n");
  906.         // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  907.         printf("Antes:\ncontadorArquivo = %i", contadorArquivo);
  908.         GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  909.         printf("Depois:\ncontadorArquivo = %i", contadorArquivo);
  910.         qtCaracteresGerados = 0;
  911.  
  912.         qtLinhas = 0;
  913.         pt = &szPalavras[0];
  914.         *pt = '\0';
  915.         time(&tempoInicial);
  916.     }
  917.     printf("Executado com sucesso.\n");
  918. }
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927. int GerarPalavras()
  928. {
  929.     char szCaracteres[256];
  930.  
  931.     // Carregar Lista.
  932.     char *pt = szCaracteres;
  933.     for(int uA = 33; uA <= 126; uA++)
  934.     {
  935.         // Vamos gravar somente se é imprimível.
  936.         if(isprint((char)uA))
  937.             *pt++ = (char)uA;
  938.     }
  939.  
  940.     // Podemos gerar até 10 caracteres por palavra.
  941.     // Vamos alocar 1000000 de palavras.
  942.     char *szPalavras = (char*) malloc(sizeof(char) * 11 * 1000000);
  943.     *szPalavras = '\0';
  944.  
  945.     // Quantidade de caracteres a ser gerado ao total.
  946.     int qtCaracteres = strlen(szCaracteres) - 1;
  947.     unsigned long contadorArquivo = 0;
  948.  
  949.     // Guarda a quantidade de caracteres já gerados.
  950.     unsigned long qtCaracteresGerados = 0;
  951.     int qtLinhas = 0;
  952.  
  953.     // Guarda o horário inicial.
  954.     time_t tempoInicial = 0;
  955.     time(&tempoInicial);
  956.  
  957.     pt = szPalavras;
  958.     for(int uA = 0; uA <= qtCaracteres; uA++)
  959.     {
  960.         *pt++ = szCaracteres[uA];
  961.         *pt++ = '\n';
  962.  
  963.         qtCaracteresGerados += 2;
  964.         qtLinhas++;
  965.         //printf("%i\n", qtLinhas);
  966.         if(qtLinhas == 1000000)
  967.         {
  968.             // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  969.             GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  970.             qtCaracteresGerados = 0;
  971.  
  972.             qtLinhas = 0;
  973.             pt = &szPalavras[0];
  974.             *pt = '\0';
  975.             time(&tempoInicial);
  976.         }
  977.  
  978.         for(int uB = 0; uB <= qtCaracteres; uB++)
  979.         {
  980.             *pt++ = szCaracteres[uA];
  981.             *pt++ = szCaracteres[uB];
  982.             *pt++ = '\n';
  983.  
  984.             qtCaracteresGerados += 3;
  985.             qtLinhas++;
  986.             //printf("%i\n", qtLinhas);
  987.             if(qtLinhas == 1000000)
  988.             {
  989.                 // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  990.                 GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  991.                 qtCaracteresGerados = 0;
  992.  
  993.                 qtLinhas = 0;
  994.                 pt = &szPalavras[0];
  995.                 *pt = '\0';
  996.                 time(&tempoInicial);
  997.             }
  998.  
  999.  
  1000.             for(int uC = 0; uC <= qtCaracteres; uC++)
  1001.             {
  1002.                 *pt++ = szCaracteres[uA];
  1003.                 *pt++ = szCaracteres[uB];
  1004.                 *pt++ = szCaracteres[uC];
  1005.                 *pt++ = '\n';
  1006.  
  1007.                 qtCaracteresGerados += 4;
  1008.                 qtLinhas++;
  1009.                 //printf("%i\n", qtLinhas);
  1010.                 if(qtLinhas == 1000000)
  1011.                 {
  1012.                     // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1013.                     GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1014.                     qtCaracteresGerados = 0;
  1015.  
  1016.                     qtLinhas = 0;
  1017.                     pt = &szPalavras[0];
  1018.                     *pt = '\0';
  1019.                     time(&tempoInicial);
  1020.                 }
  1021.  
  1022.                 for(int uD= 0; uD <= qtCaracteres; uD++)
  1023.                 {
  1024.                     *pt++ = szCaracteres[uA];
  1025.                     *pt++ = szCaracteres[uB];
  1026.                     *pt++ = szCaracteres[uC];
  1027.                     *pt++ = szCaracteres[uD];
  1028.                     *pt++ = '\n';
  1029.  
  1030.                     qtCaracteresGerados += 5;
  1031.                     qtLinhas++;
  1032.                     //printf("%i\n", qtLinhas);
  1033.                     if(qtLinhas == 1000000)
  1034.                     {
  1035.                         // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1036.                         GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1037.                         qtCaracteresGerados = 0;
  1038.  
  1039.                         qtLinhas = 0;
  1040.                         pt = &szPalavras[0];
  1041.                         *pt = '\0';
  1042.                         time(&tempoInicial);
  1043.                     }
  1044.  
  1045.                     for(int uE= 0; uE <= qtCaracteres; uE++)
  1046.                     {
  1047.                         *pt++ = szCaracteres[uA];
  1048.                         *pt++ = szCaracteres[uB];
  1049.                         *pt++ = szCaracteres[uC];
  1050.                         *pt++ = szCaracteres[uD];
  1051.                         *pt++ = szCaracteres[uE];
  1052.                         *pt++ = '\n';
  1053.  
  1054.                         qtCaracteresGerados += 6;
  1055.                         qtLinhas++;
  1056.  
  1057.                         //printf("%i\n", qtLinhas);
  1058.                         if(qtLinhas == 1000000)
  1059.                         {
  1060.                             // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1061.                             GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1062.                             qtCaracteresGerados = 0;
  1063.  
  1064.                             qtLinhas = 0;
  1065.                             pt = &szPalavras[0];
  1066.                             *pt = '\0';
  1067.                             time(&tempoInicial);
  1068.                         }
  1069.  
  1070.                         for(int uF= 0; uF <= qtCaracteres; uF++)
  1071.                         {
  1072.                             *pt++ = szCaracteres[uA];
  1073.                             *pt++ = szCaracteres[uB];
  1074.                             *pt++ = szCaracteres[uC];
  1075.                             *pt++ = szCaracteres[uD];
  1076.                             *pt++ = szCaracteres[uE];
  1077.                             *pt++ = szCaracteres[uF];
  1078.                             *pt++ = '\n';
  1079.  
  1080.                             qtCaracteresGerados += 7;
  1081.                             qtLinhas++;
  1082.  
  1083.                             //printf("%i\n", qtLinhas);
  1084.                             if(qtLinhas == 1000000)
  1085.                             {
  1086.                                 // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1087.                                 GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1088.                                 qtCaracteresGerados = 0;
  1089.  
  1090.                                 qtLinhas = 0;
  1091.                                 pt = &szPalavras[0];
  1092.                                 *pt = '\0';
  1093.                                 time(&tempoInicial);
  1094.                             }
  1095.  
  1096.                             for(int uG= 0; uG <= qtCaracteres; uG++)
  1097.                             {
  1098.                                 *pt++ = szCaracteres[uA];
  1099.                                 *pt++ = szCaracteres[uB];
  1100.                                 *pt++ = szCaracteres[uC];
  1101.                                 *pt++ = szCaracteres[uD];
  1102.                                 *pt++ = szCaracteres[uE];
  1103.                                 *pt++ = szCaracteres[uF];
  1104.                                 *pt++ = szCaracteres[uG];
  1105.                                 *pt++ = '\n';
  1106.  
  1107.                                 qtCaracteresGerados += 8;
  1108.                                 qtLinhas++;
  1109.  
  1110.                                 //printf("%i\n", qtLinhas);
  1111.                                 if(qtLinhas == 1000000)
  1112.                                 {
  1113.                                     // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1114.                                     GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1115.                                     qtCaracteresGerados = 0;
  1116.  
  1117.                                     qtLinhas = 0;
  1118.                                     pt = &szPalavras[0];
  1119.                                     *pt = '\0';
  1120.                                     time(&tempoInicial);
  1121.                                 }
  1122.                             }
  1123.  
  1124.                         }
  1125.                     }
  1126.                 }
  1127.             }
  1128.         }
  1129.     }
  1130.  
  1131.     if(qtLinhas != 0)
  1132.     {
  1133.         printf("Ultimo arquivo:\n");
  1134.         // Não iremos gravar, o último caractere '\n', por isto diminuímos 1.
  1135.         printf("Antes:\ncontadorArquivo = %li", contadorArquivo);
  1136.         GravarArquivo(szPalavras, qtCaracteresGerados-1, ++contadorArquivo, tempoInicial);
  1137.         printf("Depois:\ncontadorArquivo = %li", contadorArquivo);
  1138.         qtCaracteresGerados = 0;
  1139.  
  1140.         qtLinhas = 0;
  1141.         pt = &szPalavras[0];
  1142.         *pt = '\0';
  1143.         time(&tempoInicial);
  1144.     }
  1145.     printf("Executado com sucesso.\n");
  1146.  
  1147.     return 0;
  1148. }
  1149.  
  1150.  
  1151.  
  1152.  
  1153. int GerarQuina6Numeros()
  1154. {
  1155. //    char szTemp[4096];
  1156.  
  1157.  
  1158.     int iContadorArquivo = 0;
  1159.     int iContadorLinha = 0;
  1160.  
  1161.  
  1162.     time_t tempoInicial, tempoFinal;
  1163.     tempoInicial = time(&tempoInicial);
  1164.  
  1165.     // Vamos calcular cada linha, cada linha está neste formato:
  1166.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  1167.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  1168.     int iQuantidade = strlen("QUINA;6;_01_02_03_04_05_06;01;02;03;04;05;06") + 1;
  1169.  
  1170.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  1171.     // iremos alocar primeiramente este espaço.
  1172.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  1173.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  1174.  
  1175.     // Agora, iremos, alocar um ponteiro para ponteiro.
  1176.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  1177.  
  1178. //    char *ptTeste = szLinhas[0];
  1179.  
  1180.     // Agora, vamos apontar cada ponteiro.
  1181.     for(int iA = 0; iA < 1000000; iA++)
  1182.     {
  1183.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  1184.     }
  1185.  
  1186.  
  1187.  
  1188.  
  1189.  
  1190.     for(int uA = 1; uA <= 80; uA++)
  1191.         for(int uB = uA+1; uB <= 80; uB++)
  1192.             for(int uC = uB + 1; uC <= 80; uC++)
  1193.                 for(int uD = uC + 1; uD <= 80; uD++)
  1194.                     for(int uE = uD + 1; uE <= 80; uE++)
  1195.                         for(int uF = uE + 1; uF <= 80; uF++)
  1196.                             //for(int uG = uF + 1; uG <= 80; uG++)
  1197.                         {
  1198.                             char *pt = &szLinhas[iContadorLinha][0];
  1199. //                            char *ptUm = &szLinhas[iContadorLinha][0];
  1200.  
  1201.                             // Devemos definir o primeiro caractere nulo.
  1202.                             // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  1203.                             // o arranjo várias vezes.
  1204.                             *pt = '\0';
  1205.  
  1206.                             strcat(pt, "QUINA;6;");
  1207.                             strncat(pt, szNumeroUnderline[uA], 3);
  1208.                             strncat(pt, szNumeroUnderline[uB], 3);
  1209.                             strncat(pt, szNumeroUnderline[uC], 3);
  1210.                             strncat(pt, szNumeroUnderline[uD], 3);
  1211.                             strncat(pt, szNumeroUnderline[uE], 3);
  1212.                             strncat(pt, szNumeroUnderline[uF], 3);
  1213.                             //strncat(pt, szNumeroUnderline[uG], 3);
  1214.  
  1215.                             strncat(pt, szNumeroCSV[uA], 3);
  1216.                             strncat(pt, szNumeroCSV[uB], 3);
  1217.                             strncat(pt, szNumeroCSV[uC], 3);
  1218.                             strncat(pt, szNumeroCSV[uD], 3);
  1219.                             strncat(pt, szNumeroCSV[uE], 3);
  1220.                             strncat(pt, szNumeroCSV[uF], 3);
  1221.                             //strncat(pt, szNumeroCSV[uG], 3);
  1222.  
  1223.                             // Coloca o caractere '\n' ao invés do nulo. '\0'.
  1224.                             // Pois ao salvar, devemos gravar o caractere nulo.
  1225.                             pt = strchr(pt, '\0');
  1226.                             *pt = '\n';
  1227.  
  1228.                             iContadorLinha++;
  1229.  
  1230.                             if(iContadorLinha==1000000)
  1231.                             {
  1232.                                 iContadorLinha = 0;
  1233.  
  1234.                                 char szTemp[20];
  1235.                                 strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1236.  
  1237.                                 char szArquivo[1024];
  1238.                                 char *pt = szArquivo;
  1239.                                 *pt = '\0';
  1240.                                 strcat(pt, "/mnt/Gerador_de_Palavras/quina_6_numeros_arq_");
  1241.                                 pt = strchr(szArquivo, '\0');
  1242.  
  1243.                                 iContadorArquivo++;
  1244.                                 sprintf(pt, "%.10d", iContadorArquivo);
  1245.                                 strcat(pt, "_inicio_");
  1246.                                 strcat(pt, szTemp);
  1247.                                 strcat(pt, "_fim_");
  1248.  
  1249.                                 time(&tempoFinal);
  1250.                                 strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1251.                                 strcat(pt, szTemp);
  1252.                                 strcat(pt, ".txt");
  1253.  
  1254.  
  1255.                                 printf("Criando arquivo:\n%s\n", szArquivo);
  1256.                                 FILE * fArquivo = fopen(szArquivo, "w");
  1257.                                 if(!fArquivo)
  1258.                                 {
  1259.                                     fprintf(stderr, "Erro ao abrir arquivo.\n");
  1260.                                     perror("Erro foi: ");
  1261.                                     return -1;
  1262.                                 }
  1263.  
  1264.                                 printf("Gravando...\t");
  1265.  
  1266.  
  1267.                                 for(int uLinha = 0; uLinha < 1000000; uLinha++)
  1268.                                     fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1269.  
  1270.                                 fclose(fArquivo);
  1271.  
  1272.                                 printf("Gravado.\n\n");
  1273.                             }
  1274.  
  1275.                             time(&tempoInicial);
  1276.  
  1277.                         }
  1278.  
  1279.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  1280.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  1281.     // que há linhas ainda não gravadas.
  1282.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  1283.     // iContadorLinha é sempre 1 a mais
  1284.     if(iContadorLinha != 0)
  1285.     {
  1286.         char szTemp[20];
  1287.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1288.  
  1289.         char szArquivo[1024];
  1290.         char *pt = szArquivo;
  1291.         *pt = '\0';
  1292.         strcat(pt, "/mnt/Gerador_de_Palavras/quina_6_numeros_arq_");
  1293.         pt = strchr(szArquivo, '\0');
  1294.  
  1295.         iContadorArquivo++;
  1296.         sprintf(pt, "%.10d", iContadorArquivo);
  1297.         strcat(pt, "_inicio_");
  1298.         strcat(pt, szTemp);
  1299.         strcat(pt, "_fim_");
  1300.  
  1301.         time(&tempoFinal);
  1302.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1303.         strcat(pt, szTemp);
  1304.         strcat(pt, ".txt");
  1305.  
  1306.  
  1307.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  1308.         FILE * fArquivo = fopen(szArquivo, "w");
  1309.         if(!fArquivo)
  1310.         {
  1311.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  1312.             perror("Erro foi: ");
  1313.             return -1;
  1314.         }
  1315.  
  1316.         printf("Gravando...\t");
  1317.  
  1318.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1319.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1320.         fclose(fArquivo);
  1321.  
  1322.         printf("Gravado.\n\n");
  1323.     }
  1324.  
  1325.     time(&tempoInicial);
  1326.  
  1327.     printf("Executado com sucesso!!!");
  1328.  
  1329.     return 0;
  1330. }
  1331.  
  1332. int GerarQuina7Numeros()
  1333. {
  1334. //    char szTemp[4096];
  1335.  
  1336.  
  1337.     int iContadorArquivo = 0;
  1338.     int iContadorLinha = 0;
  1339.  
  1340.  
  1341.     time_t tempoInicial, tempoFinal;
  1342.     tempoInicial = time(&tempoInicial);
  1343.  
  1344.     // Vamos calcular cada linha, cada linha está neste formato:
  1345.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  1346.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  1347.     int iQuantidade = strlen("QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07") + 1;
  1348.  
  1349.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  1350.     // iremos alocar primeiramente este espaço.
  1351.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  1352.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  1353.  
  1354.     // Agora, iremos, alocar um ponteiro para ponteiro.
  1355.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  1356.  
  1357. //    char *ptTeste = szLinhas[0];
  1358.  
  1359.     // Agora, vamos apontar cada ponteiro.
  1360.     for(int iA = 0; iA < 1000000; iA++)
  1361.     {
  1362.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  1363.     }
  1364.  
  1365.     char *pt = NULL;
  1366.     for(int uA = 1; uA <= 80; uA++)
  1367.         for(int uB = uA+1; uB <= 80; uB++)
  1368.             for(int uC = uB + 1; uC <= 80; uC++)
  1369.                 for(int uD = uC + 1; uD <= 80; uD++)
  1370.                     for(int uE = uD + 1; uE <= 80; uE++)
  1371.                         for(int uF = uE + 1; uF <= 80; uF++)
  1372.                             for(int uG = uF + 1; uG <= 80; uG++)
  1373.                             {
  1374.                                 char *pt = &szLinhas[iContadorLinha][0];
  1375. //                                char *ptUm = &szLinhas[iContadorLinha][0];
  1376.  
  1377.                                 // Devemos definir o primeiro caractere nulo.
  1378.                                 // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  1379.                                 // o arranjo várias vezes.
  1380.                                 *pt = '\0';
  1381.  
  1382.                                 strcat(pt, "QUINA;7;");
  1383.                                 strncat(pt, szNumeroUnderline[uA], 3);
  1384.                                 strncat(pt, szNumeroUnderline[uB], 3);
  1385.                                 strncat(pt, szNumeroUnderline[uC], 3);
  1386.                                 strncat(pt, szNumeroUnderline[uD], 3);
  1387.                                 strncat(pt, szNumeroUnderline[uE], 3);
  1388.                                 strncat(pt, szNumeroUnderline[uF], 3);
  1389.                                 strncat(pt, szNumeroUnderline[uG], 3);
  1390.  
  1391.                                 strncat(pt, szNumeroCSV[uA], 3);
  1392.                                 strncat(pt, szNumeroCSV[uB], 3);
  1393.                                 strncat(pt, szNumeroCSV[uC], 3);
  1394.                                 strncat(pt, szNumeroCSV[uD], 3);
  1395.                                 strncat(pt, szNumeroCSV[uE], 3);
  1396.                                 strncat(pt, szNumeroCSV[uF], 3);
  1397.                                 strncat(pt, szNumeroCSV[uG], 3);
  1398.  
  1399.                                 // Coloca o caractere '\n' ao invés do nulo. '\0'.
  1400.                                 // Pois ao salvar, devemos gravar o caractere nulo.
  1401.                                 pt = strchr(pt, '\0');
  1402.                                 *pt = '\n';
  1403.  
  1404.                                 iContadorLinha++;
  1405.  
  1406.                                 if(iContadorLinha==1000000)
  1407.                                 {
  1408.                                     char szTemp[20];
  1409.                                     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1410.  
  1411.                                     char szArquivo[1024];
  1412.                                     char *ptArquivo = szArquivo;
  1413.                                     *ptArquivo = '\0';
  1414.                                     strcat(ptArquivo, "/mnt/Gerador_de_Palavras/quina_7_numeros_arq_");
  1415.                                     ptArquivo = strchr(szArquivo, '\0');
  1416.  
  1417.                                     iContadorArquivo++;
  1418.                                     sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1419.                                     strcat(ptArquivo, "_inicio_");
  1420.                                     strcat(ptArquivo, szTemp);
  1421.                                     strcat(ptArquivo, "_fim_");
  1422.  
  1423.                                     time(&tempoFinal);
  1424.                                     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1425.                                     strcat(ptArquivo, szTemp);
  1426.                                     strcat(ptArquivo, ".txt");
  1427.  
  1428.  
  1429.                                     printf("Abrindo arquivo:\n%s\n", szArquivo);
  1430.                                     FILE * fArquivo = fopen(szArquivo, "w");
  1431.                                     if(!fArquivo)
  1432.                                     {
  1433.                                         fprintf(stderr, "Erro ao abrir arquivo.\n");
  1434.                                         perror("Erro foi: ");
  1435.                                         return -1;
  1436.                                     }
  1437.  
  1438.                                     printf("Gravando...\t");
  1439.  
  1440.                                     for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1441.                                         fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1442.                                     fclose(fArquivo);
  1443.  
  1444.                                     printf("Gravado.\n\n");
  1445.                                 }
  1446.  
  1447.                                 time(&tempoInicial);
  1448.                             }
  1449.  
  1450.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  1451.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  1452.     // que há linhas ainda não gravadas.
  1453.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  1454.     // iContadorLinha é sempre 1 a mais
  1455.     if(iContadorLinha != 0)
  1456.     {
  1457.         *pt = '\0';
  1458.         char szTemp[20];
  1459.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1460.  
  1461.         char szArquivo[1024];
  1462.         char *ptArquivo = szArquivo;
  1463.         *ptArquivo = '\0';
  1464.         strcat(ptArquivo, "/mnt/Gerador_de_Palavras/quina_7_numeros_arq_");
  1465.         ptArquivo = strchr(szArquivo, '\0');
  1466.  
  1467.         iContadorArquivo++;
  1468.         sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1469.         strcat(ptArquivo, "_inicio_");
  1470.         strcat(ptArquivo, szTemp);
  1471.         strcat(ptArquivo, "_fim_");
  1472.  
  1473.         time(&tempoFinal);
  1474.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1475.         strcat(ptArquivo, szTemp);
  1476.         strcat(ptArquivo, ".txt");
  1477.  
  1478.  
  1479.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  1480.         FILE * fArquivo = fopen(szArquivo, "w");
  1481.         if(!fArquivo)
  1482.         {
  1483.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  1484.             perror("Erro foi: ");
  1485.             return -1;
  1486.         }
  1487.  
  1488.         printf("Gravando...\t");
  1489.  
  1490.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1491.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1492.         fclose(fArquivo);
  1493.  
  1494.         printf("Gravado.\n\n");
  1495.     }
  1496.  
  1497.     time(&tempoInicial);
  1498.  
  1499.     printf("Executado com sucesso!!!");
  1500.  
  1501.     return 0;
  1502. }
  1503.  
  1504.  
  1505. // Esta função gera todos os inserts para o jogo lotofácil.
  1506. int GerarLotofacil15Numeros()
  1507. {
  1508. //    char szTemp[4096];
  1509.  
  1510.  
  1511.     int iContadorArquivo = 0;
  1512.     int iContadorLinha = 0;
  1513.  
  1514.  
  1515.     time_t tempoInicial, tempoFinal;
  1516.     tempoInicial = time(&tempoInicial);
  1517.  
  1518.     // Vamos calcular cada linha, cada linha está neste formato:
  1519.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  1520.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  1521. //    int iQuantidade = strlen("LOTOMANIA;50;_01_02_03_04_05_06_07_08_09_10"
  1522. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  1523. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  1524. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  1525. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  1526. //                             ";01;02;03;04;05;06;07;08;09;10"
  1527. //                            ) + 1;
  1528.  
  1529.     int iQuantidade = strlen("LOTOMANIA;50;;00"
  1530. //                             "_00"
  1531. //                             "_01_02_03_04_05_06_07_08_09_10"
  1532. //                             "_11_12_13_14_15_16_17_18_19_20"
  1533. //                             "_21_22_23_24_25_26_27_28_29_30"
  1534. //                             "_31_32_33_34_35_36_37_38_39_40"
  1535. //                             "_41_42_43_44_45_46_47_48_49;00"
  1536.                              ";01;02;03;04;05;06;07;08;09;10"
  1537.                              ";11;12;13;14;15;16;17;18;19;20"
  1538.                              ";21;22;23;24;25;26;27;28;29;30"
  1539.                              ";31;32;33;34;35;36;37;38;39;40"
  1540.                              ";41;42;43;44;45;46;47;48;49") + 1;
  1541.  
  1542.  
  1543.     const int QT_CARACTERES = 3000;
  1544.     const int QT_PALAVRAS = 10000000;
  1545.  
  1546.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  1547.     // iremos alocar primeiramente este espaço.
  1548.     char *szTodasLinhas = (char*)malloc(sizeof(char)* QT_CARACTERES * QT_PALAVRAS);
  1549.  
  1550.     // Vamos verificar se foi possível alocar.
  1551.     if(!szTodasLinhas)
  1552.     {
  1553.         fprintf(stderr, "Não foi possível alocar a memória.\n");
  1554.         exit(-3);
  1555.     }
  1556.  
  1557.  
  1558.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  1559.  
  1560.     // Agora, iremos, alocar um ponteiro para ponteiro.
  1561.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  1562.  
  1563. //    char *ptTeste = szLinhas[0];
  1564.  
  1565.     // Agora, vamos apontar cada ponteiro.
  1566.     for(int iA = 0; iA < 1000000; iA++)
  1567.     {
  1568.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  1569.     }
  1570.  
  1571.     char *pt = NULL;
  1572.  
  1573.     for(int uA = 0; uA <= 99; uA++)
  1574.     for(int uB = uA + 1; uB <= 99; uB++)
  1575.     for(int uC = uB + 1; uC <= 99; uC++)
  1576.     for(int uD = uC + 1; uD <= 99; uD++)
  1577.     for(int uE = uD + 1; uE <= 99; uE++)
  1578.     for(int uF = uE + 1; uF <= 99; uF++)
  1579.     for(int uG = uF + 1; uG <= 99; uG++)
  1580.     for(int uH = uG + 1; uH <= 99; uH++)
  1581.     for(int uI = uH + 1; uI <= 99; uI++)
  1582.     for(int uJ = uI + 1; uJ <= 99; uJ++)
  1583.     for(int uK = uJ + 1; uK <= 99; uK++)
  1584.     for(int uL = uK + 1; uL <= 99; uL++)
  1585.     for(int uM = uL + 1; uM <= 99; uM++)
  1586.     for(int uN = uM + 1; uN <= 99; uN++)
  1587.     for(int uO = uN + 1; uO <= 99; uO++)
  1588.     for(int uP = uO + 1; uP <= 99; uP++)
  1589.     for(int uQ = uP + 1; uQ <= 99; uQ++)
  1590.     for(int uR = uQ + 1; uR <= 99; uR++)
  1591.     for(int uS = uR + 1; uS <= 99; uS++)
  1592.     for(int uT = uS + 1; uT <= 99; uT++)
  1593.     for(int uU = uT + 1; uU <= 99; uU++)
  1594.     for(int uV = uU + 1; uV <= 99; uV++)
  1595.     for(int uW = uV + 1; uW <= 99; uW++)
  1596.     for(int uX = uW + 1; uX <= 99; uX++)
  1597.     for(int uY = uX + 1; uY <= 99; uY++)
  1598.     for(int uZ = uY + 1; uZ <= 99; uZ++)
  1599.     for(int uAA = uZ + 1; uAA <= 99; uAA++)
  1600.     for(int uBB = uAA + 1; uBB <= 99; uBB++)
  1601.     for(int uCC = uBB + 1; uCC <= 99; uCC++)
  1602.     for(int uDD = uCC + 1; uDD <= 99; uDD++)
  1603.     for(int uEE = uDD + 1; uEE <= 99; uEE++)
  1604.     for(int uFF = uEE + 1; uFF <= 99; uFF++)
  1605.     for(int uGG = uFF + 1; uGG <= 99; uGG++)
  1606.     for(int uHH = uGG + 1; uHH <= 99; uHH++)
  1607.     for(int uII = uHH + 1; uII <= 99; uII++)
  1608.     for(int uJJ = uII + 1; uJJ <= 99; uJJ++)
  1609.     for(int uKK = uJJ + 1; uKK <= 99; uKK++)
  1610.     for(int uLL = uKK + 1; uLL <= 99; uLL++)
  1611.     for(int uMM = uLL + 1; uMM <= 99; uMM++)
  1612.     for(int uNN = uMM + 1; uNN <= 99; uNN++)
  1613.     for(int uOO = uNN + 1; uOO <= 99; uOO++)
  1614.     for(int uPP = uOO + 1; uPP <= 99; uPP++)
  1615.     for(int uQQ = uPP + 1; uQQ <= 99; uQQ++)
  1616.     for(int uRR = uQQ + 1; uRR <= 99; uRR++)
  1617.     for(int uSS = uRR + 1; uSS <= 99; uSS++)
  1618.     for(int uTT = uSS + 1; uTT <= 99; uTT++)
  1619.     for(int uUU = uTT + 1; uUU <= 99; uUU++)
  1620.     for(int uVV = uUU + 1; uVV <= 99; uVV++)
  1621.     for(int uWW = uVV + 1; uWW <= 99; uWW++)
  1622.     for(int uXX = uWW + 1; uXX <= 99; uXX++)
  1623.  
  1624.  
  1625.  
  1626.     {
  1627.         char *pt = &szLinhas[iContadorLinha][0];
  1628. //        char *ptUm = &szLinhas[iContadorLinha][0];
  1629.  
  1630.         // Devemos definir o primeiro caractere nulo.
  1631.         // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  1632.         // o arranjo várias vezes.
  1633.         *pt = '\0';
  1634.  
  1635.         strncat(pt, "LOTOMANIA;50;", 13);
  1636.  
  1637.         pt += 13;
  1638.  
  1639.         *pt++ = szNumeroCSV[uA][0]; *pt++ = szNumeroCSV[uA][1]; *pt++ = szNumeroCSV[uA][2];
  1640.         *pt++ = szNumeroCSV[uB][0]; *pt++ = szNumeroCSV[uB][1]; *pt++ = szNumeroCSV[uB][2];
  1641.         *pt++ = szNumeroCSV[uC][0]; *pt++ = szNumeroCSV[uC][1]; *pt++ = szNumeroCSV[uC][2];
  1642.         *pt++ = szNumeroCSV[uD][0]; *pt++ = szNumeroCSV[uD][1]; *pt++ = szNumeroCSV[uD][2];
  1643.         *pt++ = szNumeroCSV[uE][0]; *pt++ = szNumeroCSV[uE][1]; *pt++ = szNumeroCSV[uE][2];
  1644.         *pt++ = szNumeroCSV[uF][0]; *pt++ = szNumeroCSV[uF][1]; *pt++ = szNumeroCSV[uF][2];
  1645.         *pt++ = szNumeroCSV[uG][0]; *pt++ = szNumeroCSV[uG][1]; *pt++ = szNumeroCSV[uG][2];
  1646.         *pt++ = szNumeroCSV[uH][0]; *pt++ = szNumeroCSV[uH][1]; *pt++ = szNumeroCSV[uH][2];
  1647.         *pt++ = szNumeroCSV[uI][0]; *pt++ = szNumeroCSV[uI][1]; *pt++ = szNumeroCSV[uI][2];
  1648.         *pt++ = szNumeroCSV[uJ][0]; *pt++ = szNumeroCSV[uJ][1]; *pt++ = szNumeroCSV[uJ][2];
  1649.         *pt++ = szNumeroCSV[uK][0]; *pt++ = szNumeroCSV[uK][1]; *pt++ = szNumeroCSV[uK][2];
  1650.         *pt++ = szNumeroCSV[uL][0]; *pt++ = szNumeroCSV[uL][1]; *pt++ = szNumeroCSV[uL][2];
  1651.         *pt++ = szNumeroCSV[uM][0]; *pt++ = szNumeroCSV[uM][1]; *pt++ = szNumeroCSV[uM][2];
  1652.         *pt++ = szNumeroCSV[uN][0]; *pt++ = szNumeroCSV[uN][1]; *pt++ = szNumeroCSV[uN][2];
  1653.         *pt++ = szNumeroCSV[uO][0]; *pt++ = szNumeroCSV[uO][1]; *pt++ = szNumeroCSV[uO][2];
  1654.         *pt++ = szNumeroCSV[uP][0]; *pt++ = szNumeroCSV[uP][1]; *pt++ = szNumeroCSV[uP][2];
  1655.         *pt++ = szNumeroCSV[uQ][0]; *pt++ = szNumeroCSV[uQ][1]; *pt++ = szNumeroCSV[uQ][2];
  1656.         *pt++ = szNumeroCSV[uR][0]; *pt++ = szNumeroCSV[uR][1]; *pt++ = szNumeroCSV[uR][2];
  1657.         *pt++ = szNumeroCSV[uS][0]; *pt++ = szNumeroCSV[uS][1]; *pt++ = szNumeroCSV[uS][2];
  1658.         *pt++ = szNumeroCSV[uT][0]; *pt++ = szNumeroCSV[uT][1]; *pt++ = szNumeroCSV[uT][2];
  1659.         *pt++ = szNumeroCSV[uU][0]; *pt++ = szNumeroCSV[uU][1]; *pt++ = szNumeroCSV[uU][2];
  1660.         *pt++ = szNumeroCSV[uV][0]; *pt++ = szNumeroCSV[uV][1]; *pt++ = szNumeroCSV[uV][2];
  1661.         *pt++ = szNumeroCSV[uW][0]; *pt++ = szNumeroCSV[uW][1]; *pt++ = szNumeroCSV[uW][2];
  1662.         *pt++ = szNumeroCSV[uX][0]; *pt++ = szNumeroCSV[uX][1]; *pt++ = szNumeroCSV[uX][2];
  1663.         *pt++ = szNumeroCSV[uY][0]; *pt++ = szNumeroCSV[uY][1]; *pt++ = szNumeroCSV[uY][2];
  1664.         *pt++ = szNumeroCSV[uZ][0]; *pt++ = szNumeroCSV[uZ][1]; *pt++ = szNumeroCSV[uZ][2];
  1665.         *pt++ = szNumeroCSV[uAA][0];    *pt++ = szNumeroCSV[uAA][1];    *pt++ = szNumeroCSV[uAA][2];
  1666.         *pt++ = szNumeroCSV[uBB][0];    *pt++ = szNumeroCSV[uBB][1];    *pt++ = szNumeroCSV[uBB][2];
  1667.         *pt++ = szNumeroCSV[uCC][0];    *pt++ = szNumeroCSV[uCC][1];    *pt++ = szNumeroCSV[uCC][2];
  1668.         *pt++ = szNumeroCSV[uDD][0];    *pt++ = szNumeroCSV[uDD][1];    *pt++ = szNumeroCSV[uDD][2];
  1669.         *pt++ = szNumeroCSV[uEE][0];    *pt++ = szNumeroCSV[uEE][1];    *pt++ = szNumeroCSV[uEE][2];
  1670.         *pt++ = szNumeroCSV[uFF][0];    *pt++ = szNumeroCSV[uFF][1];    *pt++ = szNumeroCSV[uFF][2];
  1671.         *pt++ = szNumeroCSV[uGG][0];    *pt++ = szNumeroCSV[uGG][1];    *pt++ = szNumeroCSV[uGG][2];
  1672.         *pt++ = szNumeroCSV[uHH][0];    *pt++ = szNumeroCSV[uHH][1];    *pt++ = szNumeroCSV[uHH][2];
  1673.         *pt++ = szNumeroCSV[uII][0];    *pt++ = szNumeroCSV[uII][1];    *pt++ = szNumeroCSV[uII][2];
  1674.         *pt++ = szNumeroCSV[uJJ][0];    *pt++ = szNumeroCSV[uJJ][1];    *pt++ = szNumeroCSV[uJJ][2];
  1675.         *pt++ = szNumeroCSV[uKK][0];    *pt++ = szNumeroCSV[uKK][1];    *pt++ = szNumeroCSV[uKK][2];
  1676.         *pt++ = szNumeroCSV[uLL][0];    *pt++ = szNumeroCSV[uLL][1];    *pt++ = szNumeroCSV[uLL][2];
  1677.         *pt++ = szNumeroCSV[uMM][0];    *pt++ = szNumeroCSV[uMM][1];    *pt++ = szNumeroCSV[uMM][2];
  1678.         *pt++ = szNumeroCSV[uNN][0];    *pt++ = szNumeroCSV[uNN][1];    *pt++ = szNumeroCSV[uNN][2];
  1679.         *pt++ = szNumeroCSV[uOO][0];    *pt++ = szNumeroCSV[uOO][1];    *pt++ = szNumeroCSV[uOO][2];
  1680.         *pt++ = szNumeroCSV[uPP][0];    *pt++ = szNumeroCSV[uPP][1];    *pt++ = szNumeroCSV[uPP][2];
  1681.         *pt++ = szNumeroCSV[uQQ][0];    *pt++ = szNumeroCSV[uQQ][1];    *pt++ = szNumeroCSV[uQQ][2];
  1682.         *pt++ = szNumeroCSV[uRR][0];    *pt++ = szNumeroCSV[uRR][1];    *pt++ = szNumeroCSV[uRR][2];
  1683.         *pt++ = szNumeroCSV[uSS][0];    *pt++ = szNumeroCSV[uSS][1];    *pt++ = szNumeroCSV[uSS][2];
  1684.         *pt++ = szNumeroCSV[uTT][0];    *pt++ = szNumeroCSV[uTT][1];    *pt++ = szNumeroCSV[uTT][2];
  1685.         *pt++ = szNumeroCSV[uUU][0];    *pt++ = szNumeroCSV[uUU][1];    *pt++ = szNumeroCSV[uUU][2];
  1686.         *pt++ = szNumeroCSV[uVV][0];    *pt++ = szNumeroCSV[uVV][1];    *pt++ = szNumeroCSV[uVV][2];
  1687.         *pt++ = szNumeroCSV[uWW][0];    *pt++ = szNumeroCSV[uWW][1];    *pt++ = szNumeroCSV[uWW][2];
  1688.         *pt++ = szNumeroCSV[uXX][0];    *pt++ = szNumeroCSV[uXX][1];    *pt++ = szNumeroCSV[uXX][2];
  1689.  
  1690.         *pt = '\n';
  1691.  
  1692.  
  1693.         iContadorLinha++;
  1694.  
  1695.         if(iContadorLinha==1000000)
  1696.         {
  1697.             // Evita que a última linha gere um caractere de nova linha.
  1698.             *pt = '\0';
  1699.  
  1700.             char szTemp[20];
  1701.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1702.  
  1703.             char szArquivo[1024];
  1704.             char *ptArquivo = szArquivo;
  1705.             *ptArquivo = '\0';
  1706.             strcat(ptArquivo, "/mnt/Gerador_de_Palavras/lotomania_arq_");
  1707.             ptArquivo = strchr(szArquivo, '\0');
  1708.  
  1709.             iContadorArquivo++;
  1710.             sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1711.             strcat(ptArquivo, "_inicio_");
  1712.             strcat(ptArquivo, szTemp);
  1713.             strcat(ptArquivo, "_fim_");
  1714.  
  1715.             time(&tempoFinal);
  1716.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1717.             strcat(ptArquivo, szTemp);
  1718.             strcat(ptArquivo, ".txt");
  1719.  
  1720.  
  1721.             printf("Abrindo arquivo:\n%s\n", szArquivo);
  1722.             FILE * fArquivo = fopen(szArquivo, "w");
  1723.             if(!fArquivo)
  1724.             {
  1725.                 fprintf(stderr, "Erro ao abrir arquivo.\n");
  1726.                 perror("Erro foi: ");
  1727.                 return -1;
  1728.             }
  1729.  
  1730.             printf("Gravando...\t");
  1731.  
  1732.             for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1733.                 fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1734.             fclose(fArquivo);
  1735.  
  1736.             printf("Gravado.\n\n");
  1737.  
  1738.             // Reseta o contador da linha.
  1739.             iContadorLinha = 0;
  1740.         }
  1741.  
  1742.         time(&tempoInicial);
  1743.     }
  1744.  
  1745.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  1746.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  1747.     // que há linhas ainda não gravadas.
  1748.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  1749.     // iContadorLinha é sempre 1 a mais
  1750.     if(iContadorLinha != 0)
  1751.     {
  1752.         *pt = '\0';
  1753.         char szTemp[20];
  1754.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1755.  
  1756.         char szArquivo[1024];
  1757.         char *ptArquivo = szArquivo;
  1758.         *ptArquivo = '\0';
  1759.         strcat(ptArquivo, "/mnt/Gerador_de_Palavras/lotomania_arq_");
  1760.         ptArquivo = strchr(szArquivo, '\0');
  1761.  
  1762.         iContadorArquivo++;
  1763.         sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1764.         strcat(ptArquivo, "_inicio_");
  1765.         strcat(ptArquivo, szTemp);
  1766.         strcat(ptArquivo, "_fim_");
  1767.  
  1768.         time(&tempoFinal);
  1769.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1770.         strcat(ptArquivo, szTemp);
  1771.         strcat(ptArquivo, ".txt");
  1772.  
  1773.  
  1774.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  1775.         FILE * fArquivo = fopen(szArquivo, "w");
  1776.         if(!fArquivo)
  1777.         {
  1778.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  1779.             perror("Erro foi: ");
  1780.             return -1;
  1781.         }
  1782.  
  1783.         printf("Gravando...\t");
  1784.  
  1785.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1786.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1787.         fclose(fArquivo);
  1788.  
  1789.         printf("Gravado.\n\n");
  1790.  
  1791.         // Reseta o contador da linha.
  1792.         iContadorLinha = 0;
  1793.     }
  1794.  
  1795.     time(&tempoInicial);
  1796.  
  1797.     printf("Executado com sucesso!!!");
  1798.  
  1799.     return 0;
  1800. }
  1801.  
  1802.  
  1803. int GerarKeno10Numeros()
  1804. {
  1805.     const int QT_PALAVRAS = 1000000;
  1806.     const int MENOR_BOLA = 1;
  1807.     const int MAIOR_BOLA = 80;
  1808.  
  1809.     int iContadorArquivo = 0;
  1810.     int iContadorLinha = 0;
  1811.  
  1812.     time_t tempoInicial, tempoFinal;
  1813.     tempoInicial = time(&tempoInicial);
  1814.  
  1815.     // Vamos calcular cada linha, cada linha está neste formato:
  1816.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  1817.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  1818. //    int iQuantidade = strlen("LOTOMANIA;50;_01_02_03_04_05_06_07_08_09_10"
  1819. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  1820. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  1821. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  1822. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  1823. //                             ";01;02;03;04;05;06;07;08;09;10"
  1824. //                            ) + 1;
  1825.  
  1826.     int iQuantidade = strlen("KENO;10;;01;02;03;04;05;06;07;08;09;10") + 1;
  1827.  
  1828.  
  1829.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  1830.     // iremos alocar primeiramente este espaço.
  1831.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * QT_PALAVRAS);
  1832.  
  1833.     // Vamos verificar se foi possível alocar.
  1834.     if(!szTodasLinhas)
  1835.     {
  1836.         fprintf(stderr, "Não foi possível alocar a memória.\n");
  1837.         exit(-3);
  1838.     }
  1839.  
  1840.  
  1841.  
  1842.  
  1843.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * QT_PALAVRAS);
  1844.  
  1845.     // Agora, iremos, alocar um ponteiro para ponteiro.
  1846.     char **szLinhas = (char**)malloc(sizeof(char*)* QT_PALAVRAS);
  1847.  
  1848. //    char *ptTeste = szLinhas[0];
  1849.  
  1850.     // Agora, vamos apontar cada ponteiro.
  1851.     for(int iA = 0; iA < QT_PALAVRAS; iA++)
  1852.     {
  1853.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  1854.     }
  1855.  
  1856.     char *pt = NULL;
  1857.  
  1858.     for(int uA = MENOR_BOLA; uA <= MAIOR_BOLA; uA++)
  1859.     for(int uB = uA + 1; uB <= MAIOR_BOLA; uB++)
  1860.     for(int uC = uB + 1; uC <= MAIOR_BOLA; uC++)
  1861.     for(int uD = uC + 1; uD <= MAIOR_BOLA; uD++)
  1862.     for(int uE = uD + 1; uE <= MAIOR_BOLA; uE++)
  1863.     for(int uF = uE + 1; uF <= MAIOR_BOLA; uF++)
  1864.     for(int uG = uF + 1; uG <= MAIOR_BOLA; uG++)
  1865.     for(int uH = uG + 1; uH <= MAIOR_BOLA; uH++)
  1866.     for(int uI = uH + 1; uI <= MAIOR_BOLA; uI++)
  1867.     for(int uJ = uI + 1; uJ <= MAIOR_BOLA; uJ++)
  1868.  
  1869.     {
  1870.         char *pt = &szLinhas[iContadorLinha][0];
  1871. //        char *ptUm = &szLinhas[iContadorLinha][0];
  1872.  
  1873.         // Devemos definir o primeiro caractere nulo.
  1874.         // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  1875.         // o arranjo várias vezes.
  1876.         *pt = '\0';
  1877.  
  1878.         strncat(pt, "KENO;10;", 8);
  1879.  
  1880.         pt += 8;
  1881.  
  1882.         *pt++ = szNumeroCSV[uA][0]; *pt++ = szNumeroCSV[uA][1]; *pt++ = szNumeroCSV[uA][2];
  1883.         *pt++ = szNumeroCSV[uB][0]; *pt++ = szNumeroCSV[uB][1]; *pt++ = szNumeroCSV[uB][2];
  1884.         *pt++ = szNumeroCSV[uC][0]; *pt++ = szNumeroCSV[uC][1]; *pt++ = szNumeroCSV[uC][2];
  1885.         *pt++ = szNumeroCSV[uD][0]; *pt++ = szNumeroCSV[uD][1]; *pt++ = szNumeroCSV[uD][2];
  1886.         *pt++ = szNumeroCSV[uE][0]; *pt++ = szNumeroCSV[uE][1]; *pt++ = szNumeroCSV[uE][2];
  1887.         *pt++ = szNumeroCSV[uF][0]; *pt++ = szNumeroCSV[uF][1]; *pt++ = szNumeroCSV[uF][2];
  1888.         *pt++ = szNumeroCSV[uG][0]; *pt++ = szNumeroCSV[uG][1]; *pt++ = szNumeroCSV[uG][2];
  1889.         *pt++ = szNumeroCSV[uH][0]; *pt++ = szNumeroCSV[uH][1]; *pt++ = szNumeroCSV[uH][2];
  1890.         *pt++ = szNumeroCSV[uI][0]; *pt++ = szNumeroCSV[uI][1]; *pt++ = szNumeroCSV[uI][2];
  1891.         *pt++ = szNumeroCSV[uJ][0]; *pt++ = szNumeroCSV[uJ][1]; *pt++ = szNumeroCSV[uJ][2];
  1892.  
  1893.         *pt++ = '\n';
  1894.  
  1895.  
  1896.         iContadorLinha++;
  1897.  
  1898.         if(iContadorLinha==QT_PALAVRAS)
  1899.         {
  1900.             // Evita que a última linha gere um caractere de nova linha.
  1901.             *(--pt) = '\0';
  1902.  
  1903.             char szTemp[20];
  1904.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1905.  
  1906.             char szArquivo[1024];
  1907.             char *ptArquivo = szArquivo;
  1908.             *ptArquivo = '\0';
  1909.             strcat(ptArquivo, "/mnt/Gerador_de_Palavras/Keno_arq_");
  1910.             ptArquivo = strchr(szArquivo, '\0');
  1911.  
  1912.             iContadorArquivo++;
  1913.             sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1914.             strcat(ptArquivo, "_inicio_");
  1915.             strcat(ptArquivo, szTemp);
  1916.             strcat(ptArquivo, "_fim_");
  1917.  
  1918.             time(&tempoFinal);
  1919.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1920.             strcat(ptArquivo, szTemp);
  1921.             strcat(ptArquivo, ".txt");
  1922.  
  1923.  
  1924.             printf("Abrindo arquivo:\n%s\n", szArquivo);
  1925.             FILE * fArquivo = fopen(szArquivo, "w");
  1926.             if(!fArquivo)
  1927.             {
  1928.                 fprintf(stderr, "Erro ao abrir arquivo.\n");
  1929.                 perror("Erro foi: ");
  1930.                 return -1;
  1931.             }
  1932.  
  1933.             printf("Gravando...\t");
  1934.  
  1935.             for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1936.                 fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1937.             fclose(fArquivo);
  1938.  
  1939.             printf("Gravado.\n\n");
  1940.  
  1941.             // Reseta o contador da linha.
  1942.             iContadorLinha = 0;
  1943.         }
  1944.  
  1945.         time(&tempoInicial);
  1946.     }
  1947.  
  1948.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  1949.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  1950.     // que há linhas ainda não gravadas.
  1951.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  1952.     // iContadorLinha é sempre 1 a mais
  1953.     if(iContadorLinha != 0)
  1954.     {
  1955.         *pt = '\0';
  1956.         char szTemp[20];
  1957.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  1958.  
  1959.         char szArquivo[1024];
  1960.         char *ptArquivo = szArquivo;
  1961.         *ptArquivo = '\0';
  1962.         strcat(ptArquivo, "/mnt/Gerador_de_Palavras/keno_arq_");
  1963.         ptArquivo = strchr(szArquivo, '\0');
  1964.  
  1965.         iContadorArquivo++;
  1966.         sprintf(ptArquivo, "%.10d", iContadorArquivo);
  1967.         strcat(ptArquivo, "_inicio_");
  1968.         strcat(ptArquivo, szTemp);
  1969.         strcat(ptArquivo, "_fim_");
  1970.  
  1971.         time(&tempoFinal);
  1972.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  1973.         strcat(ptArquivo, szTemp);
  1974.         strcat(ptArquivo, ".txt");
  1975.  
  1976.  
  1977.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  1978.         FILE * fArquivo = fopen(szArquivo, "w");
  1979.         if(!fArquivo)
  1980.         {
  1981.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  1982.             perror("Erro foi: ");
  1983.             return -1;
  1984.         }
  1985.  
  1986.         printf("Gravando...\t");
  1987.  
  1988.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  1989.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  1990.         fclose(fArquivo);
  1991.  
  1992.         printf("Gravado.\n\n");
  1993.  
  1994.         // Reseta o contador da linha.
  1995.         iContadorLinha = 0;
  1996.     }
  1997.  
  1998.     time(&tempoInicial);
  1999.  
  2000.     printf("Executado com sucesso!!!");
  2001.  
  2002.     return 0;
  2003. }
  2004.  
  2005.  
  2006.  
  2007. int GerarLotomania()
  2008. {
  2009.     const int QT_PALAVRAS = 1000000;
  2010.     const int MENOR_BOLA = 0;
  2011.     const int MAIOR_BOLA = 99;
  2012.  
  2013.  
  2014.     int iContadorArquivo = 0;
  2015.     int iContadorLinha = 0;
  2016.  
  2017.  
  2018.     time_t tempoInicial, tempoFinal;
  2019.     tempoInicial = time(&tempoInicial);
  2020.  
  2021.     // Vamos calcular cada linha, cada linha está neste formato:
  2022.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  2023.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  2024. //    int iQuantidade = strlen("LOTOMANIA;50;_01_02_03_04_05_06_07_08_09_10"
  2025. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  2026. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  2027. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  2028. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  2029. //                             ";01;02;03;04;05;06;07;08;09;10"
  2030. //                            ) + 1;
  2031.  
  2032.     int iQuantidade = strlen("LOTOMANIA;50;;00"
  2033. //                             "_00"
  2034. //                             "_01_02_03_04_05_06_07_08_09_10"
  2035. //                             "_11_12_13_14_15_16_17_18_19_20"
  2036. //                             "_21_22_23_24_25_26_27_28_29_30"
  2037. //                             "_31_32_33_34_35_36_37_38_39_40"
  2038. //                             "_41_42_43_44_45_46_47_48_49;00"
  2039.                              ";01;02;03;04;05;06;07;08;09;10"
  2040.                              ";11;12;13;14;15;16;17;18;19;20"
  2041.                              ";21;22;23;24;25;26;27;28;29;30"
  2042.                              ";31;32;33;34;35;36;37;38;39;40"
  2043.                              ";41;42;43;44;45;46;47;48;49") + 1;
  2044.  
  2045.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  2046.     // iremos alocar primeiramente este espaço.
  2047.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * 1000000);
  2048.  
  2049.     // Vamos verificar se foi possível alocar.
  2050.     if(!szTodasLinhas)
  2051.     {
  2052.         fprintf(stderr, "Não foi possível alocar a memória.\n");
  2053.         exit(-3);
  2054.     }
  2055.  
  2056.  
  2057.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * 1000000);
  2058.  
  2059.     // Agora, iremos, alocar um ponteiro para ponteiro.
  2060.     char **szLinhas = (char**)malloc(sizeof(char*)* 1000000);
  2061.  
  2062. //    char *ptTeste = szLinhas[0];
  2063.  
  2064.     // Agora, vamos apontar cada ponteiro.
  2065.     for(int iA = 0; iA < 1000000; iA++)
  2066.     {
  2067.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  2068.     }
  2069.  
  2070.     char *pt = NULL;
  2071.  
  2072.     for(int uA = 0; uA <= MAIOR_BOLA; uA++)
  2073.     for(int uB = uA + 1; uB <= MAIOR_BOLA; uB++)
  2074.     for(int uC = uB + 1; uC <= MAIOR_BOLA; uC++)
  2075.     for(int uD = uC + 1; uD <= MAIOR_BOLA; uD++)
  2076.     for(int uE = uD + 1; uE <= MAIOR_BOLA; uE++)
  2077.     for(int uF = uE + 1; uF <= MAIOR_BOLA; uF++)
  2078.     for(int uG = uF + 1; uG <= MAIOR_BOLA; uG++)
  2079.     for(int uH = uG + 1; uH <= MAIOR_BOLA; uH++)
  2080.     for(int uI = uH + 1; uI <= MAIOR_BOLA; uI++)
  2081.     for(int uJ = uI + 1; uJ <= MAIOR_BOLA; uJ++)
  2082.     for(int uK = uJ + 1; uK <= MAIOR_BOLA; uK++)
  2083.     for(int uL = uK + 1; uL <= MAIOR_BOLA; uL++)
  2084.     for(int uM = uL + 1; uM <= MAIOR_BOLA; uM++)
  2085.     for(int uN = uM + 1; uN <= MAIOR_BOLA; uN++)
  2086.     for(int uO = uN + 1; uO <= MAIOR_BOLA; uO++)
  2087.     for(int uP = uO + 1; uP <= MAIOR_BOLA; uP++)
  2088.     for(int uQ = uP + 1; uQ <= MAIOR_BOLA; uQ++)
  2089.     for(int uR = uQ + 1; uR <= MAIOR_BOLA; uR++)
  2090.     for(int uS = uR + 1; uS <= MAIOR_BOLA; uS++)
  2091.     for(int uT = uS + 1; uT <= MAIOR_BOLA; uT++)
  2092.     for(int uU = uT + 1; uU <= MAIOR_BOLA; uU++)
  2093.     for(int uV = uU + 1; uV <= MAIOR_BOLA; uV++)
  2094.     for(int uW = uV + 1; uW <= MAIOR_BOLA; uW++)
  2095.     for(int uX = uW + 1; uX <= MAIOR_BOLA; uX++)
  2096.     for(int uY = uX + 1; uY <= MAIOR_BOLA; uY++)
  2097.     for(int uZ = uY + 1; uZ <= MAIOR_BOLA; uZ++)
  2098.     for(int uAA = uZ + 1; uAA <= MAIOR_BOLA; uAA++)
  2099.     for(int uBB = uAA + 1; uBB <= MAIOR_BOLA; uBB++)
  2100.     for(int uCC = uBB + 1; uCC <= MAIOR_BOLA; uCC++)
  2101.     for(int uDD = uCC + 1; uDD <= MAIOR_BOLA; uDD++)
  2102.     for(int uEE = uDD + 1; uEE <= MAIOR_BOLA; uEE++)
  2103.     for(int uFF = uEE + 1; uFF <= MAIOR_BOLA; uFF++)
  2104.     for(int uGG = uFF + 1; uGG <= MAIOR_BOLA; uGG++)
  2105.     for(int uHH = uGG + 1; uHH <= MAIOR_BOLA; uHH++)
  2106.     for(int uII = uHH + 1; uII <= MAIOR_BOLA; uII++)
  2107.     for(int uJJ = uII + 1; uJJ <= MAIOR_BOLA; uJJ++)
  2108.     for(int uKK = uJJ + 1; uKK <= MAIOR_BOLA; uKK++)
  2109.     for(int uLL = uKK + 1; uLL <= MAIOR_BOLA; uLL++)
  2110.     for(int uMM = uLL + 1; uMM <= MAIOR_BOLA; uMM++)
  2111.     for(int uNN = uMM + 1; uNN <= MAIOR_BOLA; uNN++)
  2112.     for(int uOO = uNN + 1; uOO <= MAIOR_BOLA; uOO++)
  2113.     for(int uPP = uOO + 1; uPP <= MAIOR_BOLA; uPP++)
  2114.     for(int uQQ = uPP + 1; uQQ <= MAIOR_BOLA; uQQ++)
  2115.     for(int uRR = uQQ + 1; uRR <= MAIOR_BOLA; uRR++)
  2116.     for(int uSS = uRR + 1; uSS <= MAIOR_BOLA; uSS++)
  2117.     for(int uTT = uSS + 1; uTT <= MAIOR_BOLA; uTT++)
  2118.     for(int uUU = uTT + 1; uUU <= MAIOR_BOLA; uUU++)
  2119.     for(int uVV = uUU + 1; uVV <= MAIOR_BOLA; uVV++)
  2120.     for(int uWW = uVV + 1; uWW <= MAIOR_BOLA; uWW++)
  2121.     for(int uXX = uWW + 1; uXX <= MAIOR_BOLA; uXX++)
  2122.  
  2123.  
  2124.  
  2125.     {
  2126.         char *pt = &szLinhas[iContadorLinha][0];
  2127. //        char *ptUm = &szLinhas[iContadorLinha][0];
  2128.  
  2129.         // Devemos definir o primeiro caractere nulo.
  2130.         // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  2131.         // o arranjo várias vezes.
  2132.         *pt = '\0';
  2133.  
  2134.         strncat(pt, "LOTOMANIA;50;", 13);
  2135.  
  2136.         pt += 13;
  2137.  
  2138.         *pt++ = szNumeroCSV[uA][0]; *pt++ = szNumeroCSV[uA][1]; *pt++ = szNumeroCSV[uA][2];
  2139.         *pt++ = szNumeroCSV[uB][0]; *pt++ = szNumeroCSV[uB][1]; *pt++ = szNumeroCSV[uB][2];
  2140.         *pt++ = szNumeroCSV[uC][0]; *pt++ = szNumeroCSV[uC][1]; *pt++ = szNumeroCSV[uC][2];
  2141.         *pt++ = szNumeroCSV[uD][0]; *pt++ = szNumeroCSV[uD][1]; *pt++ = szNumeroCSV[uD][2];
  2142.         *pt++ = szNumeroCSV[uE][0]; *pt++ = szNumeroCSV[uE][1]; *pt++ = szNumeroCSV[uE][2];
  2143.         *pt++ = szNumeroCSV[uF][0]; *pt++ = szNumeroCSV[uF][1]; *pt++ = szNumeroCSV[uF][2];
  2144.         *pt++ = szNumeroCSV[uG][0]; *pt++ = szNumeroCSV[uG][1]; *pt++ = szNumeroCSV[uG][2];
  2145.         *pt++ = szNumeroCSV[uH][0]; *pt++ = szNumeroCSV[uH][1]; *pt++ = szNumeroCSV[uH][2];
  2146.         *pt++ = szNumeroCSV[uI][0]; *pt++ = szNumeroCSV[uI][1]; *pt++ = szNumeroCSV[uI][2];
  2147.         *pt++ = szNumeroCSV[uJ][0]; *pt++ = szNumeroCSV[uJ][1]; *pt++ = szNumeroCSV[uJ][2];
  2148.         *pt++ = szNumeroCSV[uK][0]; *pt++ = szNumeroCSV[uK][1]; *pt++ = szNumeroCSV[uK][2];
  2149.         *pt++ = szNumeroCSV[uL][0]; *pt++ = szNumeroCSV[uL][1]; *pt++ = szNumeroCSV[uL][2];
  2150.         *pt++ = szNumeroCSV[uM][0]; *pt++ = szNumeroCSV[uM][1]; *pt++ = szNumeroCSV[uM][2];
  2151.         *pt++ = szNumeroCSV[uN][0]; *pt++ = szNumeroCSV[uN][1]; *pt++ = szNumeroCSV[uN][2];
  2152.         *pt++ = szNumeroCSV[uO][0]; *pt++ = szNumeroCSV[uO][1]; *pt++ = szNumeroCSV[uO][2];
  2153.         *pt++ = szNumeroCSV[uP][0]; *pt++ = szNumeroCSV[uP][1]; *pt++ = szNumeroCSV[uP][2];
  2154.         *pt++ = szNumeroCSV[uQ][0]; *pt++ = szNumeroCSV[uQ][1]; *pt++ = szNumeroCSV[uQ][2];
  2155.         *pt++ = szNumeroCSV[uR][0]; *pt++ = szNumeroCSV[uR][1]; *pt++ = szNumeroCSV[uR][2];
  2156.         *pt++ = szNumeroCSV[uS][0]; *pt++ = szNumeroCSV[uS][1]; *pt++ = szNumeroCSV[uS][2];
  2157.         *pt++ = szNumeroCSV[uT][0]; *pt++ = szNumeroCSV[uT][1]; *pt++ = szNumeroCSV[uT][2];
  2158.         *pt++ = szNumeroCSV[uU][0]; *pt++ = szNumeroCSV[uU][1]; *pt++ = szNumeroCSV[uU][2];
  2159.         *pt++ = szNumeroCSV[uV][0]; *pt++ = szNumeroCSV[uV][1]; *pt++ = szNumeroCSV[uV][2];
  2160.         *pt++ = szNumeroCSV[uW][0]; *pt++ = szNumeroCSV[uW][1]; *pt++ = szNumeroCSV[uW][2];
  2161.         *pt++ = szNumeroCSV[uX][0]; *pt++ = szNumeroCSV[uX][1]; *pt++ = szNumeroCSV[uX][2];
  2162.         *pt++ = szNumeroCSV[uY][0]; *pt++ = szNumeroCSV[uY][1]; *pt++ = szNumeroCSV[uY][2];
  2163.         *pt++ = szNumeroCSV[uZ][0]; *pt++ = szNumeroCSV[uZ][1]; *pt++ = szNumeroCSV[uZ][2];
  2164.         *pt++ = szNumeroCSV[uAA][0];    *pt++ = szNumeroCSV[uAA][1];    *pt++ = szNumeroCSV[uAA][2];
  2165.         *pt++ = szNumeroCSV[uBB][0];    *pt++ = szNumeroCSV[uBB][1];    *pt++ = szNumeroCSV[uBB][2];
  2166.         *pt++ = szNumeroCSV[uCC][0];    *pt++ = szNumeroCSV[uCC][1];    *pt++ = szNumeroCSV[uCC][2];
  2167.         *pt++ = szNumeroCSV[uDD][0];    *pt++ = szNumeroCSV[uDD][1];    *pt++ = szNumeroCSV[uDD][2];
  2168.         *pt++ = szNumeroCSV[uEE][0];    *pt++ = szNumeroCSV[uEE][1];    *pt++ = szNumeroCSV[uEE][2];
  2169.         *pt++ = szNumeroCSV[uFF][0];    *pt++ = szNumeroCSV[uFF][1];    *pt++ = szNumeroCSV[uFF][2];
  2170.         *pt++ = szNumeroCSV[uGG][0];    *pt++ = szNumeroCSV[uGG][1];    *pt++ = szNumeroCSV[uGG][2];
  2171.         *pt++ = szNumeroCSV[uHH][0];    *pt++ = szNumeroCSV[uHH][1];    *pt++ = szNumeroCSV[uHH][2];
  2172.         *pt++ = szNumeroCSV[uII][0];    *pt++ = szNumeroCSV[uII][1];    *pt++ = szNumeroCSV[uII][2];
  2173.         *pt++ = szNumeroCSV[uJJ][0];    *pt++ = szNumeroCSV[uJJ][1];    *pt++ = szNumeroCSV[uJJ][2];
  2174.         *pt++ = szNumeroCSV[uKK][0];    *pt++ = szNumeroCSV[uKK][1];    *pt++ = szNumeroCSV[uKK][2];
  2175.         *pt++ = szNumeroCSV[uLL][0];    *pt++ = szNumeroCSV[uLL][1];    *pt++ = szNumeroCSV[uLL][2];
  2176.         *pt++ = szNumeroCSV[uMM][0];    *pt++ = szNumeroCSV[uMM][1];    *pt++ = szNumeroCSV[uMM][2];
  2177.         *pt++ = szNumeroCSV[uNN][0];    *pt++ = szNumeroCSV[uNN][1];    *pt++ = szNumeroCSV[uNN][2];
  2178.         *pt++ = szNumeroCSV[uOO][0];    *pt++ = szNumeroCSV[uOO][1];    *pt++ = szNumeroCSV[uOO][2];
  2179.         *pt++ = szNumeroCSV[uPP][0];    *pt++ = szNumeroCSV[uPP][1];    *pt++ = szNumeroCSV[uPP][2];
  2180.         *pt++ = szNumeroCSV[uQQ][0];    *pt++ = szNumeroCSV[uQQ][1];    *pt++ = szNumeroCSV[uQQ][2];
  2181.         *pt++ = szNumeroCSV[uRR][0];    *pt++ = szNumeroCSV[uRR][1];    *pt++ = szNumeroCSV[uRR][2];
  2182.         *pt++ = szNumeroCSV[uSS][0];    *pt++ = szNumeroCSV[uSS][1];    *pt++ = szNumeroCSV[uSS][2];
  2183.         *pt++ = szNumeroCSV[uTT][0];    *pt++ = szNumeroCSV[uTT][1];    *pt++ = szNumeroCSV[uTT][2];
  2184.         *pt++ = szNumeroCSV[uUU][0];    *pt++ = szNumeroCSV[uUU][1];    *pt++ = szNumeroCSV[uUU][2];
  2185.         *pt++ = szNumeroCSV[uVV][0];    *pt++ = szNumeroCSV[uVV][1];    *pt++ = szNumeroCSV[uVV][2];
  2186.         *pt++ = szNumeroCSV[uWW][0];    *pt++ = szNumeroCSV[uWW][1];    *pt++ = szNumeroCSV[uWW][2];
  2187.         *pt++ = szNumeroCSV[uXX][0];    *pt++ = szNumeroCSV[uXX][1];    *pt++ = szNumeroCSV[uXX][2];
  2188.  
  2189.         *pt++ = '\n';
  2190.  
  2191.  
  2192.         iContadorLinha++;
  2193.  
  2194.         if(iContadorLinha==1000000)
  2195.         {
  2196.             // Evita que a última linha gere um caractere de nova linha.
  2197.             *(--pt) = '\0';
  2198.  
  2199.             char szTemp[20];
  2200.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  2201.  
  2202.             char szArquivo[1024];
  2203.             char *ptArquivo = szArquivo;
  2204.             *ptArquivo = '\0';
  2205.             strcat(ptArquivo, "/mnt/Gerador_de_Palavras/lotomania_arq_");
  2206.             ptArquivo = strchr(szArquivo, '\0');
  2207.  
  2208.             iContadorArquivo++;
  2209.             sprintf(ptArquivo, "%.10d", iContadorArquivo);
  2210.             strcat(ptArquivo, "_inicio_");
  2211.             strcat(ptArquivo, szTemp);
  2212.             strcat(ptArquivo, "_fim_");
  2213.  
  2214.             time(&tempoFinal);
  2215.             strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  2216.             strcat(ptArquivo, szTemp);
  2217.             strcat(ptArquivo, ".txt");
  2218.  
  2219.  
  2220.             printf("Abrindo arquivo:\n%s\n", szArquivo);
  2221.             FILE * fArquivo = fopen(szArquivo, "w");
  2222.             if(!fArquivo)
  2223.             {
  2224.                 fprintf(stderr, "Erro ao abrir arquivo.\n");
  2225.                 perror("Erro foi: ");
  2226.                 return -1;
  2227.             }
  2228.  
  2229.             printf("Gravando...\t");
  2230.  
  2231.             for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  2232.                 fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  2233.             fclose(fArquivo);
  2234.  
  2235.             printf("Gravado.\n\n");
  2236.  
  2237.             // Reseta o contador da linha.
  2238.             iContadorLinha = 0;
  2239.         }
  2240.  
  2241.         time(&tempoInicial);
  2242.     }
  2243.  
  2244.     // Toda vez que uma nova linha é gerada, iContadorLinha é incrementado.
  2245.     // Se ao final do loop, iContadorLinha for diferente de zero, quer dizer
  2246.     // que há linhas ainda não gravadas.
  2247.     // Então, iremos gravar da linha 0, até iContadorLinha - 1, pois
  2248.     // iContadorLinha é sempre 1 a mais
  2249.     if(iContadorLinha != 0)
  2250.     {
  2251.         *pt = '\0';
  2252.         char szTemp[20];
  2253.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  2254.  
  2255.         char szArquivo[1024];
  2256.         char *ptArquivo = szArquivo;
  2257.         *ptArquivo = '\0';
  2258.         strcat(ptArquivo, "/mnt/Gerador_de_Palavras/lotomania_arq_");
  2259.         ptArquivo = strchr(szArquivo, '\0');
  2260.  
  2261.         iContadorArquivo++;
  2262.         sprintf(ptArquivo, "%.10d", iContadorArquivo);
  2263.         strcat(ptArquivo, "_inicio_");
  2264.         strcat(ptArquivo, szTemp);
  2265.         strcat(ptArquivo, "_fim_");
  2266.  
  2267.         time(&tempoFinal);
  2268.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  2269.         strcat(ptArquivo, szTemp);
  2270.         strcat(ptArquivo, ".txt");
  2271.  
  2272.  
  2273.         printf("Abrindo arquivo:\n%s\n", szArquivo);
  2274.         FILE * fArquivo = fopen(szArquivo, "w");
  2275.         if(!fArquivo)
  2276.         {
  2277.             fprintf(stderr, "Erro ao abrir arquivo.\n");
  2278.             perror("Erro foi: ");
  2279.             return -1;
  2280.         }
  2281.  
  2282.         printf("Gravando...\t");
  2283.  
  2284.         for(int uLinha = 0; uLinha < iContadorLinha; uLinha++)
  2285.             fwrite(&szLinhas[uLinha][0], iQuantidade, 1, fArquivo);
  2286.         fclose(fArquivo);
  2287.  
  2288.         printf("Gravado.\n\n");
  2289.  
  2290.         // Reseta o contador da linha.
  2291.         iContadorLinha = 0;
  2292.     }
  2293.  
  2294.     time(&tempoInicial);
  2295.  
  2296.     printf("Executado com sucesso!!!");
  2297.  
  2298.     return 0;
  2299. }
  2300.  
  2301. int GerarLotomania_2()
  2302. {
  2303.     const int QT_PALAVRAS = 50000000;
  2304.     const int MENOR_BOLA = 0;
  2305.     const int MAIOR_BOLA = 99;
  2306.  
  2307.  
  2308.     int iContadorArquivo = 0;
  2309.     int iContadorLinha = 0;
  2310.  
  2311.  
  2312.     time_t tempoInicial, tempoFinal;
  2313.     tempoInicial = time(&tempoInicial);
  2314.  
  2315.     // Vamos calcular cada linha, cada linha está neste formato:
  2316.     // QUINA;7;_01_02_03_04_05_06_07;01;02;03;04;05;06;07
  2317.     // Haverá mais 1 caractere para o caractere nulo ou carriage return.
  2318. //    int iQuantidade = strlen("LOTOMANIA;50;_01_02_03_04_05_06_07_08_09_10"
  2319. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  2320. //                             "_01_02_03_04_05_06_07_08_09_10_01_02_03_04_05_06_07_08_09_10"
  2321. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  2322. //                             ";01;02;03;04;05;06;07;08;09;10;01;02;03;04;05;06;07;08;09;10"
  2323. //                             ";01;02;03;04;05;06;07;08;09;10"
  2324. //                            ) + 1;
  2325.  
  2326.     int iQuantidade = strlen("LOTOMANIA;50;;00"
  2327. //                             "_00"
  2328. //                             "_01_02_03_04_05_06_07_08_09_10"
  2329. //                             "_11_12_13_14_15_16_17_18_19_20"
  2330. //                             "_21_22_23_24_25_26_27_28_29_30"
  2331. //                             "_31_32_33_34_35_36_37_38_39_40"
  2332. //                             "_41_42_43_44_45_46_47_48_49;00"
  2333.                              ";01;02;03;04;05;06;07;08;09;10"
  2334.                              ";11;12;13;14;15;16;17;18;19;20"
  2335.                              ";21;22;23;24;25;26;27;28;29;30"
  2336.                              ";31;32;33;34;35;36;37;38;39;40"
  2337.                              ";41;42;43;44;45;46;47;48;49") + 1;
  2338.  
  2339.     // Haverá um total de 1 milhão de linhas, com cada linha tendo 52 caracteres, então,
  2340.     // iremos alocar primeiramente este espaço.
  2341.     char *szTodasLinhas = (char*)malloc(sizeof(char)* iQuantidade * QT_PALAVRAS);
  2342.  
  2343.     // Vamos verificar se foi possível alocar.
  2344.     if(!szTodasLinhas)
  2345.     {
  2346.         fprintf(stderr, "Não foi possível alocar a memória.\n");
  2347.         exit(-3);
  2348.     }
  2349.  
  2350.  
  2351.     memset(szTodasLinhas, '\0', sizeof(char)* iQuantidade * QT_PALAVRAS);
  2352.  
  2353.     // Agora, iremos, alocar um ponteiro para ponteiro.
  2354.     char **szLinhas = (char**)malloc(sizeof(char*)* QT_PALAVRAS);
  2355.  
  2356. //    char *ptTeste = szLinhas[0];
  2357.  
  2358.     // Agora, vamos apontar cada ponteiro.
  2359.     for(int iA = 0; iA < QT_PALAVRAS; iA++)
  2360.     {
  2361.         szLinhas[iA] = szTodasLinhas + iA * iQuantidade;
  2362.     }
  2363.  
  2364.     //char *pt = NULL;
  2365.     char szTemp[20];
  2366.  
  2367.     for(int uA = 0; uA <= MAIOR_BOLA; uA++)
  2368.     for(int uB = uA + 1; uB <= MAIOR_BOLA; uB++)
  2369.     for(int uC = uB + 1; uC <= MAIOR_BOLA; uC++)
  2370.     for(int uD = uC + 1; uD <= MAIOR_BOLA; uD++)
  2371.     for(int uE = uD + 1; uE <= MAIOR_BOLA; uE++)
  2372.     for(int uF = uE + 1; uF <= MAIOR_BOLA; uF++)
  2373.     for(int uG = uF + 1; uG <= MAIOR_BOLA; uG++)
  2374.     for(int uH = uG + 1; uH <= MAIOR_BOLA; uH++)
  2375.     for(int uI = uH + 1; uI <= MAIOR_BOLA; uI++)
  2376.     for(int uJ = uI + 1; uJ <= MAIOR_BOLA; uJ++)
  2377.     for(int uK = uJ + 1; uK <= MAIOR_BOLA; uK++)
  2378.     for(int uL = uK + 1; uL <= MAIOR_BOLA; uL++)
  2379.     for(int uM = uL + 1; uM <= MAIOR_BOLA; uM++)
  2380.     for(int uN = uM + 1; uN <= MAIOR_BOLA; uN++)
  2381.     for(int uO = uN + 1; uO <= MAIOR_BOLA; uO++)
  2382.     for(int uP = uO + 1; uP <= MAIOR_BOLA; uP++)
  2383.     for(int uQ = uP + 1; uQ <= MAIOR_BOLA; uQ++)
  2384.     for(int uR = uQ + 1; uR <= MAIOR_BOLA; uR++)
  2385.     for(int uS = uR + 1; uS <= MAIOR_BOLA; uS++)
  2386.     for(int uT = uS + 1; uT <= MAIOR_BOLA; uT++)
  2387.     for(int uU = uT + 1; uU <= MAIOR_BOLA; uU++)
  2388.     for(int uV = uU + 1; uV <= MAIOR_BOLA; uV++)
  2389.     for(int uW = uV + 1; uW <= MAIOR_BOLA; uW++)
  2390.     for(int uX = uW + 1; uX <= MAIOR_BOLA; uX++)
  2391.     for(int uY = uX + 1; uY <= MAIOR_BOLA; uY++)
  2392.     for(int uZ = uY + 1; uZ <= MAIOR_BOLA; uZ++)
  2393.     for(int uAA = uZ + 1; uAA <= MAIOR_BOLA; uAA++)
  2394.     for(int uBB = uAA + 1; uBB <= MAIOR_BOLA; uBB++)
  2395.     for(int uCC = uBB + 1; uCC <= MAIOR_BOLA; uCC++)
  2396.     for(int uDD = uCC + 1; uDD <= MAIOR_BOLA; uDD++)
  2397.     for(int uEE = uDD + 1; uEE <= MAIOR_BOLA; uEE++)
  2398.     for(int uFF = uEE + 1; uFF <= MAIOR_BOLA; uFF++)
  2399.     for(int uGG = uFF + 1; uGG <= MAIOR_BOLA; uGG++)
  2400.     for(int uHH = uGG + 1; uHH <= MAIOR_BOLA; uHH++)
  2401.     for(int uII = uHH + 1; uII <= MAIOR_BOLA; uII++)
  2402.     for(int uJJ = uII + 1; uJJ <= MAIOR_BOLA; uJJ++)
  2403.     for(int uKK = uJJ + 1; uKK <= MAIOR_BOLA; uKK++)
  2404.     for(int uLL = uKK + 1; uLL <= MAIOR_BOLA; uLL++)
  2405.     for(int uMM = uLL + 1; uMM <= MAIOR_BOLA; uMM++)
  2406.     for(int uNN = uMM + 1; uNN <= MAIOR_BOLA; uNN++)
  2407.     for(int uOO = uNN + 1; uOO <= MAIOR_BOLA; uOO++)
  2408.     for(int uPP = uOO + 1; uPP <= MAIOR_BOLA; uPP++)
  2409.     for(int uQQ = uPP + 1; uQQ <= MAIOR_BOLA; uQQ++)
  2410.     for(int uRR = uQQ + 1; uRR <= MAIOR_BOLA; uRR++)
  2411.     for(int uSS = uRR + 1; uSS <= MAIOR_BOLA; uSS++)
  2412.     for(int uTT = uSS + 1; uTT <= MAIOR_BOLA; uTT++)
  2413.     for(int uUU = uTT + 1; uUU <= MAIOR_BOLA; uUU++)
  2414.     for(int uVV = uUU + 1; uVV <= MAIOR_BOLA; uVV++)
  2415.     for(int uWW = uVV + 1; uWW <= MAIOR_BOLA; uWW++)
  2416.     for(int uXX = uWW + 1; uXX <= MAIOR_BOLA; uXX++)
  2417.  
  2418.  
  2419.  
  2420.     {
  2421.         char *pt = &szLinhas[iContadorLinha][0];
  2422. //        char *ptUm = &szLinhas[iContadorLinha][0];
  2423.  
  2424.  
  2425.         strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoInicial));
  2426.  
  2427.         // Devemos definir o primeiro caractere nulo.
  2428.         // Senão strcat, vai continuar de onde parou, pois reutilizaremos
  2429.         // o arranjo várias vezes.
  2430.         *pt = '\0';
  2431.  
  2432.         strncat(pt, "LOTOMANIA;50;", 13);
  2433.  
  2434.         pt += 13;
  2435.  
  2436.         *pt++ = szNumeroCSV[uA][0]; *pt++ = szNumeroCSV[uA][1]; *pt++ = szNumeroCSV[uA][2];
  2437.         *pt++ = szNumeroCSV[uB][0]; *pt++ = szNumeroCSV[uB][1]; *pt++ = szNumeroCSV[uB][2];
  2438.         *pt++ = szNumeroCSV[uC][0]; *pt++ = szNumeroCSV[uC][1]; *pt++ = szNumeroCSV[uC][2];
  2439.         *pt++ = szNumeroCSV[uD][0]; *pt++ = szNumeroCSV[uD][1]; *pt++ = szNumeroCSV[uD][2];
  2440.         *pt++ = szNumeroCSV[uE][0]; *pt++ = szNumeroCSV[uE][1]; *pt++ = szNumeroCSV[uE][2];
  2441.         *pt++ = szNumeroCSV[uF][0]; *pt++ = szNumeroCSV[uF][1]; *pt++ = szNumeroCSV[uF][2];
  2442.         *pt++ = szNumeroCSV[uG][0]; *pt++ = szNumeroCSV[uG][1]; *pt++ = szNumeroCSV[uG][2];
  2443.         *pt++ = szNumeroCSV[uH][0]; *pt++ = szNumeroCSV[uH][1]; *pt++ = szNumeroCSV[uH][2];
  2444.         *pt++ = szNumeroCSV[uI][0]; *pt++ = szNumeroCSV[uI][1]; *pt++ = szNumeroCSV[uI][2];
  2445.         *pt++ = szNumeroCSV[uJ][0]; *pt++ = szNumeroCSV[uJ][1]; *pt++ = szNumeroCSV[uJ][2];
  2446.         *pt++ = szNumeroCSV[uK][0]; *pt++ = szNumeroCSV[uK][1]; *pt++ = szNumeroCSV[uK][2];
  2447.         *pt++ = szNumeroCSV[uL][0]; *pt++ = szNumeroCSV[uL][1]; *pt++ = szNumeroCSV[uL][2];
  2448.         *pt++ = szNumeroCSV[uM][0]; *pt++ = szNumeroCSV[uM][1]; *pt++ = szNumeroCSV[uM][2];
  2449.         *pt++ = szNumeroCSV[uN][0]; *pt++ = szNumeroCSV[uN][1]; *pt++ = szNumeroCSV[uN][2];
  2450.         *pt++ = szNumeroCSV[uO][0]; *pt++ = szNumeroCSV[uO][1]; *pt++ = szNumeroCSV[uO][2];
  2451.         *pt++ = szNumeroCSV[uP][0]; *pt++ = szNumeroCSV[uP][1]; *pt++ = szNumeroCSV[uP][2];
  2452.         *pt++ = szNumeroCSV[uQ][0]; *pt++ = szNumeroCSV[uQ][1]; *pt++ = szNumeroCSV[uQ][2];
  2453.         *pt++ = szNumeroCSV[uR][0]; *pt++ = szNumeroCSV[uR][1]; *pt++ = szNumeroCSV[uR][2];
  2454.         *pt++ = szNumeroCSV[uS][0]; *pt++ = szNumeroCSV[uS][1]; *pt++ = szNumeroCSV[uS][2];
  2455.         *pt++ = szNumeroCSV[uT][0]; *pt++ = szNumeroCSV[uT][1]; *pt++ = szNumeroCSV[uT][2];
  2456.         *pt++ = szNumeroCSV[uU][0]; *pt++ = szNumeroCSV[uU][1]; *pt++ = szNumeroCSV[uU][2];
  2457.         *pt++ = szNumeroCSV[uV][0]; *pt++ = szNumeroCSV[uV][1]; *pt++ = szNumeroCSV[uV][2];
  2458.         *pt++ = szNumeroCSV[uW][0]; *pt++ = szNumeroCSV[uW][1]; *pt++ = szNumeroCSV[uW][2];
  2459.         *pt++ = szNumeroCSV[uX][0]; *pt++ = szNumeroCSV[uX][1]; *pt++ = szNumeroCSV[uX][2];
  2460.         *pt++ = szNumeroCSV[uY][0]; *pt++ = szNumeroCSV[uY][1]; *pt++ = szNumeroCSV[uY][2];
  2461.         *pt++ = szNumeroCSV[uZ][0]; *pt++ = szNumeroCSV[uZ][1]; *pt++ = szNumeroCSV[uZ][2];
  2462.         *pt++ = szNumeroCSV[uAA][0];    *pt++ = szNumeroCSV[uAA][1];    *pt++ = szNumeroCSV[uAA][2];
  2463.         *pt++ = szNumeroCSV[uBB][0];    *pt++ = szNumeroCSV[uBB][1];    *pt++ = szNumeroCSV[uBB][2];
  2464.         *pt++ = szNumeroCSV[uCC][0];    *pt++ = szNumeroCSV[uCC][1];    *pt++ = szNumeroCSV[uCC][2];
  2465.         *pt++ = szNumeroCSV[uDD][0];    *pt++ = szNumeroCSV[uDD][1];    *pt++ = szNumeroCSV[uDD][2];
  2466.         *pt++ = szNumeroCSV[uEE][0];    *pt++ = szNumeroCSV[uEE][1];    *pt++ = szNumeroCSV[uEE][2];
  2467.         *pt++ = szNumeroCSV[uFF][0];    *pt++ = szNumeroCSV[uFF][1];    *pt++ = szNumeroCSV[uFF][2];
  2468.         *pt++ = szNumeroCSV[uGG][0];    *pt++ = szNumeroCSV[uGG][1];    *pt++ = szNumeroCSV[uGG][2];
  2469.         *pt++ = szNumeroCSV[uHH][0];    *pt++ = szNumeroCSV[uHH][1];    *pt++ = szNumeroCSV[uHH][2];
  2470.         *pt++ = szNumeroCSV[uII][0];    *pt++ = szNumeroCSV[uII][1];    *pt++ = szNumeroCSV[uII][2];
  2471.         *pt++ = szNumeroCSV[uJJ][0];    *pt++ = szNumeroCSV[uJJ][1];    *pt++ = szNumeroCSV[uJJ][2];
  2472.         *pt++ = szNumeroCSV[uKK][0];    *pt++ = szNumeroCSV[uKK][1];    *pt++ = szNumeroCSV[uKK][2];
  2473.         *pt++ = szNumeroCSV[uLL][0];    *pt++ = szNumeroCSV[uLL][1];    *pt++ = szNumeroCSV[uLL][2];
  2474.         *pt++ = szNumeroCSV[uMM][0];    *pt++ = szNumeroCSV[uMM][1];    *pt++ = szNumeroCSV[uMM][2];
  2475.         *pt++ = szNumeroCSV[uNN][0];    *pt++ = szNumeroCSV[uNN][1];    *pt++ = szNumeroCSV[uNN][2];
  2476.         *pt++ = szNumeroCSV[uOO][0];    *pt++ = szNumeroCSV[uOO][1];    *pt++ = szNumeroCSV[uOO][2];
  2477.         *pt++ = szNumeroCSV[uPP][0];    *pt++ = szNumeroCSV[uPP][1];    *pt++ = szNumeroCSV[uPP][2];
  2478.         *pt++ = szNumeroCSV[uQQ][0];    *pt++ = szNumeroCSV[uQQ][1];    *pt++ = szNumeroCSV[uQQ][2];
  2479.         *pt++ = szNumeroCSV[uRR][0];    *pt++ = szNumeroCSV[uRR][1];    *pt++ = szNumeroCSV[uRR][2];
  2480.         *pt++ = szNumeroCSV[uSS][0];    *pt++ = szNumeroCSV[uSS][1];    *pt++ = szNumeroCSV[uSS][2];
  2481.         *pt++ = szNumeroCSV[uTT][0];    *pt++ = szNumeroCSV[uTT][1];    *pt++ = szNumeroCSV[uTT][2];
  2482.         *pt++ = szNumeroCSV[uUU][0];    *pt++ = szNumeroCSV[uUU][1];    *pt++ = szNumeroCSV[uUU][2];
  2483.         *pt++ = szNumeroCSV[uVV][0];    *pt++ = szNumeroCSV[uVV][1];    *pt++ = szNumeroCSV[uVV][2];
  2484.         *pt++ = szNumeroCSV[uWW][0];    *pt++ = szNumeroCSV[uWW][1];    *pt++ = szNumeroCSV[uWW][2];
  2485.         *pt++ = szNumeroCSV[uXX][0];    *pt++ = szNumeroCSV[uXX][1];    *pt++ = szNumeroCSV[uXX][2];
  2486.  
  2487.         *pt++ = '\0';
  2488.  
  2489.  
  2490.         iContadorLinha++;
  2491.         if(iContadorLinha == QT_PALAVRAS){
  2492.             for(iContadorLinha=0; iContadorLinha < QT_PALAVRAS; iContadorLinha++){
  2493.                 printf("%s\n", szLinhas[iContadorLinha]);
  2494.             }
  2495.  
  2496.             iContadorLinha = 0;
  2497.         }
  2498.  
  2499.         printf("%i\n", iContadorLinha);
  2500.     }
  2501.  
  2502.     printf("Tempo inicial: %s\n", szTemp);
  2503.     time(&tempoFinal);
  2504.     strftime(szTemp, 20, "%Y-%m-%d_%H-%M-%S", localtime(&tempoFinal));
  2505.     printf("Tempo final  : %s\n", szTemp);
  2506.  
  2507.     printf("Executado com sucesso!!!\n");
  2508.  
  2509.     return 0;
  2510. }
  2511.  
  2512.  
  2513. void Gerar_Palavras(
  2514.     const char *szCaracteres,
  2515.     size_t qt_caracteres_por_Palavra,
  2516.     )
  2517. {
  2518.         char *szTexto = calloc()
  2519. }
  2520.  
  2521.  
  2522.  
  2523.  
  2524. int main()
  2525. {
  2526.     //GerarPalavras();
  2527.     //GerarQuina5Numeros();
  2528.     //GerarDuplaSena7Numeros();
  2529.     //GerarPalavras2();
  2530.     //GerarQuina6Numeros();
  2531.     //GerarLotomania();
  2532.     //GerarKeno10Numeros();
  2533.     GerarLotomania_2();
  2534.  
  2535.     return 0;
  2536. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!