Advertisement
poczatkujacykoder

Untitled

Oct 23rd, 2014
179
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.75 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. int licznik;
  5. int co;
  6. int spr[15];
  7. int g;
  8. float t_wyniki[10];
  9. float wynik;
  10. int licznik;
  11. int to_multiply();
  12. int a, i, j, k, z, m, n;
  13. float liczba_znakow;
  14. char wybor;
  15.  
  16. int main(){
  17.  
  18.    
  19.  
  20.     char **tab2;
  21.     char *tab;
  22.  
  23.     fpos_t d;
  24.     FILE *file;
  25.     file = fopen("zaszyfrowane.txt", "r");
  26.     if (!file)
  27.         return -1;
  28.  
  29.     tab = ((char*)malloc(1000 * sizeof(char)));
  30.     if (!tab)
  31.         return -2;
  32.  
  33.     fseek(file, 0, SEEK_END);
  34.     fgetpos(file, &d);
  35.     fseek(file, 0, 0);
  36.     a = (int)d;
  37.  
  38.     printf("liczba bitow = %d", a);
  39.     fscanf(file, "%s", tab);
  40.  
  41. /*  printf("%s", tab);
  42.     printf("\n");*/
  43.     printf("\n");
  44.    
  45.     tab2 = ((char**)malloc(10 * sizeof(char*))); /**/
  46.     if (!tab2) return -1;
  47.  
  48.     for (i = 2; i < 11; i++)
  49.     {
  50.             printf("DLUGOSC KLUCZA : %d\n", i);
  51.                 for (j = 0; j < i; j++)
  52.                 {
  53.  
  54.                     tab2[j] = ((char*)malloc(a*sizeof(char))); if (!tab2) return -1;
  55.  
  56.                     m = 0;
  57.                     if (j>0)
  58.                         m = j;
  59.                     for (k = 0; k < (a / i); k++){
  60.                         tab2[j][k] = tab[m];
  61.                         m += i;
  62.                     }
  63.  
  64.                    
  65.                     /*  for (k = 0; k < (a / i); k++){
  66.    
  67.                         printf("%c", tab2[j][k]);
  68.                     }*/
  69.                    
  70.  
  71.                     //////////////////////////////////////// start kod
  72.                     if (j % 2 == 0) /// sprawdzam czy w tablicy jest parzysta liczba znakow czy nie
  73.                         liczba_znakow =(float) k;
  74.                     else
  75.                     {
  76.                         liczba_znakow =(float) k - 1;
  77.                     }
  78.  
  79.                     printf("liczba znakow = %.0f\n", liczba_znakow);
  80.  
  81.  
  82.  
  83.                     ///////////////////////////////////////////
  84.                     g = 0;
  85.                     licznik = 0;
  86.                     for (k = 0; k < liczba_znakow; k++)
  87.                     {
  88.                         if (tab2[j][k] == 'a')
  89.                             g++;
  90.                     }
  91.                         printf("a = %d\t", g);
  92.                         licznik += (g*(g - 1));
  93.                         printf("licz = %d\t", licznik);
  94.                         g = 0;
  95.                         /////
  96.  
  97.  
  98.                         for (k = 0; k < liczba_znakow; k++)
  99.                         {
  100.                             if (tab2[j][k] == 'b')
  101.                                 g++;
  102.                         }
  103.                         printf("b = %d\t", g);
  104.                         licznik += g*(g - 1);
  105.                         printf("licz = %d\t", licznik);
  106.                         g = 0;
  107.                         /////
  108.                         for (k = 0; k < liczba_znakow; k++)
  109.                         {
  110.                             if (tab2[j][k] == 'c')
  111.                                 g++;
  112.                         }
  113.                         printf("c = %d\t", g);
  114.                         licznik += g*(g - 1);
  115.                         printf("licz = %d\n", licznik);
  116.                         g = 0;
  117.                         /////
  118.                         for (k = 0; k < liczba_znakow; k++)
  119.                         {
  120.                             if (tab2[j][k] == 'd')
  121.                                 g++;
  122.                         }
  123.                         printf("d = %d\t", g);
  124.                         licznik += g*(g - 1);
  125.                         printf("licz = %d\t", licznik);
  126.                         g = 0;
  127.                         /////
  128.  
  129.  
  130.                         for (k = 0; k < liczba_znakow; k++)
  131.                         {
  132.                             if (tab2[j][k] == 'e')
  133.                                 g++;
  134.                         }
  135.                         printf("e = %d\t", g);
  136.                         licznik += g*(g - 1);
  137.                         printf("licz = %d\t", licznik);
  138.                         g = 0;
  139.                         /////
  140.                         for (k = 0; k < liczba_znakow; k++)
  141.                         {
  142.                             if (tab2[j][k] == 'f')
  143.                                 g++;
  144.                         }
  145.                         printf("f = %d\t", g);
  146.                         licznik += g*(g - 1);
  147.                         printf("licz = %d\n", licznik);
  148.                         g = 0;
  149.                         /////
  150.  
  151.                         for (k = 0; k < liczba_znakow; k++)
  152.                         {
  153.                             if (tab2[j][k] == 'g')
  154.                                 g++;
  155.                         }
  156.                         printf("g = %d\t", g);
  157.                         licznik += g*(g - 1);
  158.                         printf("licz = %d\t", licznik);
  159.                         g = 0;
  160.                         /////
  161.                         for (k = 0; k < liczba_znakow; k++)
  162.                         {
  163.                             if (tab2[j][k] == 'h')
  164.                                 g++;
  165.                         }
  166.                         printf("h = %d\t", g);
  167.                         licznik += g*(g - 1);
  168.                         printf("licz = %d\t", licznik);
  169.                         g = 0;
  170.                         /////
  171.                         for (k = 0; k < liczba_znakow; k++)
  172.                         {
  173.                             if (tab2[j][k] == 'i')
  174.                                 g++;
  175.                         }
  176.                         printf("i = %d\t", g);
  177.                         licznik += g*(g - 1);
  178.                         printf("licz= %d\n", licznik);
  179.                         g = 0;
  180.                         /////
  181.  
  182.  
  183.                         for (k = 0; k < liczba_znakow; k++)
  184.                         {
  185.                             if (tab2[j][k] == 'j')
  186.                                 g++;
  187.                         }
  188.                         printf("j = %d\t", g);
  189.                         licznik += g*(g - 1);
  190.                         printf("licz = %d\t", licznik);
  191.                         g = 0;
  192.                         /////
  193.                         for (k = 0; k < liczba_znakow; k++)
  194.                         {
  195.                             if (tab2[j][k] == 'k')
  196.                                 g++;
  197.                         }
  198.                         printf("k = %d\t", g);
  199.                         licznik += g*(g - 1);
  200.                         printf("licz = %d\t", licznik);
  201.                         g = 0;
  202.                         /////
  203.                         for (k = 0; k < liczba_znakow; k++)
  204.                         {
  205.                             if (tab2[j][k] == 'l')
  206.                                 g++;
  207.                         }
  208.                         printf("l = %d\t", g);
  209.                         licznik += g*(g - 1);
  210.                         printf("licz = %d\n", licznik);
  211.                         g = 0;
  212.                         /////
  213.                         for (k = 0; k < liczba_znakow; k++)
  214.                         {
  215.                             if (tab2[j][k] == 'm')
  216.                                 g++;
  217.                         }
  218.                         printf("m = %d\t", g);
  219.                         licznik += g*(g - 1);
  220.                         printf("licz = %d\t", licznik);
  221.                         g = 0;
  222.                         /////
  223.  
  224.  
  225.                         for (k = 0; k < liczba_znakow; k++)
  226.                         {
  227.                             if (tab2[j][k] == 'n')
  228.                                 g++;
  229.                         }
  230.                         printf("n = %d\t", g);
  231.                         licznik += g*(g - 1);
  232.                         printf("licz = %d\t", licznik);
  233.                         g = 0;
  234.                         /////
  235.                         for (k = 0; k < liczba_znakow; k++)
  236.                         {
  237.                             if (tab2[j][k] == 'o')
  238.                                 g++;
  239.                         }
  240.                         printf("o = %d\t", g);
  241.                         licznik += g*(g - 1);
  242.                         printf("licz = %d\n", licznik);
  243.                         g = 0;
  244.                         /////
  245.  
  246.                         for (k = 0; k < liczba_znakow; k++)
  247.                         {
  248.                             if (tab2[j][k] == 'p')
  249.                                 g++;
  250.                         }
  251.                         printf("p = %d\t", g);
  252.                         licznik += g*(g - 1);
  253.                         printf("licz = %d\t", licznik);
  254.                         g = 0;
  255.                         /////
  256.                         for (k = 0; k < liczba_znakow; k++)
  257.                         {
  258.                             if (tab2[j][k] == 'q')
  259.                                 g++;
  260.                         }
  261.                         printf("q = %d\t", g);
  262.                         licznik += g*(g - 1);
  263.                         printf("licz = %d\t", licznik);
  264.                         g = 0;
  265.                         /////
  266.                         for (k = 0; k < liczba_znakow; k++)
  267.                         {
  268.                             if (tab2[j][k] == 'r')
  269.                                 g++;
  270.                         }
  271.                         printf("r = %d\t", g);
  272.                         licznik += g*(g - 1);
  273.                         printf("licz = %d\n", licznik);
  274.                         g = 0;
  275.                         /////
  276.  
  277.  
  278.                         for (k = 0; k < liczba_znakow; k++)
  279.                         {
  280.                             if (tab2[j][k] == 's')
  281.                                 g++;
  282.                         }
  283.                         printf("s = %d\t", g);
  284.                         licznik += g*(g - 1);
  285.                         printf("licz= %d\t", licznik);
  286.                         g = 0;
  287.                         /////
  288.                         for (k = 0; k < liczba_znakow; k++)
  289.                         {
  290.                             if (tab2[j][k] == 't')
  291.                                 g++;
  292.                         }
  293.                         printf("t = %d\t", g);
  294.                         licznik += g*(g - 1);
  295.                         printf("licz = %d\t", licznik);
  296.                         g = 0;
  297.                         /////
  298.                         for (k = 0; k < liczba_znakow; k++)
  299.                         {
  300.                             if (tab2[j][k] == 'u')
  301.                                 g++;
  302.                         }
  303.                         printf("u = %d\t", g);
  304.                         licznik += g*(g - 1);
  305.                         printf("licz = %d\n", licznik);
  306.                         g = 0;
  307.                         /////
  308.                         for (k = 0; k < liczba_znakow; k++)
  309.                         {
  310.                             if (tab2[j][k] == 'v')
  311.                                 g++;
  312.                         }
  313.                         printf("v = %d\t", g);
  314.                         licznik += g*(g - 1);
  315.                         printf("licz = %d\t", licznik);
  316.                         g = 0;
  317.                         /////
  318.                         for (k = 0; k < liczba_znakow; k++)
  319.                         {
  320.                             if (tab2[j][k] == 'w')
  321.                                 g++;
  322.                         }
  323.                         printf("w = %d\t", g);
  324.                         licznik += g*(g - 1);
  325.                         printf("licz = %d\t", licznik);
  326.                         g = 0;
  327.                         /////
  328.  
  329.  
  330.                         for (k = 0; k < liczba_znakow; k++)
  331.                         {
  332.                             if (tab2[j][k] == 'x')
  333.                                 g++;
  334.                         }
  335.                         printf("x = %d\t", g);
  336.                         licznik += g*(g - 1);
  337.                         printf("licz = %d\n", licznik);
  338.                         g = 0;
  339.                         /////
  340.                         for (k = 0; k < liczba_znakow; k++)
  341.                         {
  342.                             if (tab2[j][k] == 'y')
  343.                                 g++;
  344.                         }
  345.                         printf("y = %d\t", g);
  346.                         licznik += g*(g - 1);
  347.                         printf("licz = %d\t", licznik);
  348.                         g = 0;
  349.                         /////
  350.                         for (k = 0; k < liczba_znakow; k++)
  351.                         {
  352.                             if (tab2[j][k] == 'z')
  353.                                 g++;
  354.                         }
  355.                         printf("z = %d\t", g);
  356.                         licznik += g*(g - 1);
  357.                         printf("licz = %d\n", licznik);
  358.                         g = 0;
  359.                         /////
  360.                         printf("licznik = %d \n\n", licznik);
  361.  
  362.  
  363.                         wynik = (licznik / ((liczba_znakow)*(liczba_znakow - 1)));
  364.  
  365.                         printf("wynik to %f \n", wynik);
  366.  
  367.                         printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");
  368.                         n++;
  369.                         t_wyniki[j] = wynik;
  370.  
  371.                     }
  372.  
  373.  
  374.  
  375.                     for (z = 0; z < j; z++)
  376.                         printf("%d wynik to: %f\n", z + 1, t_wyniki[z]);
  377.  
  378.  
  379.                     for (z = 0; z < i; z++){
  380.  
  381.                             if ((t_wyniki[z]) <= 0.076 && (t_wyniki[z]) >= 0.054)
  382.                                 spr[z] = 1;
  383.                             else
  384.                                 spr[z] = 0;
  385.                     }
  386.  
  387.                     for (z = 0; z < i; z++)
  388.                     {
  389.                         printf("w-%d= %d  ",z+1, spr[z]);
  390.                     }
  391.  
  392.  
  393.                
  394.                     for (z = 0; z < i; z++)
  395.                     {
  396.                     if (spr[z] == 1)
  397.                         co += 1;
  398.                     }
  399.  
  400.                         printf("\n");
  401.                         if (co == i){
  402.                             printf("mozliwe ze klucz jest %d literowy\n", i);
  403.                             printf("szukac dalej?? y/n\n");
  404.                             wybor = getch();
  405.                             //scanf("%c", &wybor);
  406.  
  407.                             switch(wybor)
  408.                             {
  409.                                 case 'y':
  410.                                     break;
  411.                                 case 'n':
  412.                                     return 0;
  413.  
  414.                             }
  415.                        
  416.                         }
  417.                         else
  418.                         printf("klucz nie jest %d literowy\n\n", i);
  419.  
  420.  
  421.  
  422.  
  423.                 printf("////////////\n");
  424.                 for (j = 0; j < i; j++)
  425.                     free(tab2[j]);
  426.                 co = 0;
  427.                 wybor = NULL;
  428.     }
  429.  
  430.     free(tab2);
  431.    
  432.     printf("KONIEC PROGRAMU\n\n\n");
  433.     system("pause");
  434.    
  435.     return 0;
  436. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement