Advertisement
poczatkujacykoder

Untitled

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