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.