API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 20th, 2017
269
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 27.96 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <iomanip>
  3. #include <math.h>
  4.  
  5.  
  6. using namespace std;
  7.  
  8. //Napišite program, poštujući sve faze procesa programiranja,
  9. //koji će ispisati sve četveroznamenkaste brojeve kojima su :
  10. //sve znamenke neparne i ne sadrži znamenku 0.
  11.  
  12. //int main()
  13. //{
  14. // bool ispunjeno = false;
  15. // int help = 0;
  16. // for (int i = 1000; i < 10000; i++)
  17. // {
  18. // help = i;
  19. // while (help > 0)
  20. // {
  21. // if (help % 2 == 0)
  22. // {
  23. // ispunjeno = false;
  24. // break;
  25. // }
  26. // else
  27. // {
  28. // ispunjeno = true;
  29. // help /= 10;
  30. // }
  31. // }
  32. // if (ispunjeno)
  33. // {
  34. // cout << i << endl;
  35. // }
  36. // }
  37. //
  38. // system("pause>0");
  39. // return 0;
  40. //}
  41.  
  42. /*Zadatak 2
  43. Napišite program koji će korisniku omogućiti unos znakova s tastature.
  44. Unos znakova se prekida kad korisnik unese znak „0“.
  45. Program treba prebrojati i ispisati koliko je među unesenim znakovima bilo malih slova,
  46. koliko velikih slova i koliko je među unesenim znakovima bilo onih koji nisu slova
  47. (interpunkcijski znakovi, znamenke, zagrade i sl.)*/
  48.  
  49. //void main()
  50. //{
  51. // int malaSlova = 0, velikaSlova = 0, ostaliZnakovi = 0;
  52. // char a;
  53. //
  54. // do
  55. // {
  56. // cout << "Unijeti slovo/znak: " << endl;
  57. // cin >> a;
  58. // if(a >= 65 && a <= 90)
  59. // velikaSlova++;
  60. // else if (a >= 97 && a <= 122)
  61. // malaSlova++;
  62. // else
  63. // ostaliZnakovi++;
  64. //
  65. // } while (a != '0');
  66. //
  67. // cout << "Velikih slova je: " << velikaSlova << endl;
  68. // cout << "Malih slova je: " << malaSlova << endl;
  69. // cout << "Ostalih znakova je: " << ostaliZnakovi << endl;
  70. //
  71. //
  72. // system("pause");
  73. //}
  74.  
  75. /*Zadatak 3
  76. Napišite program kojim se za uneseni datum(dan, mjesec i godina)
  77. određuje koji je to redni broj dana u godini.Voditi računa da godina može biti i prijestupna.
  78. Omogućiti korisniku da ponavlja unos datuma.
  79. Npr: ako korisnik unese 15 3 2015 program treba ispisati uneseni dan je 74. dan u 2015 godini.*/
  80.  
  81. //void main()
  82. //{
  83. //
  84. // int dan = 0, mjesec, godina;
  85. // char ponoviti = 'n';
  86. // bool prijestupnaGodina = true;
  87. // do {
  88. // cout << "Upisite dan/mjesec/godinu!" << endl;
  89. // cin >> dan >> mjesec >> godina;
  90. //
  91. // prijestupnaGodina = (godina % 4 == 0 && godina % 100 != 0) || (godina % 100 == 0 && godina % 400 == 0);
  92. //
  93. // for (int i = 1; i <= mjesec - 1; i++) {
  94. //
  95. // switch (i)
  96. // {
  97. // case 1:
  98. // case 3:
  99. // case 5:
  100. // case 7:
  101. // case 8:
  102. // case 10:
  103. // case 12: dan += 31;
  104. // break;
  105. // case 2: if (prijestupnaGodina)
  106. // dan += 29;
  107. // else
  108. // dan += 28;
  109. // break;
  110. // default: dan += 30;
  111. // break;
  112. // }
  113. // }
  114. // cout << "Uneseni dan je " << dan << ". dan u " << godina << " godini!" << endl;
  115. // cout << "Ponoviti ? d|n :";
  116. // cin >> ponoviti;
  117. // } while (ponoviti == 'D' || ponoviti == 'd');
  118. //}
  119.  
  120. /*Učitati članove niza.Izračunati aritmetičku sredinu i ispisati sumu članova niza
  121. većih od aritmetičke sredine sa neparnim indeksom.*/
  122.  
  123. //void main()
  124. //{
  125. // int niz[10] = { 3,5,6,2,7,8,3,6,2 };
  126. // float arit_sr = 0;
  127. // int suma = 0;
  128. //
  129. // cout << "Clanovi niza su: " << endl;
  130. // for (int i = 0; i < 10; i++)
  131. // {
  132. // cout <<setw(4)<<niz[i];
  133. // arit_sr += niz[i];
  134. // }
  135. // cout << endl;
  136. // arit_sr /= 10;
  137. // cout << "Aritmeticka sredina niza: " << arit_sr << endl;
  138. //
  139. //
  140. // cout << "Suma clanova niza vecih od aritmeticke sredine sa neparnim indexom niza: ";
  141. // for (int i = 0; i < 10; i++)
  142. // {
  143. // if (i % 2 != 0 && niz[i]>arit_sr)
  144. // {
  145. // suma += niz[i];
  146. // }
  147. // }
  148. // cout << suma << endl;
  149. //
  150. //
  151. //
  152. // system("pause");
  153. //}
  154.  
  155. //void main()
  156. //{
  157. /*int niz[10] = { 5,10,20,50,40,31,32,88,52,9 };
  158. bool promjena = true;
  159. int a = 9;
  160.  
  161. while (promjena)
  162. {
  163. promjena = false;
  164. for (int i = 0; i < a; i++)
  165. {
  166. int privremeni;
  167. if (niz[i] > niz[i + 1])
  168. {
  169. privremeni = niz[i];
  170. niz[i] = niz[i + 1];
  171. niz[i + 1] = privremeni;
  172. promjena = true;
  173. }
  174. }
  175. for (int i = 0; i < 10; i++)
  176. {
  177. cout << setw(4) << niz[i];
  178. }
  179. cout << endl;
  180. }*/
  181.  
  182. //int counter = 0;
  183. //int niz[100];
  184. //int n;
  185. //cin >> n;
  186. //int m = 0;
  187. //for (int i = 2; i < 10; i++)
  188. //{
  189. // for (int j = 2; j < 10; j++)
  190. // {
  191. // m = pow(i, j);
  192. // if (m >= n)
  193. // {
  194. // niz[counter] = m;
  195. // cout << m << "=" << i << "^" << j << endl;
  196. // counter++;
  197. // }
  198.  
  199. // }
  200.  
  201. //}
  202. //cout << endl << endl << endl;
  203. ///*for (int l = 0; l < counter; l++)
  204. //{
  205. // cout << niz[l] << endl;
  206. //}*/
  207.  
  208. //for (int i = 0; i<counter; i++) {
  209. // int min = niz[i];
  210. // int position = i;
  211. // for (int k = i + 1; k<counter; k++) {
  212. // if (min > niz[k]) {
  213. // min = niz[k];
  214. // position = k;
  215. // }
  216. // }
  217. // int temp = niz[i];
  218. // niz[i] = niz[position];
  219. // niz[position] = temp;
  220. //}
  221.  
  222.  
  223. //cout << niz[1];
  224.  
  225. //Napisati program koji će omogućiti :
  226. //• Unos 2D niza od 10x10 elemanata vodeći računa da su svi elementi dvocifreni(ukoliko unos nekog elementa ne zadovoljava uslov, ponavljati unos tog elementa dok se ne zadovolji uslov) – Koristiti funkciju unos
  227. //• Izvršiti transpoziciju niza tako što će se zamjeniti redovi i kolone – Koristiti funkciju transpose, a zatim na osnovu izmijenjenog 2D niza :
  228. //• Izračunati aritmetičku sredinu svih prostih brojeva ispod sporedne dijagonale – Koristiti dvije funkcije : aritmeticka i prost_broj(pozivati će se iz funkcije aritmeticka)
  229. //• Napisati funkciju simpatican koja će provjeriti da li su brojevi iznad sporedne dijagonale simpatični*.
  230. //Obavezno koristiti navedene funkcije, a parametre i eventualne povratne vrijednosti definisati prema potrebi.U main() funkciji napisati testni program koji će omogućiti izvršenje svih funkcija navedenim redoslijedom.
  231.  
  232. //Transpozicija 2D niza od 4x4 elementa
  233. //
  234. //Pomoć : Broj je simpatičan ukoliko je zbir cifara njegovog kvadrata jednak kvadratu zbira njegovih cifara.Broj 21 je simpatičan jer je s(421) = s(21) * s(21) pri čemu je s(n) zbir cifara prirodnog broja n.
  235.  
  236. //void unos(int niz[][10])
  237. //{
  238. // for (int i = 0; i < 10; i++)
  239. // {
  240. // for (int j = 0; j < 10; j++)
  241. // {
  242. // do
  243. // {
  244. // cin >> niz[i][j];
  245. // } while (niz[i][j] < 10 && niz[i][j]>99);
  246. // }
  247. // cout << endl;
  248. // }
  249. //}
  250. //void transpose(int niz[][10])
  251. //{
  252. // for (int i = 0; i < 10; i++)
  253. // {
  254. // for (int j = 0; j < 10; j++)
  255. // {
  256. // cout<<setw(4)<<niz[j][i];
  257. // }
  258. // cout << endl;
  259. // }
  260. //}
  261. //bool prost(int n)
  262. //{
  263. // bool prost = true;
  264. // int i = 2;
  265. // do
  266. // {
  267. // if (n%i == 0)
  268. // {
  269. // prost = false;
  270. // break;
  271. // }
  272. // i++;
  273. // } while (i <= n / 2);
  274. // if (prost = false)
  275. // {
  276. // return true;
  277. // }
  278. // else
  279. // {
  280. // return false;
  281. // }
  282. //}
  283. //void aritmeticka(int niz[][10])
  284. //{
  285. // int brojac = 0, aritmeticka = 0;
  286. // for (int i = 0; i < 10; i++)
  287. // {
  288. // for (int j = 0; j < 10; j++)
  289. // {
  290. // while (i + j > 9)
  291. // {
  292. // if (niz[j][i] == prost)
  293. // {
  294. //
  295. // }
  296. // }
  297. // }
  298. // }
  299. //}
  300. //
  301. //void main()
  302. //{
  303. // int matrica[10][10];
  304. // cout << "Unijeti dvocifrene elemente matrice: " << endl;
  305. // unos(matrica);
  306. // cout << "---------------------------------------------------------------------" << endl;
  307. // cout << "Transponovana matrica: " << endl;
  308. // transpose(matrica);
  309. // cout << "---------------------------------------------------------------------" << endl;
  310. // cout << "Sporedna dijagonala: ";
  311. // for (int i = 0; i < 10; i++)
  312. // {
  313. // for (int j = 0; j < 10; j++)
  314. // {
  315. // if (i + j > 9)
  316. // {
  317. // cout << setw(4) << matrica[i][j];
  318. // }
  319. // }
  320. // }
  321. // cout << endl;
  322. // cout << "Aritmeticka sredina prostih brojeva ispod sporedne dijagonale transponovane matrice je: " << endl;
  323. // aritmeticka(matrica);
  324. //void zamjena(int mat[])
  325. //{
  326. // int pom[3];
  327. // for (int i = 0; i < 3; i++)
  328. // {
  329. // pom[i] = mat[i];
  330. // }
  331. // for (int i =2; i>=0; i--)
  332. // {
  333. // mat[i] = pom[i];
  334. // }
  335. // for (int i = 2; i >=0; i--)
  336. // {
  337. // cout << setw(3) << mat[i];
  338. // }
  339. // cout << endl;
  340. //}
  341. //
  342. //
  343.  
  344. //{
  345. // int matrica[3] = { 1,2,3};
  346. // for (int i = 0; i < 3; i++)
  347. // {
  348. // cout << setw(4) << matrica[i];
  349. //
  350. //
  351. // }
  352. // cout << endl;
  353. // zamjena(matrica);
  354.  
  355. //void potencija(int niz[], int brojacx, int n, int m)
  356. //{
  357. // bool promjena = true;
  358. // int brojac = 0;
  359. // for (int i = 2; i < 10; i++)
  360. // {
  361. // for (int j = 2; j < 10; j++)
  362. // {
  363. // m = pow(i, j);
  364. // if (m >= n)
  365. // {
  366. // niz[brojac] = m;
  367. // cout << " " << niz[brojac];
  368. // brojac++;
  369. // }
  370. // }
  371. // cout << endl;
  372. // }
  373. // cout << endl;
  374. // cout << "Broj prolaza, tj. broj elemenata u nizu: " << endl;
  375. // cout << brojac << endl;
  376. //
  377. // while (promjena)
  378. // {
  379. // promjena = false;
  380. // for (int i = 0; i < brojac - 1; i++)
  381. // {
  382. // int test;
  383. // if (niz[i] > niz[i + 1])
  384. // {
  385. // test = niz[i];
  386. // niz[i] = niz[i + 1];
  387. // niz[i + 1] = test;
  388. // promjena = true;
  389. // }
  390. // }
  391. // /*for (int i = 0; i < brojac; i++)
  392. // {
  393. // cout <<" "<<niz[i];
  394. // }
  395. // cout << endl;*/
  396. // }
  397. // cout << endl;
  398. // cout << "Trazeni rezultat: " << endl;
  399. // for (int i = 0; i < 1; i++)
  400. // {
  401. // cout << niz[i] << endl;
  402. // }
  403. //}
  404. //
  405. //void main()
  406. //{
  407. // int niz[100];
  408. // int brojac = 0, n, m = 0;
  409. //
  410. // cout << "Unijeti prirodan broj: " << endl;
  411. // cin >> n;
  412. // potencija(niz, brojac, n, m);
  413. //
  414. // system("pause");
  415. //}
  416. //void unos(int niz[])
  417. //{
  418. // for (int i = 0; i < 6; i++)
  419. // {
  420. // cin >> niz[i];
  421. // }
  422. //}
  423. //
  424. //void pronaci(int niz[], int a)
  425. //{
  426. // bool promjena = true;
  427. // int smjena = 5;
  428. // while (promjena)
  429. // {
  430. // promjena = false;
  431. // for (int i = 0; i < smjena; i++)
  432. // {
  433. // int testna;
  434. // if (niz[i] > niz[i + 1])
  435. // {
  436. // testna = niz[i];
  437. // niz[i] = niz[i + 1];
  438. // niz[i + 1] = testna;
  439. // promjena = true;
  440. // }
  441. // }
  442. // }
  443. // for (int i = 4; i < 6; i++)
  444. // {
  445. // cout << " / " << niz[i];
  446. // }
  447. //}
  448. //float suma(int niz[], int x)
  449. //{
  450. // float suma = 0;
  451. // for (int i = 0; i < x; i++)
  452. // {
  453. // suma += (1.0/niz[i]);
  454. // }
  455. // return suma;
  456. //}
  457. //int prebroji(int niz[], int y)
  458. //{
  459. // int brojac = 0;
  460. // for (int i = 0; i < y; i++)
  461. // {
  462. // if (niz[i] > 0)
  463. // {
  464. // brojac++;
  465. // cout << " " << niz[i] << " Broj indexa " << i;
  466. // }
  467. // }
  468. // cout << endl;
  469. // return brojac;
  470. //}
  471. //
  472. //void main()
  473. //{
  474. // const int vel_niza = 6;
  475. // int niz[vel_niza];
  476. // cout << "Unijeti elemente: " << endl;
  477. // unos(niz);
  478. // cout << "Dva najveca elementa niza: " << endl;
  479. // pronaci(niz, vel_niza);
  480. // cout << endl;
  481. // cout << "Suma reciprocnih vrijednosti elemenata niza: " << endl;
  482. // cout<<suma(niz, vel_niza);
  483. // cout << endl;
  484. // cout << "Pozitivni elementi sa indexom i kolicina: " << endl;
  485. // prebroji(niz, vel_niza);
  486. // cout << endl;
  487. //
  488. // system("pause>0");
  489. //}
  490.  
  491. //int obratno(int broj)
  492. //{
  493. // int povratni = 0;
  494. // do
  495. // {
  496. // povratni = povratni * 10 + broj % 10;
  497. // broj /= 10;
  498. //
  499. // } while (broj > 0);
  500. //
  501. // return povratni;
  502. //}
  503. //
  504. //void unos(int matrica[][4])
  505. //{
  506. // for (int i = 0; i < 4; i++)
  507. // {
  508. // for (int j = 0; j < 4; j++)
  509. // {
  510. // if (i % 2 == 0)
  511. // do
  512. // {
  513. // cout << "Unesite [" << i << "][" << j << "] element:";
  514. // cin >> matrica[i][j];
  515. // } while (matrica[i][j] < 100);
  516. // else matrica[i][j] = obratno(matrica[i - 1][j]);
  517. //
  518. // }
  519. // }
  520. //}
  521. //
  522. //void ispis(int matrica[][4])
  523. //{
  524. // cout << "--------------------\n";
  525. // for (int i = 0; i < 4; i++)
  526. // {
  527. // for (int j = 0; j < 4; j++)
  528. // cout << setw(10) << matrica[i][j];
  529. // cout << endl;
  530. // }
  531. //}
  532. //
  533. //void max(int matrica[][4])
  534. //{
  535. // int niz[4];
  536. // cout << "Najveci elementi u redu: ";
  537. // for (int i = 0; i < 4; i++)
  538. // {
  539. // int max = INT_MIN;
  540. // for (int j = 0; j < 4; j++)
  541. // {
  542. // if (matrica[i][j] > max)
  543. // {
  544. // max = matrica[i][j];
  545. // }
  546. // }
  547. // niz[i] = max;
  548. // cout <<" " << max;
  549. // }
  550. // cout << endl;
  551. // cout <<"------------------------------------------\n"<<endl;
  552. //}
  553. //void iznad_dijagonala(int matrica[][4])
  554. //{
  555. // int brojac = 0;
  556. // cout << "Elementi iznad glavne i sporedne dijagonale: ";
  557. // for (int i = 0; i < 4; i++)
  558. // {
  559. // for (int j = 0; j < 4; j++)
  560. // {
  561. // if (j > i && i + j < 3)
  562. // {
  563. // brojac++;
  564. // cout <<" "<< matrica[i][j];
  565. // }
  566. // }
  567. // }
  568. // cout << endl;
  569. // cout << "Broj elemenata iznad dijagonala: " << brojac;
  570. //}
  571. //
  572. //void main()
  573. //{
  574. // int matrica[4][4];
  575. //
  576. // unos(matrica);
  577. // ispis(matrica);
  578. // max(matrica);
  579. // iznad_dijagonala(matrica);
  580. // system("pause>0");
  581. //}
  582.  
  583. //napraviti program koji unosi sve elemente iznad glavne dijagonale minimalno
  584. //trocifrenim neparnim brojevima, a u odgovarajuce elemente ispod glavne dijagonale
  585. //simetricno u odnosu na unseen elemente unijeti obrnute brojeve.
  586. //Pogledati u durgom primjeru transpoziciju matrice.
  587.  
  588. //int obrnuto(int x)
  589. //{
  590. // int povratni = 0;
  591. // do
  592. // {
  593. // povratni = povratni * 10 + x % 10;
  594. // x /= 10;
  595. // } while (x > 0);
  596. // return povratni;
  597. //}
  598. //
  599. //void main()
  600. //{
  601. // int matrica[4][4];
  602. // for (int i = 0; i < 4; i++)
  603. // {
  604. // for (int j = 0; j < 4; j++)
  605. // {
  606. // if (i < j)
  607. // {
  608. // do
  609. // {
  610. // cin >> matrica[i][j];
  611. // } while (matrica[i][j] < 100 || matrica[i][j] % 2 == 0);
  612. // }
  613. // else if (i > j)
  614. // {
  615. // matrica[i][j] = obrnuto(matrica[j][i]);
  616. // }
  617. // else
  618. // matrica[i][j] = 1;
  619. // }
  620. // }
  621. // for (int i = 0; i < 4; i++)
  622. // {
  623. // for (int j = 0; j < 4; j++)
  624. // {
  625. // cout << setw(4) << matrica[i][j];
  626. // }
  627. // cout << endl;
  628. // }
  629.  
  630. // system("pause>0");
  631. //}
  632.  
  633. //void main()
  634. //{
  635. // int niz[10];
  636. // int n, pomocna, cifra, brojac = 0;
  637. //
  638. // {
  639. // cout << "Unijeti prirodne brojeve: " << endl;
  640. // do
  641. // {
  642. // cin >> n;
  643. // if (n == 0)
  644. // {
  645. // cout << "Forsirani prekid" << endl;
  646. // break;
  647. // }
  648. //
  649. //
  650. // pomocna = n;
  651. //
  652. // do
  653. // {
  654. // cifra = pomocna % 10;
  655. // pomocna /= 10;
  656. // } while (pomocna > 0);
  657. //
  658. // if (cifra % 2 == 0)
  659. // {
  660. // niz[brojac] = n;
  661. // brojac++;
  662. // }
  663. //
  664. // } while (brojac < 10 && n>0);
  665. //
  666. // for (int i = 0; i < 10; i++)
  667. // {
  668. // cout << " " << niz[i];
  669. // }
  670. // cout << endl;
  671. //
  672. // }
  673.  
  674. //int prost_broj(int broj)
  675. //{
  676. // bool prost = true;
  677. // for (int i = 2; i < broj / 2; i++)
  678. // {
  679. // if (broj%i == 0)
  680. // {
  681. // prost = false;
  682. // }
  683. // }
  684. // return prost;
  685.  
  686.  
  687.  
  688. //bool prost_broj(int broj)
  689. //{
  690. // bool prost = false;
  691. // for (int i = 2; i < broj / 2; i++)
  692. // {
  693. // if (broj%i == 0)
  694. // {
  695. // prost = false;
  696. // }
  697. // else if (broj%i != 0)
  698. // {
  699. // prost = true;
  700. // }
  701. // }
  702. // if (prost)
  703. // {
  704. // return true;
  705. // }
  706. // return prost;
  707. //}
  708. // void main()
  709. // {
  710. // bool vrijednost = false;
  711. // int a, b;
  712. // cin >> a, b;
  713. // vrijednost = prost_broj(a);
  714. // if (vrijednost = true)
  715. // {
  716. // cout << a;
  717. // }
  718. // else
  719. // cout << "Nije prost" << endl;
  720.  
  721. //void unos(int matrica[][5])
  722. //{
  723. // for (int i = 0; i < 5; i++)
  724. // {
  725. // for (int j = 0; j < 5; j++)
  726. // {
  727. // cin >> matrica[i][j];
  728. // }
  729. // }
  730. //}
  731. //int prost(int broj)
  732. //{
  733. // bool prost = true;
  734. // for (int i = 2; i<=broj/2; i++)
  735. // {
  736. // if (broj%i == 0)
  737. // {
  738. // prost = false;
  739. // }
  740. // }
  741. // return prost;
  742. //}
  743. //
  744. //void main()
  745. //{
  746. // bool jeste = false;
  747. // int matrica[5][5];
  748. // cout << "Unijeti elemente matrice: " << endl;
  749. // unos(matrica);
  750. //
  751. // cout << "Ispis prostih brojeva: " << endl;
  752. // for (int i = 0; i < 5; i++)
  753. // {
  754. // for (int j = 0; j < 5; j++)
  755. // {
  756. // jeste = prost(matrica[i][j]);
  757. // if (jeste == true)
  758. // {
  759. // cout << setw(4) << matrica[i][j];
  760. // }
  761. // }
  762. // }
  763. //
  764. // system("pause>0");
  765. //}
  766. //void sortiran(int matrica[][5])
  767. //{
  768. // int temp = 0;
  769. // for (int i = 0, j=0;j<5;j++)
  770. // {
  771. // temp = matrica[i][j];
  772. // matrica[i][j] = matrica[i + 2][j];
  773. // matrica[i + 2][j] = temp;
  774. // }
  775. // for (int i = 0; i < 5; i++)
  776. // {
  777. // for (int j = 0; j < 5; j++)
  778. // {
  779. // cout << setw(4) << matrica[i][j];
  780. // }
  781. // cout << endl;
  782. // }
  783. // cout << endl;
  784. //}
  785. //int obratno(int x)
  786. //{
  787. // int povratni = 0;
  788. // do
  789. // {
  790. // povratni = povratni * 10 + x % 10;
  791. // x /= 10;
  792. // } while (x > 0);
  793. // return povratni;
  794. //}
  795. //void obrtni_2Dniz(int matrica[][5])
  796. //{
  797. // for (int i = 0, j = 0; j < 5; j++)
  798. // {
  799. // matrica[i + 4][j] = obratno(matrica[i][j]);
  800. // }
  801. // for (int i = 0; i < 5; i++)
  802. // {
  803. // for (int j = 0; j < 5; j++)
  804. // {
  805. // cout << setw(4) << matrica[i][j];
  806. // }
  807. // cout << endl;
  808. // }
  809. // cout << endl;
  810. //}
  811. //void main()
  812. //{
  813. // int matrica[5][5] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25 };
  814. // cout << "Matrica glasi: " << endl;
  815. // for (int i = 0; i < 5; i++)
  816. // {
  817. // for (int j = 0; j < 5; j++)
  818. // {
  819. // cout << setw(4) << matrica[i][j];
  820. // }
  821. // cout << endl;
  822. // }
  823. // cout << endl;
  824. // cout << "Zamijenjen 1. i 3. red matrice: " << endl;
  825. // sortiran(matrica);
  826. // cout << "...................................................." << endl;
  827. // cout << "Zadnji red jednak obratnom prvom: " << endl;
  828. // obrtni_2Dniz(matrica);
  829. // cout << "...................................................." << endl;
  830. //
  831. // system("pause>0");
  832. //}
  833. //int broj_cifara(int x)
  834. //{
  835. // int brojac = 0;
  836. // while (x > 0)
  837. // {
  838. // x /= 10;
  839. // brojac++;
  840. // }
  841. // return brojac;
  842. //}
  843. //void srednja_cifra(int y)
  844. //{
  845. // int brcfr = broj_cifara(y);
  846. // int temp = 0;
  847. // float rezultat;
  848. // if (brcfr % 2 != 0)
  849. // {
  850. // rezultat= y / pow(10, brcfr / 2);
  851. // cout<< int(rezultat)%10;
  852. // }
  853. // else
  854. // {
  855. // rezultat = (int(y / pow(10, brcfr / 2)))%10;
  856. // temp = (int(y / pow(10, (brcfr/2) - 1))) % 10;
  857. // rezultat = (rezultat + temp) / 2;
  858. // cout<< rezultat;
  859. // }
  860. //}
  861. //
  862. //void main()
  863. //{
  864. // int a;
  865. // do
  866. // {
  867. // cout << "Unijeti prirodan broj minimalno 100!" << endl;
  868. // cin >> a;
  869. // } while (a < 100);
  870. // cout << "----------------------------------------------------------" << endl;
  871. // cout << "Srednja cifra unesenog broja: " << endl;
  872. // srednja_cifra(a);
  873. //
  874. // system("pause>0");
  875. //}
  876.  
  877. //void main()
  878. //{
  879. // int niz[7];
  880. // int brojac = 0;
  881. // int brojac2 = 0;
  882. // float aritmeticka = 0;
  883. // cout << "Unijeti element niza: " << endl;
  884. // for (int i = 0; i < 7; i++)
  885. // {
  886. // do
  887. // {
  888. // cin >> niz[i];
  889. // if (niz[i] < 0)
  890. // {
  891. // brojac++;
  892. // }
  893. // else if(niz[i]>0)
  894. // {
  895. // aritmeticka += niz[i];
  896. // brojac2++;
  897. // }
  898. // } while (niz[i] == 0);
  899. // }
  900. // cout << "Broj negativnih elemenata niza: " << brojac << endl;
  901. // cout << "Aritmeticka sredina pozitivnih brojeva niza: " << aritmeticka / brojac2 << endl;
  902. //
  903. // system("pause>0");
  904. //}
  905.  
  906. //bool prost(int broj)
  907. //{
  908. // bool prost = true;
  909. // for (int i = 2; i <= broj / 2; i++)
  910. // {
  911. // if (broj%i == 0)
  912. // {
  913. // prost = false;
  914. // }
  915. // }
  916. // return prost;
  917. //}
  918. //
  919. //void main()
  920. //{
  921. // bool jeste = false;
  922. // bool tarik = false;
  923. // int a, b;
  924. // cout << "Unijeti 2 prirodna broja: " << endl;
  925. // do
  926. // {
  927. // cin >> a >> b;
  928. // } while (a < 0 || b < 0);
  929. // jeste = prost(a);
  930. // if (jeste == true)
  931. // {
  932. // cout << "Prvi broj jeste prost!" << endl;
  933. // }
  934. // else
  935. // {
  936. // cout << "Prvi broj nije prost!" << endl;
  937. // }
  938. // tarik = prost(b);
  939. // if (tarik == true)
  940. // {
  941. // cout << "Drugi broj jeste prost!" << endl;
  942. // }
  943. // else
  944. // {
  945. // cout << "Drugi broj nije prost!" << endl;
  946. // }
  947. //
  948. //
  949. // system("pause>0");
  950. //}
  951.  
  952. /*Napišite program, poštujući sve faze procesa programiranja,
  953. u kojem ćete za uneseni prirodni broj n(prirodni brojevi : 1, 2, 3, …..)
  954. izračunati umnožak :
  955. (jedan kroz 2 što množi 1 kroz dva na kvadrat što množi .....jedan kroz dva na n)
  956. Upotrijebite funkciju :
  957. double umnozak(int);*/
  958.  
  959. //double umnozak(int x)
  960. //{
  961. // double rezultat;
  962. // float A = 1;
  963. // for (int i = 1; i <= x; i++)
  964. // {
  965. // A *= pow(2, i);
  966. // }
  967. // rezultat = 1.0 / A;
  968. // return rezultat;
  969. //}
  970. //
  971. //void main()
  972. //{
  973. // int n;
  974. // cout << "Unijeti prirodan broj n: " << endl;
  975. // cin >> n;
  976. //
  977. // cout << "Rezultat je: " << endl;
  978. // cout << umnozak(n);
  979. //
  980. // system("pause>0");
  981. //}
  982.  
  983. /*Zadatak 2
  984. Napišite program koji će omogućiti kreiranje matrice prirodnih brojeva 4x3 i
  985. matrice 2x3.Pretpostavka je da postoji funkcija koja omogućava unos prirodnih
  986. brojeva u prvu matricu(funkciju unos ne treba ni definirati ni pozivati).
  987. Kreirajte funkcije :
  988. void kopiraj(int[][3], int[][3]); zadaća funkcije je da kopira svaki drugi
  989. element iz jedne matrice(4x3) u drugu matricu(2x3);
  990.  
  991. funkcije: int suma(int[], int); čija je zadaća izračunati sumu retka kojeg
  992. izabere korisnik za matricu koju izabere korisnik; obavezno onemogućiti
  993. korisnika da izabere nepostojeću matricu i nepostojeći redak;
  994.  
  995. Ispis sume, izbor matrice i retka vršite u funkciji main.*/
  996.  
  997. //void unos(int matrica1[][3])
  998. //{
  999. // for (int i = 0; i < 4; i++)
  1000. // {
  1001. // for (int j = 0; j < 3; j++)
  1002. // {
  1003. // cin >> matrica1[i][j];
  1004. // }
  1005. // }
  1006. //}
  1007. //void kopiraj(int x[][3], int y[][3])
  1008. //{
  1009. // int privremena[6], brojac = 0;
  1010. // for (int i = 0; i < 4; i++)
  1011. // {
  1012. // for (int j = 0; j < 3; j++)
  1013. // {
  1014. // if (i % 2 == 0)
  1015. // {
  1016. // if (j % 2 == 0)
  1017. // {
  1018. // privremena[brojac] = x[i][j];
  1019. // brojac++;
  1020. // }
  1021. // }
  1022. // else
  1023. // {
  1024. // if (j % 2 != 0)
  1025. // {
  1026. // privremena[brojac] = x[i][j];
  1027. // brojac++;
  1028. // }
  1029. // }
  1030. // }
  1031. // }
  1032. // brojac = 0;
  1033. // for (int i = 0; i < 2; i++)
  1034. // {
  1035. // for (int j = 0; j < 3; j++)
  1036. // {
  1037. // y[i][j] = privremena[brojac];
  1038. // brojac++;
  1039. // }
  1040. // }
  1041. //}
  1042. //int suma(int red[], int brredova)
  1043. //{
  1044. // int suma = 0;
  1045. // for (int i = 0; i < brredova; i++)
  1046. // {
  1047. // suma += red[i];
  1048. // }
  1049. // return suma;
  1050. //}
  1051. //void main()
  1052. //{
  1053. // const int redovi1 = 4, redovi2 = 2, kolona = 3;
  1054. // int odabirm, odabirr;
  1055. // int matrica1[redovi1][kolona];
  1056. // int matrica2[redovi2][kolona];
  1057. //
  1058. // cout << "Unijeti elemente prve matrice: " << endl;
  1059. // unos(matrica1);
  1060. // cout << "Prva matrica glasi: " << endl;
  1061. // for (int i = 0; i < 4; i++)
  1062. // {
  1063. // for (int j = 0; j < 3; j++)
  1064. // {
  1065. // cout << setw(4) << matrica1[i][j];
  1066. // }
  1067. // cout << endl;
  1068. // }
  1069. // cout << endl;
  1070. // kopiraj(matrica1, matrica2);
  1071. // cout << "Druga matrica glasi: " << endl;
  1072. // for (int i = 0; i < 2; i++)
  1073. // {
  1074. // for (int j = 0; j < 3; j++)
  1075. // {
  1076. // cout << setw(4) << matrica2[i][j];
  1077. // }
  1078. // cout << endl;
  1079. // }
  1080. // cout << "----------------------------------------" << endl;
  1081. // do
  1082. // {
  1083. // cout << "Odaberite matricu 1|2: " << endl;
  1084. // cin >> odabirm;
  1085. // } while (odabirm < 1 || odabirm>1);
  1086. // if (odabirm == 1)
  1087. // {
  1088. // do
  1089. // {
  1090. // cout << "Odaberite red 1.,2.,3. ili 4.: " << endl;
  1091. // cin >> odabirr;
  1092. // } while (odabirr < 1 || odabirr>4);
  1093. // }
  1094. // if (odabirm == 2)
  1095. // {
  1096. // do
  1097. // {
  1098. // cout << "Odaberite red 1. ili 2.: " << endl;
  1099. // cin >> odabirr;
  1100. // } while (odabirr < 1 || odabirr>2);
  1101. // }
  1102. // if (odabirm == 1)
  1103. // {
  1104. // cout << "Suma izabranog reda prve matrice: " << suma(matrica1[odabirr - 1], kolona);
  1105. // }
  1106. // if (odabirm == 2)
  1107. // {
  1108. // cout << "Suma izabranog reda druge matrice: " << suma(matrica2[odabirr - 1], kolona);
  1109. // }
  1110. // system("pause>0");
  1111. //}
  1112.  
  1113. //Napišite program u kojem ćete omogućiti kreiranje niza od 6 cjelobrojnih
  1114. //elemenata.Pretpostavka je da postoji funkcija koja
  1115. //omogućava unos brojeva u niz(ne treba ju definirati);
  1116. //· definirati i upotrijebiti funkciju void pronaci(int[], int);
  1117. //koja će pronaći i ispisati dva najveća elementa u nizu;
  1118. //· definirati i upotrijebiti funkciju float suma(int[], int);
  1119. //koja će izračunati sumu recipročnih vrijednosti elemenata niza;
  1120. //· definirati i upotrijebiti funkciju int prebroji(int[], int)
  1121. //koja treba ispisati sve pozitivne elemente niza i njihove indekse,
  1122. //te prebrojati koliko takvih elemenata ima;
  1123. //Ispis sume recipročnih vrijednosti i broja pozitivnih
  1124. //elemenata vršiti u funkciji main.
  1125.  
  1126. //void unos(int niz[])
  1127. //{
  1128. // for (int i = 0; i < 6; i++)
  1129. // {
  1130. // cin >> niz[i];
  1131. // }
  1132. //}
  1133. //void pronaci(int niz[])
  1134. //{
  1135. // int temp[6];
  1136. // bool promjena = true;
  1137. // for (int i = 0; i < 6; i++)
  1138. // {
  1139. // temp[i] = niz[i];
  1140. // }
  1141. // while (promjena)
  1142. // {
  1143. // promjena = false;
  1144. // for (int i = 0; i < 5; i++)
  1145. // {
  1146. // int privremena;
  1147. // if (temp[i] > temp[i + 1])
  1148. // {
  1149. // privremena = temp[i];
  1150. // temp[i] = temp[i + 1];
  1151. // temp[i + 1] = privremena;
  1152. // promjena = true;
  1153. // }
  1154. // }
  1155. // }
  1156. // for (int i = 4; i < 6; i++)
  1157. // {
  1158. // cout << " " << temp[i];
  1159. // }
  1160. //}
  1161. //float suma(int niz[])
  1162. //{
  1163. // float suma = 0;
  1164. // for (int i = 0; i < 6; i++)
  1165. // {
  1166. // suma += 1.0 / niz[i]; //Ako se unese element '0', rezultat ce bit 'inf', jer u nazivniku ne smije biti nula(0)!
  1167. // }
  1168. // return suma;
  1169. //}
  1170. //int prebroji(int niz[])
  1171. //{
  1172. // int brojac = 0;
  1173. // for (int i = 0; i < 6; i++)
  1174. // {
  1175. // if (niz[i] > 0)
  1176. // {
  1177. // brojac++;
  1178. // cout << "Pozitivan element: " << niz[i] << " njegov index: " << i << endl;
  1179. // }
  1180. // }
  1181. // return brojac;
  1182. //}
  1183. //
  1184. //void main()
  1185. //{
  1186. // int niz[6];
  1187. // cout << "Unijeti 6 elemanata niza: " << endl;
  1188. // unos(niz);
  1189. // cout << "Najveca 2 elementa niza: ";
  1190. // pronaci(niz);
  1191. // cout << endl;
  1192. // cout << "Suma reciprocnih vrijednosti elemenata niza: " << suma(niz) << endl;
  1193. // cout << "Pozitivnih elemenata ima: " << prebroji(niz) << endl;
  1194. //
  1195. //
  1196. // system("pause>0");
  1197. //}
  1198.  
  1199. //int sumacifara(int broj)
  1200. //{
  1201. // int suma = 0;
  1202. // while (broj > 0)
  1203. // {
  1204. // suma += broj % 10;
  1205. // broj /= 10;
  1206. // }
  1207. // return suma;
  1208. //}
  1209. //int sumaprveizadnje(int broj)
  1210. //{
  1211. // int suma = 0;
  1212. // suma = broj % 10;
  1213. // while (broj > 9)
  1214. // {
  1215. // broj /= 10;
  1216. // }
  1217. // suma += broj;
  1218. // return suma;
  1219. //}
  1220. //
  1221. //void main()
  1222. //{
  1223. // int X, Y;
  1224. // int brojac = 0;
  1225. // do
  1226. // {
  1227. // cout << "Unijeti 2 prirodna broja u intervalu 10-5000: " << endl;
  1228. // cin >> X >> Y;
  1229. // } while (X < 10 || X>5000 || Y < 10 || Y>5000);
  1230. //
  1231. // if (X < Y)
  1232. // {
  1233. // for (int i = X; i <= Y; i++)
  1234. // {
  1235. // if (sumacifara(i) % sumaprveizadnje(i) == 0)
  1236. // {
  1237. // cout << " " << i;
  1238. // brojac++;
  1239. // }
  1240. // }
  1241. // }
  1242. // cout << endl;
  1243. //
  1244. // if (X > Y)
  1245. // {
  1246. // for (int i = Y; i <= X; i++)
  1247. // {
  1248. // if (sumacifara(i) % sumaprveizadnje(i) == 0)
  1249. // {
  1250. // cout << " " << i;
  1251. // brojac++;
  1252. // }
  1253. // }
  1254. // }
  1255. // cout << endl;
  1256. // cout <<"---------------------------------------------------------------------------"<< endl;
  1257. // cout << endl;
  1258. // cout << "U intervalu od X do Y broj brojeva koji zadovoljavaju uslov je: " << brojac;
  1259. //
  1260. // system("pause>0");
  1261. //}
  1262.  
  1263. //void rastuci(int niz[])
  1264. //{
  1265. // bool promjena = true;
  1266. // while (promjena)
  1267. // {
  1268. // promjena = false;
  1269. // for (int i = 0; i < 9; i++)
  1270. // {
  1271. // int privremena;
  1272. // if (niz[i] > niz[i + 1])
  1273. // {
  1274. // privremena = niz[i];
  1275. // niz[i] = niz[i + 1];
  1276. // niz[i + 1] = privremena;
  1277. // promjena = true;
  1278. // }
  1279. // }
  1280. // }
  1281. // for (int i = 0; i < 10; i++)
  1282. // {
  1283. // cout << " " << niz[i];
  1284. // }
  1285. //}
  1286. //void opadajuci(int niz[])
  1287. //{
  1288. // bool promjena = true;
  1289. // while (promjena)
  1290. // {
  1291. // promjena = false;
  1292. // for (int i = 0; i < 9; i++)
  1293. // {
  1294. // int privremena;
  1295. // if (niz[i] < niz[i + 1])
  1296. // {
  1297. // privremena = niz[i];
  1298. // niz[i] = niz[i + 1];
  1299. // niz[i + 1] = privremena;
  1300. // promjena = true;
  1301. // }
  1302. // }
  1303. // }
  1304. // for (int i = 0; i < 10; i++)
  1305. // {
  1306. // cout << " " << niz[i];
  1307. // }
  1308. //}
  1309. //
  1310. //void main()
  1311. //{
  1312. // int niz[10];
  1313. // int x;
  1314. // for (int i = 0; i < 10; i++)
  1315. // {
  1316. // cout << "Unijeti elemente niza: " << endl;
  1317. // cin >> niz[i];
  1318. // }
  1319. //
  1320. // do
  1321. // {
  1322. // cout << "Odaberite da li zelite rastuci(1) ili opadajuci(2) niz (1|2): " << endl;
  1323. // cin >> x;
  1324. // if (x == 1)
  1325. // {
  1326. // cout << "Izabrali ste rastuci niz: ";
  1327. // rastuci(niz);
  1328. // }
  1329. // if (x == 2)
  1330. // {
  1331. // cout << "Izabrali ste opadajuci niz: ";
  1332. // opadajuci(niz);
  1333. // }
  1334. // } while (x < 1 || x > 2);
  1335. //
  1336. // system("pause>0");
  1337. //}
  1338.  
  1339. void main()
  1340. {
  1341. char niz[20];
  1342. int brojac = 0;
  1343. char unos;
  1344.  
  1345. do
  1346. {
  1347. cout << "Unijeti elemente niza (mala slova ili brojeve): " << endl;
  1348. if (brojac = 0)
  1349. {
  1350. cin >> unos;
  1351. }
  1352. if (unos >= 'a' && unos <= 'z')
  1353. {
  1354. if (unos < niz[brojac])
  1355. {
  1356. brojac++;
  1357. niz[brojac] = unos;
  1358. }
  1359. }
  1360. if (unos >= '0' && unos <= '9')
  1361. {
  1362. if (unos < niz[brojac])
  1363. {
  1364. brojac++;
  1365. niz[brojac] = unos;
  1366. }
  1367. }
  1368.  
  1369. } while (unos != '0' || unos != 'a' || brojac <20);
  1370.  
  1371. cout << "Niz glasi: " << endl;
  1372. for (int i = 0; i < 20; i++)
  1373. {
  1374. cout << setw(4) << niz[i];
  1375. }
  1376.  
  1377. system("pause>0");
  1378. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!