ulvis.paste.net

Paste Search Dynamic
Recent pastes
HakerC++
  1. #include "stdafx.h"
  2. #include "iostream"
  3. #include "vector"
  4. using namespace std;
  5.  
  6. //*****************************
  7. void generuj(int tablica[], int rozmiar, int zakres)
  8. {
  9.         for (int i = 0; i < rozmiar; i++)
  10.         {
  11.                 tablica[i] = rand() % (zakres + 1);
  12.         }
  13. }
  14. //*****************************
  15. void wypisz(int tablica[], int rozmiar, char separator)
  16. {
  17.         for (int i = 0; i < rozmiar; i++)
  18.                 cout << tablica[i] << separator;
  19.         cout << endl;
  20. }
  21. //*****************************
  22. void przesun(int tablica[], int rozmiar)
  23. //funkcja   void przesun(int tab[], int rozmiar)
  24. //Przesuwa elementy tablicy wg zasady
  25. //0 ->1
  26. //1 ->2 ..
  27. //ostatni->pierwszy
  28. {
  29.         int tmp;
  30.         tmp = tablica[rozmiar - 1];//zapami�tuj� ostatni element
  31.         for (int i = rozmiar - 1; i > 0; i--)
  32.         {
  33.                 tablica[i] = tablica[i - 1];
  34.         }
  35.         tablica[0] = tmp;//ostatni na pierwszy
  36. }
  37. //*****************************
  38. bool czyObokSiebie(int tablica[], int rozmiar)
  39. //funkcja bool czyOK(int tab[], int rozmiar)
  40. //sprawdza czy w tablicy wyst�puj� obok siebie jednakowe elementy
  41. //tak - wynik true   2 4 6 6 8
  42. //nie - wynik false  2 4 6 8 0
  43. {
  44.         for (int i = 0; i <rozmiar - 1; i++)
  45.         {
  46.                 if (tablica[i] == tablica[i + 1])
  47.                         return false;
  48.         }
  49.         return true;
  50. }
  51. //*****************************
  52. bool czyKolejne(int tablica[], int rozmiar)
  53. //funkcja bool czyOK(int tab[], int rozmiar)
  54. //sprawdza czy w tablicy wyst�puj� obok siebie kolejne elementy
  55. //2 5 7 8 2  tak
  56. //1 4 7 2 8  nie
  57. {
  58.         for (int i = 0; i <rozmiar - 1; i++)
  59.         {
  60.                 if (tablica[i] + 1 == tablica[i + 1])
  61.                         return true;
  62.         }
  63.         return false;
  64. }
  65. //*****************************
  66. bool pinOk(char pin1[])
  67. //
  68. {
  69.         int i, j, ileZnakow;
  70.         ileZnakow = strlen(pin1);
  71.         if (ileZnakow != 4)
  72.         {
  73.                 cout << "Zla liczba znakow!\n"; return false;
  74.         }
  75.         for (int i = 0; i < ileZnakow; i++)
  76.         {
  77.                 if (!isdigit(pin1[i]))
  78.                 {
  79.                         cout << "Musza byc tylko cyfry!!\n"; return false;
  80.                 }
  81.         }
  82.         for (int i = 0; i < ileZnakow; i++)
  83.         {
  84.                 for (int j = i + 1; j < ileZnakow; j++)
  85.                 if (pin1[i] == pin1[j])
  86.                 {
  87.                         cout << "Znaki powtarzaja sie!\n"; return false;
  88.                 }
  89.         }
  90.         return true;
  91. }
  92.  
  93.  
  94. //*****************************
  95. bool czyZawiera(char napis[], char znak)
  96. {
  97.         int i = 0;
  98.         while (napis[i] != '\0')
  99.         {
  100.                 if (napis[i] == znak)
  101.                         return true;
  102.                 i++;
  103.         }
  104.         return false;
  105. }
  106. //*****************************
  107. bool czyPowtorzone(char napis[])
  108. {
  109.         int ileZnakow = strlen(napis);
  110.         for (int i = 0; i < ileZnakow; i++)
  111.         {
  112.                 for (int j = i + 1; j < ileZnakow; j++)
  113.                 if (napis[i] == napis[j])
  114.                         return true;
  115.         }
  116.         return false;
  117. }
  118. //*****************************
  119. bool czyOK1(char haslo[])
  120. //Funkcja sprawdza czy zostało podane prawidłowe hasło
  121. //prawidłowa liczba znaków >6, W hasle nie mogą wystapić znaki :!@#$%^&*() {} ? <>  
  122. //znaki w hasle nie mogą się powtarzac
  123. //pozostałe znaki sa dozwolone
  124. {
  125.         char zabronione[] = "!@#$%^&*(){}?<>";
  126.         int ileZnakow = strlen(haslo);
  127.         if (ileZnakow <= 6)
  128.         {
  129.                 cout << "zla liczba znakow!!\n";
  130.                 return false;
  131.         }
  132.         for (int i = 0; i < ileZnakow; i++)
  133.         {
  134.                 if (czyZawiera(zabronione, haslo[i]))
  135.                 {
  136.                         cout << "Zabronione znaki w hasle!!!\n";
  137.                         return false;
  138.                 }
  139.         }
  140.         if (czyPowtorzone(haslo))
  141.         {
  142.                 cout << "Powtorzone znaki w hasle!!\n";
  143.                 return false;
  144.         }
  145.         cout << "OK\n";
  146.         return true;
  147. }
  148.  
  149. bool czyNalezy(vector<int>liczby, int liczba)
  150. {
  151.         for (int i = 0; i < liczby.size(); i++)
  152.         {
  153.                 if (liczby[i] == liczba)
  154.                 {
  155.                         return true;
  156.                 }
  157.         }
  158.         return false;
  159. }
  160.  
  161. int f1(vector<int>liczby)
  162. {
  163.         vector<int>wynik;
  164.         for (int i = 0; i < liczby.size(); i++)
  165.         {
  166.                 if (!czyNalezy(wynik, liczby[i]))
  167.                 {
  168.                         wynik.push_back(liczby[i]);
  169.                 }
  170.         }
  171.         return wynik.size();
  172. }
  173. //*****************************
  174. char litera()
  175. {
  176.         char znak;
  177.         int licznik = 0;
  178.         do{
  179.                 cout << "wprowadz znak: ";
  180.                 cin >> znak;
  181.                 if (isupper(znak)) licznik++;
  182.                 if (islower(znak)) licznik++;
  183.         } while (licznik == 0);
  184.         return znak;
  185. }
  186. //*****************************
  187. int liczba()
  188. {
  189.         char liczby;
  190.         do{
  191.                 cout << "wpisz liczbe dodatnia: ";
  192.                 cin >> liczby;
  193.         } while (liczby < 0);
  194.         return liczby;
  195. }
  196. //*****************************
  197. bool czypierwsza(int liczba)
  198. {
  199.         int licznik = 0;
  200.         for (int i = 1; i < liczba; i++)
  201.         {
  202.                 if (liczba % i == 0) licznik++;
  203.         }
  204.         if (licznik > 2) return false;
  205.         return true;
  206. }
  207. //*****************************
  208. bool CzyOK(char haslo[])
  209. {
  210.         cout << litera();
  211.         int ileZnakow = strlen(haslo);
  212.         int ileM = 0;
  213.         int ileD = 0;
  214.         int ileC = 0;
  215.         if (ileZnakow <= 5 || ileZnakow >= 10) return false;
  216.         int i = 0;
  217.         while (haslo[i] != '\0')
  218.         {
  219.                 if (isdigit(haslo[i])) ileC++;
  220.                 if (isupper(haslo[i])) ileD++;
  221.                 if (islower(haslo[i])) ileM++;
  222.                 i++;
  223.         }
  224.         if (ileM + ileD + ileC != ileZnakow)
  225.         {
  226.                 return false;
  227.         }
  228.         for (int i = 0; i < ileZnakow; i++)
  229.         {
  230.                 for (int j = i + 1; j < ileZnakow; j++)
  231.                 {
  232.                         if (haslo[i] == haslo[j]) return false;
  233.                 }
  234.         }
  235.         return true;
  236. }
  237.  
  238. int zad5(int liczba)
  239. //Funkcja zwraca w wynku sume cyfr  liczby podaj jako parametr
  240. {
  241.         int suma = 0;
  242.         do
  243.         {
  244.                 suma += liczba % 10;
  245.                 liczba /= 10;
  246.         } while (liczba > 0);
  247.         return suma;
  248. }
  249.  
  250. bool czyNalezy(int tablica[], int rozmiar, int wartosc)
  251. //Sprawdza czy wartosc, przekazana jako parametr, jest jednym z elementów tablicy
  252. {
  253.         for (int i = 0; i < rozmiar; i++)
  254.         if (tablica[i] == wartosc)
  255.                 return true;
  256.         return false;
  257. }
  258.  
  259. bool czyZawiera(int tablica1[], int rozmiar1, int tablica2[], int rozmiar2)
  260. //sprawdza czy wszystkie elementy tablica2 są elementami tablica1
  261. {
  262.         for (int i = 0; i < rozmiar2; i++)
  263.         {
  264.                 if (!czyNalezy(tablica1, rozmiar1, tablica2[i]))
  265.                         return false;
  266.         }
  267.         return true;
  268. }
  269. void unikalnosc(int tablica[], int tmp[], int rozmiar)
  270. {
  271.         int j = 0;
  272.         for (int i = 0; i < rozmiar; i++)tmp[i] = -1;
  273.         for (int i = 0; i < rozmiar; i++)
  274.         {
  275.                 if (!czyNalezy(tmp, rozmiar, tablica[i]))
  276.                 {
  277.                         tmp[j] = tablica[i]; j++;
  278.                         //cout << tablica[i] << endl;
  279.                         //mogę wypisywać lub nie, w zależności od założeń
  280.                 }
  281.         }
  282. }
  283.  
  284.  
  285. int _tmain(int argc, _TCHAR* argv[])
  286. {
  287.         vector<int>liczby;
  288.         liczby.push_back(5);
  289.         liczby.push_back(8);
  290.         liczby.push_back(4);
  291.         liczby.push_back(5);
  292.         liczby.push_back(1);
  293.         liczby.push_back(8);
  294.         liczby.push_back(9);
  295.         liczby.push_back(1);
  296.         liczby.push_back(5);
  297.         cout << liczba();
  298.         //cout << f1(liczby);
  299.         //char haslo[] = "QWERTY11";
  300.         //cout << czypierwsza(6);
  301.         //cout << CzyOK(haslo);
  302.         system("pause");
  303.         return 0;
  304. }
  305.  
  306.  
Parsed in 0.056 seconds