Facebook
From ss, 3 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 309
  1. // Napisz funkcj─Ö, kt├│ra otrzymuje dwa argumenty : nieujemn─ů liczb─Ö ca┼ékowit─ů n oraz nelementow─ů
  2. // tablic─Ö tab element├│w typu int i wykonuje po sobie nast─Öpuj─ůce operacje :
  3. // a) nadaje warto┼Ť─ç zero wszystkim elementom tablicy tab,
  4. // b) zapisuje do kolejnych element├│w tablicy warto┼Ťci r├│wne ich indeksom(do kom├│rki
  5. // o indeksie i funkcja ma zapisywa─ç warto┼Ť─ç i),
  6. // c) podwaja warto┼Ť─ç wszystkich element├│w w tablicy tab,
  7. // d) do wszystkich kom├│rek tablicy tab wstawia przeciwie┼ästwo ich pierwotnych warto┼Ťci.
  8.  
  9. //#include <iostream>
  10. //using namespace std;
  11. //
  12. //void funkcja(unsigned int n, int * tab)
  13. //{
  14. //      for (int i = 0; i < n; ++i)
  15. //      {
  16. //              tab[i] = 0;
  17. //      }
  18. //      for (int i = 0; i < n; ++i)
  19. //      {
  20. //              tab[i] = i;
  21. //      }
  22. //      for (int i = 0; i < n; ++i)
  23. //      {
  24. //              tab[i] = 2 * tab[i];
  25. //      }
  26. //      for (int i = 0; i < n; ++i)
  27. //      {
  28. //              tab[i] = -tab[i];
  29. //      }
  30. //}
  31. //
  32. //int main(int argc, char *argv[])
  33. //{
  34. //      int n;
  35. //      cin >> n;
  36. //      int * tab = new int[n];
  37. //      funkcja(n, tab);
  38. //      cout << tab[n-1];
  39. //      system("pause");
  40. //      return 0;
  41. //}
  42.  
  43. // Napisz funkcj─Ö, kt├│ra otrzymuje dwa argumenty: dodatni─ů liczb─Ö ca┼ékowit─ů n oraz nelementow─ů
  44. // tablic─Ö tab o elementach typu int i zwraca jako warto┼Ť─ç :
  45. // a) ┼Ťredni─ů arytmetyczn─ů element├│w tablicy tab.
  46. // b) sum─Ö element├│w tablicy tab,
  47. // c) sum─Ö kwadrat├│w element├│w tablicy tab.
  48. //
  49.  
  50. //#include <iostream>
  51. //using namespace std;
  52. //
  53. //double funkcja1(int n, int * tab)
  54. //{
  55. //      int suma = 0;
  56. //      for (int i = 0; i < n; ++i)
  57. //      {
  58. //              suma += tab[i];
  59. //      }
  60. //      return (suma / n);
  61. //}
  62. //int funkcja2(int n, int * tab)
  63. //{
  64. //      int suma = 0;
  65. //      for (int i = 0; i < n; ++i)
  66. //      {
  67. //              suma += tab[i];
  68. //      }
  69. //      return suma;
  70. //}
  71. //int funkcja3(int n, int * tab)
  72. //{
  73. //      int suma = 0;
  74. //      for (int i = 0; i < n; ++i)
  75. //      {
  76. //              suma += tab[i]*tab[i];
  77. //      }
  78. //      return suma;
  79. //}
  80. //
  81. //int main(int argc, char * argv[])
  82. //{
  83. //      int n;
  84. //      cin >> n;
  85. //      int * tab = new int[n];
  86. //      for (int i = 0; i < n; ++i) tab[i] = i;
  87. //
  88. //      cout << funkcja1(n, tab) << endl;
  89. //      cout << funkcja2(n, tab) << endl;
  90. //      cout << funkcja3(n, tab) << endl;
  91. //      system("pause");
  92. //      return 0;
  93. //}
  94.  
  95. // Napisz program, kt├│ry odwraca losow─ů wype┼énion─ů tablic─Ö, tab[m][m]
  96.  
  97. //#include <iostream>
  98. //#include <ctime>
  99. //using namespace std;
  100. //
  101. //int main()
  102. //{
  103. //      // stworzy─ç tablic─Ö mm
  104. //      int m = 0;
  105. //      cin >> m;
  106. //      int ** tab = new int*[m];
  107. //      for (int i = 0; i < m; i++) tab[i] = new int[m];
  108. //
  109. //      // wype┼éni─ç losowo tablic─Ö
  110. //      srand(time(NULL));
  111. //
  112. //      for (int i = 0; i < m; i++)
  113. //      {
  114. //              for (int j = 0; j < m; j++)
  115. //              {
  116. //                      tab[i][j] = rand() % 100;
  117. //              }
  118. //      }
  119. //
  120. //      // odwr├│ci─ç tablic─Ö
  121. //      int temp;
  122. //      for (int i = 0; i < m; i++)
  123. //      {
  124. //              for (int j = 0; j < m; j++)
  125. //              {
  126. //                      temp = tab[i][j];
  127. //                      tab[i][j] = tab[j][i];
  128. //                      tab[j][i] = temp;
  129. //                      // cout << tab[i][j] << " ";
  130. //              }
  131. //              // cout << endl;
  132. //      }
  133. //      // system("pause");
  134. //
  135. //      return 0;
  136. //}
  137.  
  138. // 4. Napisz funkcj─Ö, kt├│ra otrzymuje dwa argumenty : dodatni─ů liczb─Ö ca┼ékowit─ů n oraz nelementow─ů
  139. // tablic─Ö tab o elementach typu double a nast─Öpnie tworzy kopi─Ö tablicy tab
  140. // i zwraca jako warto┼Ť─ç wska┼║nik do nowo utworzonej kopii.
  141.  
  142. // 5. Napisz program, który przechowuje w tablicy figury złożone z gwiazdek(kwadrat,
  143. // prostok─ůt, tr├│jk─ůt)
  144.  
  145. // 6. Napisz funkcj─Ö, kt├│ra otrzymuje dwa argumenty : dodatni─ů liczb─Ö ca┼ékowit─ů n oraz nelementow─ů
  146. // tablic─Ö tab o elementach typu int i :
  147. // a) zwraca najwi─Öksz─ů warto┼Ť─ç przechowywan─ů w tablicy tab,
  148. // b) zwraca najmniejsz─ů warto┼Ť─ç przechowywan─ů w tablicy tab,
  149. // c) zwraca indeks elementu tablicy tab o najwi─Ökszej warto┼Ťci,
  150. // d) zwraca indeks elementu tablicy tab o najmniejszej warto┼Ťci,
  151.  
  152. // Napisz funkcj─Ö otrzymuj─ůc─ů jako argumenty referencje do dw├│ch zmiennych typu int, kt├│ra
  153. // zamienia ze sob─ů warto┼Ťci zmiennych, do kt├│rych referencje dostali┼Ťmy w argumentach.
  154.  
  155. //2) Napisz funkcj─Ö otrzymuj─ůc─ů jako argumenty wska┼║niki do dw├│ch zmiennych typu int, kt├│ra
  156. //zamienia ze sob─ů warto┼Ťci wskazywanych zmiennych tylko wtedy, gdy wskazywana przez
  157. //drugi argument zmienna jest mniejsza od zmiennej wskazywanej przez pierwszy argument.
  158.  
  159. //3) Napisz funkcj─Ö, kt├│ra dostaje jako argument dodatni─ů liczb─Ö ca┼ékowit─ů n, rezerwuje w
  160. //pami─Öci blok n zmiennych typu int i zwraca jako warto┼Ťd wska┼║nik do pocz─ůtku
  161. //zarezerwowanego bloku pami─Öci(tworzenie dynamicznej tablicy 1D).Prze┼éaduj utworzon─ů
  162. //funkcję tak aby alokowała ona pamięd dla tablicy 2D.
  163.  
  164. //4) Napisz funkcj─Ö, kt├│ra przyjmuje dwa argumenty :
  165. //ÔÇö wska┼║nik na funkcj─Ö o jednym argumencie typu int N zwracaj─ůc─ů warto┼Ťd typu double
  166. //ÔÇö warto┼Ťd typu int,
  167. //Funkcja ma zwracad warto┼Ťd funkcji otrzymanej w pierwszym argumencie dla liczby
  168. //całkowitej podanej w drugim argumencie.
  169. //Wywo┼éaj utworzon─ů funkcj─Ö przekazuj─ůc jako argument wska┼║nik na funkcj─Ö zwracaj─ůc─ů
  170. //(2.45^N),
  171.  
  172. //5) Napisz funkcj─Ö, kt├│ra otrzymuje trzy argumenty : dodatni─ů liczb─Ö ca┼ékowit─ů n oraz dwie tablice
  173. //n - elementowe o elementach typu int przechowuj─ůce wsp├│┼érz─Ödne wektor├│w i zwraca jako
  174. //warto┼Ťd wska┼║nik do pierwszego elementu nowo utworzonej tablicy przechowuj─ůcej sum─Ö
  175. //wektor├│w w otrzymanych w argumentach.
  176.  
  177. //6) Napisz funkcj─Ö, kt├│ra otrzymuje trzy argumenty : dodatni─ů liczb─Ö ca┼ékowit─ů n, n elementow─ů
  178. //tablic─Ö tab o elementach typu int, liczb─Ö ca┼ékowit─ů wybor i w zale┼╝no┼Ťci od zmiennej wybor :
  179. //a) odwraca kolejno┼Ťd element├│w tablicy tab.
  180. //b) przesuwa o jeden w lewo wszystkie elementy tablicy(tak, ┼╝eby warto┼Ťd elementu o
  181. //indeksie n Ôłĺ 1 znalaz┼éa si─Ö w elemencie o indeksie nÔłĺ2, warto┼Ťd elementu o indeksie nÔłĺ2
  182. //znalaz┼éa si─Ö w elemencie o indeksie n Ôłĺ 3, za┼Ť warto┼Ťd elementu o indeksie 0 w elemencie o
  183. //indeksie n Ôłĺ 1),
  184. //c) przesuwa o jeden w prawo wszystkie elementy tablicy(tak, ┼╝eby warto┼Ťd elementu o
  185. //indeksie 0 znalaz┼éa si─Ö w elemencie o indeksie 1, warto┼Ťd elementu o indeksie 1 znalaz┼éa si─Ö w
  186. //elemencie o indeksie 2, za┼Ť warto┼Ťd elementu o indeksie n Ôłĺ 1 w elemencie o indeksie 0),
  187.  
  188. //1. Zdefiniuj struktur─Ö tr├│jk─ůt przechowuj─ůc─ů d┼éugo┼Ťci bok├│w tr├│jk─ůta.
  189. //´éĚ Napisz funkcj─Ö, kt├│ra otrzymuje jako argument zmienn─ů typu struct tr├│jk─ůt, i
  190. //zwraca jako warto┼Ť─ç obw├│d tr├│jk─ůta przekazanego w argumencie.
  191. //´éĚ Napisz funkcj─Ö, kt├│ra otrzymuj─Ö jago argument wska┼║nik typu struct tr├│jk─ůt i
  192. //zwraca jako warto┼Ť─ç pole tr├│jk─ůta.
  193.  
  194. //2. Stw├│rz struktur─Ö okr─ůg sk┼éadaj─ůc─ů si─Ö z trzech liczb rzeczywistych x, y oraz r oraz
  195. //jednej funkcji ÔÇ×wprowad┼║ÔÇŁ(funkcja dostaje jako argumenty trzy warto┼Ťci i wpisuje je
  196. //do zmiennych x, y oraz r).Napisz globaln─ů funkcj─Ö, kt├│ra jako argumenty przyjmuje
  197. //dwa okr─Ögi i zwraca prawd─Ö je┼Ťli okr─Ögi s─ů styczne zewn─Ötrznie.
  198. //Wz├│r na d┼éugo┼Ť─ç odcinka :
  199.  
  200. //3. Napisz funkcj─Ö, kt├│ra otrzymuje jako argumenty tablice tab1 i tab2 o argumentach
  201. //typu struct punkt zdefiniowanego w rozwi─ůzaniu zadania 1 oraz ich rozmiar, i
  202. //przepisuje zwarto┼Ť─ç tablicy tab1 do tablicy tab2.
  203.  
  204. //4. Stw├│rz struktur─Ö punkt reprezentuj─ůc─ů punkt w n wymiarowej przestrzeni(struktura
  205. //powinna zawierać dwa elementy : rozmiar przestrzeni oraz tablicę współrzędnych).
  206. //Napisz funkcj─Ö sk┼éadowe : Funkcja umo┼╝liwiaj─ůca wprowadzenie wsp├│┼érz─Ödnych z
  207. //klawiatury, funkcja wypisuj─ůca wsp├│┼érz─Ödne na ekranie, funkcj─Ö wykonuj─ůc─ů symetri─Ö
  208. //┼Ťrodkow─ů wzgl─Ödem zadanego punktu.
  209.  
  210. //5. Zdefiniuj struktur─Ö los.Struktura powinna zawiera─ç tablic─Ö 1D oraz funkcj─Ö losuj
  211. //(funkcja alokuje losow─ů wielko┼Ť─ç tablicy maksymalnie 100000 i wype┼énia j─ů
  212. //losowymi elementami).Ponadto struktura powinna zawiera─ç funkcj─Ö wypisz
  213. //(wypisuj─ůc─ů losow─ů ilo┼Ť─ç, losowych wybranych element├│w).
  214.  
  215.  
  216. //int main(int argc, char* argv[]){}
  217. //1. Napisz program witam, kt├│ry przyjmuje jako argumenty funkcji main twoje imi─Ö,
  218. //nazwisko, kierunek oraz rok.Program powinien wy┼Ťwietli─ç pobrane informacj─Ö w
  219. //formacie :
  220. //Witam :
  221. /// Imi─Ö : / ÔÇŽ..
  222. /// Nazwisko : / ÔÇŽ.
  223. /// Kierunek : / ÔÇŽ.
  224. /// Rok : / ÔÇŽ.
  225.  
  226. //2. Napisz program, kt├│ry liczy ┼Ťredni─ů arytmetyczn─ů N liczb z przedzia┼éu <a : b>, rozmiar
  227. //N jak i zmienne a, b powinny zostać przesłanie jako argumenty funkcji main.
  228. //Tablice wielowymiarowe :
  229.  
  230. //3. Napisz funkcj─Ö, kt├│ra dostaje jako argumenty : kwadratow─ů tablic─Ö 2D tab o
  231. //elementach typu int, jej wymiar N, oraz zmienna M.Funkcja tworzy now─ů tablic─Ö
  232. //typu double do kt├│rej wpisuje warto┼Ťci z tablicy tab, w taki spos├│b, ┼╝e wiersze o
  233. //numerze mniejszym od M przepisywane s─ů normalnie, a w pozosta┼ée elementy
  234. //wpisane s─ů warto┼Ťci r├│wne tab[i][j] / 2. Tak utworzon─ů tablic─Ö funkcja zwraca za
  235. //pomoc─ů wska┼║nika.
  236.  
  237. //4. Napisz program kółko i krzyżyk(dla dwóch graczy).Program powinien zawierać
  238. //funkcj─Ö do:
  239. //´éĚ Wykonywania ruchu
  240. //´éĚ Sprawdzenia wygranej
  241. //´éĚ Czyszczenia planszy
  242. //´éĚ Wy┼Ťwietlania planszy np. :
  243. //_ | _ | _ _ | X | _
  244. //_ | _ | _ _ | _ | X
  245. //_ | _ | _ O | O | _
  246. //Plansza przechowywana jest w tablicy char├│w[3][3].Ruchy gracza 1 powinny zosta─ç
  247. //pokazywane za pomoc─ů X, natomiast gracza 2 za pomoc─ů O