Ledger Nano X - The secure hardware wallet
SHARE
TWEET

Untitled

a guest Mar 28th, 2020 61 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. class Reflektor {
  6. private:
  7.     short int ile_liter;
  8.     short int* permutacja;
  9. public:
  10.     short int get_ile_liter();
  11.     void set_ile_liter(short int a);
  12.     short int* get_permutacja();
  13.     void wczytaj_permutacje();
  14. };
  15.  
  16. class Wirnik {
  17. private:
  18.     short int ile_liter;
  19.     short int* permutacja_poczatkowa;
  20.     short int ile_obraca;
  21.     short int* litery_obracajace;
  22.     short int* przesuniecia;
  23.     short int obecna_pozycja = 1;
  24.     short int* obecna_permutacja;
  25.  
  26. public:
  27.     //Wirnik(int ile_lit, int* per, int ile_obr, int* litery_obr);
  28.     ~Wirnik();
  29.     short int get_ile_liter();
  30.     void set_ile_liter(short int a);
  31.     short int get_ile_obraca();
  32.     void set_ile_obraca(short int a);
  33.     short int* get_permutacja_poczatkowa();
  34.     short int* get_litery_obracajace();
  35.     void set_permutacja_poczatkowa(short int* elementy);
  36.     void set_litery_obracajace(short int* elementy);
  37.     void wczytaj_permutacje();
  38.     void wyswietl_permutacje();
  39.     void wczytaj_obracajace();
  40.     short int* get_przesuniecia();
  41.     void set_przesuniecia(short int* a);
  42.     short int get_obecna_pozycja();
  43.     void set_obecna_pozycja(short int a);
  44.     void przesun();
  45.     void ustaw_przesuniecia();
  46.     short int szukaj(short int a);
  47.     void ustaw_na_pozycje(short int pozycja);
  48.     void ustaw_aktywna_permutacje(short int* poprzednie);
  49.     void poczatkowa_na_aktywna();
  50.     bool czy_obrocic();
  51.     short int* get_obecna_permutacja();
  52.     void set_obecna_permutacja(short int* a);
  53.     short int* kopiuj_permutacje();
  54.     short int szukaj_p(short int a);
  55. };
  56.  
  57. /*Wirnik::Wirnik(int ile_lit, int* per, int ile_obr, int* litery_obr) {
  58.     this->ile_liter = ile_lit;
  59.     this->permutacja = per;
  60.     this->ile_obraca = ile_obr;
  61.     this->litery_obracajace = litery_obr;
  62. }*/
  63. Wirnik::~Wirnik() {}
  64. short int Wirnik::get_ile_liter() {
  65.     return ile_liter;
  66. }
  67. short int* Wirnik::get_permutacja_poczatkowa() {
  68.     return permutacja_poczatkowa;
  69. }
  70. short int Wirnik::get_ile_obraca() {
  71.     return ile_obraca;
  72. }
  73. short int* Wirnik::get_litery_obracajace() {
  74.     return litery_obracajace;
  75. }
  76. void Wirnik::set_ile_liter(short int a) {
  77.     this->ile_liter = a;
  78. }
  79. void Wirnik::set_ile_obraca(short int a) {
  80.     this->ile_obraca = a;
  81. }
  82. void Wirnik::set_permutacja_poczatkowa(short int* elementy) {
  83.     this->permutacja_poczatkowa = elementy;
  84. }
  85. void Wirnik::set_litery_obracajace(short int* elementy) {
  86.     this->litery_obracajace = elementy;
  87. }
  88. void Wirnik::wczytaj_permutacje() {
  89.     //this->permutacja_poczatkowa = new int[ile_liter];
  90.     this->permutacja_poczatkowa = (short int*)malloc(ile_liter * sizeof(short int));
  91.     for (int i = 0; i < ile_liter; i++) {
  92.         //cin >> permutacja_poczatkowa[i];
  93.         scanf("%h", &permutacja_poczatkowa[i]);
  94.     }
  95. }
  96. void Wirnik::wyswietl_permutacje() {
  97.     for (int i = 0; i < ile_liter; i++) cout << permutacja_poczatkowa[i];
  98. }
  99. void Wirnik::wczytaj_obracajace() {
  100.     //this->litery_obracajace = new int[ile_obraca];
  101.     this->litery_obracajace = (short int*)malloc(ile_obraca * sizeof(short int));
  102.     for (int i = 0; i < ile_obraca; i++) {
  103.         //cin >> litery_obracajace[i];
  104.         scanf("%h", &litery_obracajace[i]);
  105.     }
  106. }
  107. short int* Wirnik::get_przesuniecia() {
  108.     return przesuniecia;
  109. }
  110. short int Wirnik::get_obecna_pozycja() {
  111.     return obecna_pozycja;
  112. }
  113. void Wirnik::set_obecna_pozycja(short int a) {
  114.     this->obecna_pozycja = a;
  115. }
  116. void Wirnik::set_przesuniecia(short int* a) {
  117.     this->przesuniecia = a;
  118. }
  119. void Wirnik::przesun() {
  120.     short int tmp = this->przesuniecia[0];
  121.     for (int i = 0; i < ile_liter - 1; i++) {
  122.         this->przesuniecia[i] = this->przesuniecia[i + 1];
  123.     }
  124.     this->przesuniecia[ile_liter - 1] = tmp;
  125.     if (obecna_pozycja == ile_liter) obecna_pozycja = 1;
  126.     else obecna_pozycja++;
  127. }
  128. void Wirnik::ustaw_przesuniecia() {
  129.     //this->przesuniecia = new int[ile_liter];
  130.     this->przesuniecia = (short int*)malloc(ile_liter * sizeof(short int));
  131.     for (int i = 0; i < ile_liter; i++) {
  132.         this->przesuniecia[i] = this->szukaj_p(i + 1) - i;
  133.     }
  134. }
  135. short int Wirnik::szukaj(short int a) {
  136.     for (int i = 0; i < ile_liter; i++) {
  137.         if (obecna_permutacja[i] == a) return i;
  138.     }
  139.     return -1;
  140. }
  141. short int Wirnik::szukaj_p(short int a) {
  142.     for (int i = 0; i< ile_liter; i++)
  143.         if (permutacja_poczatkowa[i] == a) return i;
  144.     return -1;
  145. }
  146. void Wirnik::ustaw_na_pozycje(short int pozycja) {
  147.     while (this->obecna_pozycja != pozycja) this->przesun();
  148. }
  149. void Wirnik::ustaw_aktywna_permutacje(short int* poprzednie) {
  150.     for (int i = 0; i < ile_liter; i++) {
  151.         if (przesuniecia[i] + i < 0) przesuniecia[i] = ile_liter + przesuniecia[i];
  152.         else if (przesuniecia[i] + i > ile_liter - 1) przesuniecia[i] = przesuniecia[i] - ile_liter;
  153.         this->obecna_permutacja[i] = poprzednie[i + przesuniecia[i]];
  154.     }
  155. }
  156. void Wirnik::poczatkowa_na_aktywna() {
  157.     //this->obecna_permutacja = new int[ile_liter];
  158.     this->obecna_permutacja = (short int*)malloc(ile_liter * sizeof(int));
  159.     for (int i = 0; i < ile_liter; i++) {
  160.         obecna_permutacja[i] = permutacja_poczatkowa[i];
  161.     }
  162. }
  163. bool Wirnik::czy_obrocic() {
  164.     for (int i = 0; i < ile_obraca; i++) {
  165.         if (obecna_pozycja == litery_obracajace[i]) return true;
  166.     }
  167.     return false;
  168. }
  169. short int* Wirnik::get_obecna_permutacja() {
  170.     return obecna_permutacja;
  171. }
  172. void Wirnik::set_obecna_permutacja(short int* a) {
  173.     this->obecna_permutacja = a;
  174. }
  175. short int* Wirnik::kopiuj_permutacje() {
  176.     //int* nowy = new int[ile_liter];
  177.     short int* nowy = (short int*)malloc(ile_liter * sizeof(short int));
  178.     for (int i = 0; i < ile_liter; i++) {
  179.         nowy[i] = this->obecna_permutacja[i];
  180.     }
  181.     return nowy;
  182. }
  183.  
  184.  
  185. short int Reflektor::get_ile_liter() {
  186.     return ile_liter;
  187. }
  188. short int* Reflektor::get_permutacja() {
  189.     return permutacja;
  190. }
  191. void Reflektor::set_ile_liter(short int a) {
  192.     this->ile_liter = a;
  193. }
  194. void Reflektor::wczytaj_permutacje() {
  195.     //this->permutacja = new int[ile_liter];
  196.     this->permutacja = (short int*)malloc(ile_liter * sizeof(short int));
  197.     for (int i = 0; i < ile_liter; i++) {
  198.         //cin >> this->permutacja[i];
  199.         scanf("%h", &permutacja[i]);
  200.     }
  201. }
  202.  
  203.  
  204.  
  205. int main()
  206. {
  207.     //ios::sync_with_stdio(false);
  208.     short int ile_liter = 0;
  209.     //cin >> ile_liter;
  210.     scanf("%h", &ile_liter);
  211.     //int* podstawa = new int[ile_liter];
  212.     short int* podstawa = (short int*)malloc(ile_liter * sizeof(short int));
  213.     for (int i = 1; i <= ile_liter; i++) podstawa[i - 1] = i;
  214.     short int ile_wirnikow = 0;
  215.     //cin >> ile_wirnikow;
  216.     scanf("%h", &ile_wirnikow);
  217.     Wirnik* wirniki = new Wirnik[ile_wirnikow];
  218.     for (int i = 0; i < ile_wirnikow; i++) {
  219.         wirniki[i].set_ile_liter(ile_liter);
  220.         wirniki[i].wczytaj_permutacje();
  221.         short int ile_obraca;
  222.         //cin >> ile_obraca;
  223.         scanf("%h", &ile_obraca);
  224.         wirniki[i].set_ile_obraca(ile_obraca);
  225.         wirniki[i].wczytaj_obracajace();
  226.         //cout << endl;
  227.         //wirniki[i].wyswietl_permutacje();
  228.         //cout << endl << endl;
  229.     }
  230.     short int liczba_reflektorow;
  231.     //cin >> liczba_reflektorow;
  232.     scanf("%h", &liczba_reflektorow);
  233.     Reflektor* reflektory = new Reflektor[liczba_reflektorow];
  234.     for (int i = 0; i < liczba_reflektorow; i++) {
  235.         reflektory[i].set_ile_liter(ile_liter);
  236.         reflektory[i].wczytaj_permutacje();
  237.         //cout << endl;
  238.         //reflektory[i].wyswietl_permutacje();
  239.         //cout << endl << endl;
  240.     }
  241.  
  242.     short int liczba_zadan;
  243.     //cin >> liczba_zadan;
  244.     scanf("%h", &liczba_zadan);
  245.     for (int i = 0; i < liczba_zadan; i++) {
  246.         short int ile_aktywnych_wirnikow;
  247.         //cin >> ile_aktywnych_wirnikow;
  248.         scanf("%h", &ile_aktywnych_wirnikow);
  249.         Wirnik* aktywne_wirniki = new Wirnik[ile_aktywnych_wirnikow];
  250.         for (int j = 0; j < ile_aktywnych_wirnikow; j++) {
  251.             short int indeks_wirnika;
  252.             //cin >> indeks_wirnika;
  253.             scanf("%h", &indeks_wirnika);
  254.             aktywne_wirniki[j] = wirniki[indeks_wirnika];
  255.             short int pozycja_poczatkowa;
  256.             //cin >> pozycja_poczatkowa;
  257.             scanf("%h", &pozycja_poczatkowa);
  258.             aktywne_wirniki[j].ustaw_przesuniecia();
  259.             aktywne_wirniki[j].poczatkowa_na_aktywna();
  260.             aktywne_wirniki[j].ustaw_na_pozycje(pozycja_poczatkowa);
  261.         }
  262.         short int indeks_reflektora;
  263.         //cin >> indeks_reflektora;
  264.         scanf("%h", &indeks_reflektora);
  265.         Reflektor aktywny_reflektor = reflektory[indeks_reflektora];
  266.         bool odwrocony_2 = false;
  267.         for (int x = 0;; x++) {
  268.             short int oryginal;
  269.            
  270.             //cin >> oryginal;
  271.             scanf("%h", &oryginal);
  272.             if (oryginal == 0) break;
  273.             else {
  274.                 aktywne_wirniki[0].przesun();
  275.                 aktywne_wirniki[0].ustaw_aktywna_permutacje(podstawa);
  276.  
  277.                 for (int j = 1; j < ile_aktywnych_wirnikow; j++) {
  278.                     if (x != 0 && j == 1 && aktywne_wirniki[j - 1].czy_obrocic()) {
  279.                         aktywne_wirniki[j].przesun();
  280.                         odwrocony_2 = true;
  281.                         aktywne_wirniki[j].ustaw_aktywna_permutacje(aktywne_wirniki[j - 1].get_obecna_permutacja());
  282.                         continue;
  283.                     }
  284.                     else if (x != 0 && j == 2 && odwrocony_2 && aktywne_wirniki[j - 1].czy_obrocic()) {
  285.                         aktywne_wirniki[j].przesun();
  286.                         aktywne_wirniki[j - 1].przesun();
  287.                         aktywne_wirniki[j - 1].ustaw_aktywna_permutacje(aktywne_wirniki[j - 2].get_obecna_permutacja());
  288.                     }
  289.                     //int* poprzednie = aktywne_wirniki[j-1].kopiuj_permutacje();
  290.                     aktywne_wirniki[j].ustaw_aktywna_permutacje(aktywne_wirniki[j - 1].get_obecna_permutacja());
  291.                 }
  292.                 //int indeks = aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal);
  293.                 //int* permutacje_reflektora = aktywny_reflektor.get_permutacja_poczatkowa();
  294.                 //int indeks_w_reflektorze = permutacje_reflektora[indeks]-1;
  295.                 //int* ostatni_wirnik = aktywne_wirniki[ile_aktywnych_wirnikow -1].get_obecna_permutacja();
  296.                 //cout << aktywne_wirniki[ile_aktywnych_wirnikow - 1].get_obecna_permutacja()[aktywny_reflektor.get_permutacja_poczatkowa()[aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal)] - 1] << '\n';
  297.                 printf("%d",aktywne_wirniki[ile_aktywnych_wirnikow - 1].get_obecna_permutacja()[aktywny_reflektor.get_permutacja()[aktywne_wirniki[ile_aktywnych_wirnikow - 1].szukaj(oryginal)] - 1]);
  298.                 printf("%c", '\n');
  299.  
  300.             }
  301.         }
  302.     }
  303.  
  304.     return 0;
  305. }
RAW Paste Data
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
Top