Advertisement
Guest User

Maszyna Szyfrująca

a guest
Nov 26th, 2014
155
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 15.30 KB | None | 0 0
  1. #include <iostream>
  2. #include <string>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. void wypelnijTabliceDomyslnie(int modyfikator[])
  8. {
  9.     modyfikator[0] = 6;
  10.     modyfikator[1] = 3;
  11.     modyfikator[2] = -4;
  12.     modyfikator[3] = 2;
  13.     modyfikator[4] = 8;
  14.     modyfikator[5] = -7;
  15. }
  16.  
  17. void wprowadzTekst(string & tekst)
  18. {
  19.     cout <<"Wprowad\253 tekst:"<< endl;
  20.     cout <<"Program obs\210uguje wszystkie znaki podstawowej tabeli drukowalnych znak\242w ASCII."<< endl;
  21.     cout <<"Mo\276esz u\276ywa\206 wszystkich znak\242w mo\276liwych do wpisania na klawiaturze,\nopr\242cz tych, do kt\242rych napisania wymagane jest wci\230ni\251cie alt."<< endl;
  22.     getline(cin, tekst);
  23.     cin.clear();
  24.     cin.sync();
  25. }
  26.  
  27. bool sprawdzenieZnakow(string tekst)
  28. {
  29.     if(tekst.size() == 0)
  30.     {
  31.         system("cls");//zeby wcisniecie samego entera nic nie dawalo
  32.         return false;
  33.     }
  34.  
  35.     for(int a = 0; a < tekst.size(); a++)
  36.     {
  37.         if(tekst[a] < 32 || tekst[a] > 125)
  38.         {
  39.             cout <<"Znaleziono niedozwolony znak. Wprowad\253 dane poprawnie."<< endl;
  40.             return false;
  41.         }
  42.     }
  43.  
  44.     return true;
  45. }
  46.  
  47. void zamianaNaChary(string tekst, unsigned char znak[])
  48. {
  49.     for(int a = 0; a < tekst.size(); a++)
  50.     {
  51.         znak[a] = tekst[a];
  52.     }
  53. }
  54.  
  55. void szyfrowanie1(unsigned char znak[], int dlugosc, int modyfikator[], int ileElementow)
  56. {
  57.     int m = 0;
  58.     for(int a = 0; a < dlugosc; a++, m++)
  59.     {
  60.         if(m == ileElementow)
  61.         {
  62.             m = 0;
  63.         }
  64.  
  65.         znak[a] += modyfikator[m];
  66.  
  67.  
  68.         if(znak[a] < 32)
  69.         {
  70.             znak[a] = 126 - (32 - znak[a]);
  71.         }
  72.  
  73.         if(znak[a] > 125)
  74.         {
  75.            znak[a] = 31 + (znak[a] - 125);
  76.         }
  77.     }
  78. }
  79.  
  80. void szyfrowanie2(unsigned char znak[], int dlugosc)
  81. {
  82.     for(int a = 0; a < dlugosc; a++)
  83.     {
  84.         if(znak[a] == 32)
  85.         {
  86.             znak[a] = 48;
  87.             continue;
  88.         }
  89.         if(znak[a] == 33)
  90.         {
  91.             znak[a] = 120;
  92.             continue;
  93.         }
  94.         if(znak[a] == 34)
  95.         {
  96.             znak[a] = 90;
  97.             continue;
  98.         }
  99.         if(znak[a] == 35)
  100.         {
  101.             znak[a] = 60;
  102.             continue;
  103.         }
  104.         if(znak[a] == 36)
  105.         {
  106.             znak[a] = 50;
  107.             continue;
  108.         }
  109.         if(znak[a] == 37)
  110.         {
  111.             znak[a] = 40;
  112.             continue;
  113.         }
  114.         if(znak[a] == 38)
  115.         {
  116.             znak[a] = 82;
  117.             continue;
  118.         }
  119.         if(znak[a] == 39)
  120.         {
  121.             znak[a] = 101;
  122.             continue;
  123.         }
  124.         if(znak[a] == 40)
  125.         {
  126.             znak[a] = 37;
  127.             continue;
  128.         }
  129.         if(znak[a] == 41)
  130.         {
  131.             znak[a] = 66;
  132.             continue;
  133.         }
  134.         if(znak[a] == 42)
  135.         {
  136.             znak[a] = 93;
  137.             continue;
  138.         }
  139.         if(znak[a] == 43)
  140.         {
  141.             znak[a] = 125;
  142.             continue;
  143.         }
  144.         if(znak[a] == 44)
  145.         {
  146.             znak[a] = 92;
  147.             continue;
  148.         }
  149.         if(znak[a] == 45)
  150.         {
  151.             znak[a] = 51;
  152.             continue;
  153.         }
  154.         if(znak[a] == 46)
  155.         {
  156.             znak[a] = 83;
  157.             continue;
  158.         }
  159.         if(znak[a] == 47)
  160.         {
  161.             znak[a] = 111;
  162.             continue;
  163.         }
  164.         if(znak[a] == 48)
  165.         {
  166.             znak[a] = 32;
  167.             continue;
  168.         }
  169.         if(znak[a] == 49)
  170.         {
  171.             znak[a] = 73;
  172.             continue;
  173.         }
  174.         if(znak[a] == 50)
  175.         {
  176.             znak[a] = 36;
  177.             continue;
  178.         }
  179.         if(znak[a] == 51)
  180.         {
  181.             znak[a] = 45;
  182.             continue;
  183.         }
  184.         if(znak[a] == 52)
  185.         {
  186.             znak[a] = 61;
  187.             continue;
  188.         }
  189.         if(znak[a] == 53)
  190.         {
  191.             znak[a] = 72;
  192.             continue;
  193.         }
  194.         if(znak[a] == 54)
  195.         {
  196.             znak[a] = 99;
  197.             continue;
  198.         }
  199.         if(znak[a] == 55)
  200.         {
  201.             znak[a] = 59;
  202.             continue;
  203.         }
  204.         if(znak[a] == 56)
  205.         {
  206.             znak[a] = 124;
  207.             continue;
  208.         }
  209.         if(znak[a] == 57)
  210.         {
  211.             znak[a] = 74;
  212.             continue;
  213.         }
  214.         if(znak[a] == 58)
  215.         {
  216.             znak[a] = 96;
  217.             continue;
  218.         }
  219.         if(znak[a] == 59)
  220.         {
  221.             znak[a] = 55;
  222.             continue;
  223.         }
  224.         if(znak[a] == 60)
  225.         {
  226.             znak[a] = 35;
  227.             continue;
  228.         }
  229.         if(znak[a] == 61)
  230.         {
  231.             znak[a] = 52;
  232.             continue;
  233.         }
  234.         if(znak[a] == 62)
  235.         {
  236.             znak[a] = 71;
  237.             continue;
  238.         }
  239.         if(znak[a] == 63)
  240.         {
  241.             znak[a] = 100;
  242.             continue;
  243.         }
  244.         if(znak[a] == 64)
  245.         {
  246.             znak[a] = 70;
  247.             continue;
  248.         }
  249.         if(znak[a] == 65)
  250.         {
  251.             znak[a] = 113;
  252.             continue;
  253.         }
  254.         if(znak[a] == 66)
  255.         {
  256.             znak[a] = 41;
  257.             continue;
  258.         }
  259.         if(znak[a] == 67)
  260.         {
  261.             znak[a] = 94;
  262.             continue;
  263.         }
  264.         if(znak[a] == 68)
  265.         {
  266.             znak[a] = 116;
  267.             continue;
  268.         }
  269.         if(znak[a] == 69)
  270.         {
  271.             znak[a] = 91;
  272.             continue;
  273.         }
  274.         if(znak[a] == 70)
  275.         {
  276.             znak[a] = 64;
  277.             continue;
  278.         }
  279.         if(znak[a] == 71)
  280.         {
  281.             znak[a] = 62;
  282.             continue;
  283.         }
  284.         if(znak[a] == 72)
  285.         {
  286.             znak[a] = 53;
  287.             continue;
  288.         }
  289.         if(znak[a] == 73)
  290.         {
  291.             znak[a] = 49;
  292.             continue;
  293.         }
  294.         if(znak[a] == 74)
  295.         {
  296.             znak[a] = 57;
  297.             continue;
  298.         }
  299.         if(znak[a] == 75)
  300.         {
  301.             znak[a] = 123;
  302.             continue;
  303.         }
  304.         if(znak[a] == 76)
  305.         {
  306.             znak[a] = 89;
  307.             continue;
  308.         }
  309.         if(znak[a] == 77)
  310.         {
  311.             znak[a] = 81;
  312.             continue;
  313.         }
  314.         if(znak[a] == 78)
  315.         {
  316.             znak[a] = 80;
  317.             continue;
  318.         }
  319.         if(znak[a] == 79)
  320.         {
  321.             znak[a] = 104;
  322.             continue;
  323.         }
  324.         if(znak[a] == 80)
  325.         {
  326.             znak[a] = 78;
  327.             continue;
  328.         }
  329.         if(znak[a] == 81)
  330.         {
  331.             znak[a] = 77;
  332.             continue;
  333.         }
  334.         if(znak[a] == 82)
  335.         {
  336.             znak[a] = 38;
  337.             continue;
  338.         }
  339.         if(znak[a] == 83)
  340.         {
  341.             znak[a] = 46;
  342.             continue;
  343.         }
  344.         if(znak[a] == 84)
  345.         {
  346.             znak[a] = 97;
  347.             continue;
  348.         }
  349.         if(znak[a] == 85)
  350.         {
  351.             znak[a] = 102;
  352.             continue;
  353.         }
  354.         if(znak[a] == 86)
  355.         {
  356.             znak[a] = 105;
  357.             continue;
  358.         }
  359.         if(znak[a] == 87)
  360.         {
  361.             znak[a] = 95;
  362.             continue;
  363.         }
  364.         if(znak[a] == 88)
  365.         {
  366.             znak[a] = 109;
  367.             continue;
  368.         }
  369.         if(znak[a] == 89)
  370.         {
  371.             znak[a] = 76;
  372.             continue;
  373.         }
  374.         if(znak[a] == 90)
  375.         {
  376.             znak[a] = 34;
  377.             continue;
  378.         }
  379.         if(znak[a] == 91)
  380.         {
  381.             znak[a] = 69;
  382.             continue;
  383.         }
  384.         if(znak[a] == 92)
  385.         {
  386.             znak[a] = 44;
  387.             continue;
  388.         }
  389.         if(znak[a] == 93)
  390.         {
  391.             znak[a] = 42;
  392.             continue;
  393.         }
  394.         if(znak[a] == 94)
  395.         {
  396.             znak[a] = 67;
  397.             continue;
  398.         }
  399.         if(znak[a] == 95)
  400.         {
  401.             znak[a] = 87;
  402.             continue;
  403.         }
  404.         if(znak[a] == 96)
  405.         {
  406.             znak[a] = 58;
  407.             continue;
  408.         }
  409.         if(znak[a] == 97)
  410.         {
  411.             znak[a] = 84;
  412.             continue;
  413.         }
  414.         if(znak[a] == 98)
  415.         {
  416.             znak[a] = 107;
  417.             continue;
  418.         }
  419.         if(znak[a] == 99)
  420.         {
  421.             znak[a] = 54;
  422.             continue;
  423.         }
  424.         if(znak[a] == 100)
  425.         {
  426.             znak[a] = 63;
  427.             continue;
  428.         }
  429.         if(znak[a] == 101)
  430.         {
  431.             znak[a] = 39;
  432.             continue;
  433.         }
  434.         if(znak[a] == 102)
  435.         {
  436.             znak[a] = 85;
  437.             continue;
  438.         }
  439.         if(znak[a] == 103)
  440.         {
  441.             znak[a] = 108;
  442.             continue;
  443.         }
  444.         if(znak[a] == 104)
  445.         {
  446.             znak[a] = 79;
  447.             continue;
  448.         }
  449.         if(znak[a] == 105)
  450.         {
  451.             znak[a] = 86;
  452.             continue;
  453.         }
  454.         if(znak[a] == 106)
  455.         {
  456.             znak[a] = 117;
  457.             continue;
  458.         }
  459.         if(znak[a] == 107)
  460.         {
  461.             znak[a] = 98;
  462.             continue;
  463.         }
  464.         if(znak[a] == 108)
  465.         {
  466.             znak[a] = 103;
  467.             continue;
  468.         }
  469.         if(znak[a] == 109)
  470.         {
  471.             znak[a] = 88;
  472.             continue;
  473.         }
  474.         if(znak[a] == 110)
  475.         {
  476.             znak[a] = 122;
  477.             continue;
  478.         }
  479.         if(znak[a] == 111)
  480.         {
  481.             znak[a] = 47;
  482.             continue;
  483.         }
  484.         if(znak[a] == 112)
  485.         {
  486.             znak[a] = 121;
  487.             continue;
  488.         }
  489.         if(znak[a] == 113)
  490.         {
  491.             znak[a] = 65;
  492.             continue;
  493.         }
  494.         if(znak[a] == 114)
  495.         {
  496.             znak[a] = 119;
  497.             continue;
  498.         }
  499.         if(znak[a] == 115)
  500.         {
  501.             znak[a] = 118;
  502.             continue;
  503.         }
  504.         if(znak[a] == 116)
  505.         {
  506.             znak[a] = 68;
  507.             continue;
  508.         }
  509.         if(znak[a] == 117)
  510.         {
  511.             znak[a] = 106;
  512.             continue;
  513.         }
  514.         if(znak[a] == 118)
  515.         {
  516.             znak[a] = 115;
  517.             continue;
  518.         }
  519.         if(znak[a] == 119)
  520.         {
  521.             znak[a] = 114;
  522.             continue;
  523.         }
  524.         if(znak[a] == 120)
  525.         {
  526.             znak[a] = 33;
  527.             continue;
  528.         }
  529.         if(znak[a] == 121)
  530.         {
  531.             znak[a] = 112;
  532.             continue;
  533.         }
  534.         if(znak[a] == 122)
  535.         {
  536.             znak[a] = 110;
  537.             continue;
  538.         }
  539.         if(znak[a] == 123)
  540.         {
  541.             znak[a] = 75;
  542.             continue;
  543.         }
  544.         if(znak[a] == 124)
  545.         {
  546.             znak[a] = 56;
  547.             continue;
  548.         }
  549.         if(znak[a] == 125)
  550.         {
  551.             znak[a] = 43;
  552.             continue;
  553.         }
  554.     }
  555. }
  556.  
  557. void szyfrowanie3(unsigned char znak[], int dlugosc)
  558. {
  559.     char przechowalnia;
  560.     for(int a = 0; a < dlugosc - 1; a += 2)
  561.     {
  562.         przechowalnia = znak[a];
  563.         znak[a] = znak[a+1];
  564.         znak[a+1] = przechowalnia;
  565.     }
  566. }
  567.  
  568. void deszyfrowanie1(unsigned char znak[], int dlugosc, int modyfikator[], int ileElementow)
  569. {
  570.     int m = 0;
  571.     for(int a = 0; a < dlugosc; a++, m++)
  572.     {
  573.         if(m == ileElementow)
  574.         {
  575.             m = 0;
  576.         }
  577.  
  578.         znak[a] -= modyfikator[m];
  579.  
  580.  
  581.         if(znak[a] < 32)
  582.         {
  583.             znak[a] = 126 - (32 - znak[a]);
  584.         }
  585.  
  586.  
  587.         if(znak[a] > 125)
  588.         {
  589.             znak[a] = 31 + (znak[a] - 125);
  590.         }
  591.     }
  592. }
  593.  
  594. int menu()
  595. {
  596.     int menu;
  597.     bool menuGood;
  598.     do
  599.     {
  600.         cout <<"1 - Szyfrowanie"<< endl;
  601.         cout <<"2 - Deszyfrowanie"<< endl;
  602.         cout <<"3 - Ustawienia"<< endl;
  603.         cout <<"4 - Wyj\230cie"<< endl;
  604.         cin >> menu;
  605.         menuGood = cin.good();
  606.         cin.clear();
  607.         cin.sync();
  608.  
  609.         if(menuGood == false || (menuGood == true && (menu > 4 || menu < 1)))
  610.         {
  611.             cout <<"Wprowadzono b\210\251dne dane. Wprowad\253 jeszcze raz.\n"<< endl;
  612.         }
  613.     }while(menuGood == false || (menuGood == true && (menu > 4 || menu < 1)));
  614.  
  615.     return menu;
  616. }
  617.  
  618. bool jeszczeRaz()
  619. {
  620.     string czy;
  621.  
  622.     do
  623.     {
  624.         cout <<"\nCzy na pewno chcesz zamkn\245\206 program? Wprowad\253 [T]ak lub [N]ie."<< endl;
  625.         cin >> czy;
  626.         cin.clear();
  627.         cin.sync();
  628.         if(czy != "T" && czy != "t" && czy != "N" && czy != "n")
  629.         {
  630.             cout <<"B\210\251dne wprowadzenie danych. Wprowad\253 poprawnie.\nT dla [T]ak, N dla [N]ie. Wielko\230\206 litery nie ma znaczenia."<< endl;
  631.         }
  632.     }while(czy != "T" && czy != "t" && czy != "N" && czy != "n");
  633.  
  634.     if(czy == "N" || czy == "n")
  635.     {
  636.         return true;
  637.     }
  638.     if(czy == "T" || czy == "t")
  639.     {
  640.         return false;
  641.     }
  642. }
  643.  
  644. int main()
  645. {
  646.     string tekst;
  647.     bool ifretry;
  648.     int ileElementow = 6;
  649.     int modyfikator[ileElementow];
  650.     wypelnijTabliceDomyslnie(modyfikator); //takie pierdoly do ustawiania domyslnych ustawien, potem sie zrobi opcje do robienia innych ustawien, takich jak ilosc modyfikatorow i ich wartosc
  651.  
  652.     bool ifexit;
  653.  
  654.     do
  655.     {
  656.         int opcja = menu();
  657.  
  658.         if(opcja == 1)
  659.         {
  660.             do
  661.             {
  662.                 wprowadzTekst(tekst);
  663.                 ifretry = sprawdzenieZnakow(tekst);
  664.             }while(ifretry == false);
  665.  
  666.             unsigned char znak[tekst.size()];
  667.             zamianaNaChary(tekst, znak);
  668.             int dlugosc = tekst.size();
  669.  
  670.             szyfrowanie1(znak, dlugosc, modyfikator, ileElementow);
  671.             szyfrowanie2(znak, dlugosc);
  672.             for(int v = 0; v < 2; v++)
  673.             {
  674.                 szyfrowanie3(znak, dlugosc);
  675.             }
  676.             cout << "\nZaszyfrowany tekst: ";
  677.  
  678.             for(int a = 0; a < dlugosc; a++)
  679.             {
  680.                 cout << znak[a];
  681.             }
  682.         }
  683.         if(opcja == 2)
  684.         {
  685.             {
  686.                 wprowadzTekst(tekst);
  687.                 ifretry = sprawdzenieZnakow(tekst);
  688.             }while(ifretry == false);
  689.  
  690.             unsigned char znak[tekst.size()];
  691.             zamianaNaChary(tekst, znak);
  692.             int dlugosc = tekst.size();
  693.  
  694.             for(int v = 0; v < 2; v++)
  695.             {
  696.                 szyfrowanie3(znak, dlugosc);
  697.             }
  698.             szyfrowanie2(znak, dlugosc);
  699.             deszyfrowanie1(znak, dlugosc, modyfikator, ileElementow);
  700.  
  701.             cout << "\nOdszyfrowany tekst: ";
  702.  
  703.             for(int a = 0; a < dlugosc; a++)
  704.             {
  705.                 cout << znak[a];
  706.             }
  707.         }
  708.         if(opcja == 3)
  709.         {
  710.             cout <<"Sorry, ale na razie nie ma \276adnych ustawie\344 poza domy\230lnymi.\nB\251d\245 w nast\251pnej wersji."<< endl;
  711.         }
  712.         if(opcja == 4)
  713.         {
  714.             ifexit = jeszczeRaz();
  715.             if(ifexit == false)
  716.             {
  717.                 return 0;
  718.             }
  719.             else
  720.             {
  721.                 continue;
  722.             }
  723.         }
  724.         cout << "\n";
  725.         system("pause");
  726.         cout << "\n";
  727.     }while(ifexit == true);
  728.  
  729.     return 0;
  730. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement