Tutorijal 6
1
/*
    TP 2018/2019: Tutorijal 6, Zadatak 1

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <stdexcept>
#include <cmath>
#include <limits>
#include <new>
#include <iomanip>
using namespace std;
template <typename Nekitip>
Nekitip *GenerirajStepeneDvojke(int n)
{
	if(n <= 0) throw domain_error("Broj elemenata mora biti pozitivan");


	Nekitip *niz(nullptr);
	try
	{
		//Nekitip broj_dva(2);
		Nekitip broj_dva(2);
		Nekitip min(numeric_limits<Nekitip>::min());
		Nekitip max(numeric_limits<Nekitip>::max());
		Nekitip provjera(powl(broj_dva,n));
		if(provjera > max || provjera == min)
				throw overflow_error("Prekoracen dozvoljeni opseg");

		niz = new Nekitip[n];


		for(int i=0;i<n;i++)
		{

			niz[i] = pow(broj_dva, i);

		}

		return niz;
	}
	catch(bad_alloc)
	{
		delete[] niz;
		throw runtime_error("Alokacija nije uspjela");

	}
	catch(...)
	{
		delete[] niz;
		throw;
	}


}

int main ()
{
	try
	{
		int broj;
		cout << "Koliko zelite elemenata: ";
			cin >> broj;

			auto pok(GenerirajStepeneDvojke<long double>(broj));
			for(int i=0;i < 30;i++)
				cout << fixed << setprecision(0) << pok[i] << " ";
				delete[] pok;
	}
	catch(domain_error izuzetak)
	{
		cout << "Izuzetak: " << izuzetak.what();
	}
	catch(runtime_error izuzetak)
	{
		cout << "Izuzetak: " << izuzetak.what();

	}
	catch(overflow_error izuzetak)
	{
		cout << "Izuzetak: " << izuzetak.what();
	}
	catch(...)
	{
		cout << "Neocekivan!";
	}
	return 0;
}
---------------------------------------------------------------------------
2
/*
    TP 2018/2019: Tutorijal 6, Zadatak 2

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <new>
#include <vector>
#include <type_traits>
#include <forward_list>

using namespace std;
template <typename NekiBlok>

auto KreirajIzvrnutiNiz(NekiBlok p1, NekiBlok p2) -> typename remove_reference<decltype(*p1)>::type*
{
	decltype(*p1 + *p1) *niz(nullptr);
	try
	{
		int broj(0);
		auto p(p1);
		while(p != p2)
		{
			p++;
			broj++;
		}
		niz = new typename remove_reference<decltype(*p1)>::type[broj];

		while(p1 != p2)
		{
			broj--;
			niz[broj] = *p1;

			p1++;
		}

		return niz;
	}
	catch(bad_alloc izuzetak)
	{
		delete niz;
		delete[] niz;
		throw;
	}

}
int main ()
{


	try
	{
	int broj_elemenata;
	cout << "Koliko zelite elemenata: ";
		cin >> broj_elemenata;
	vector<double> v(broj_elemenata, 0);

	cout << "Unesite elemente: ";
		for(int i=0;i<broj_elemenata;i++)
			cin >> v[i];
	auto *pok=KreirajIzvrnutiNiz(v.begin(), v.end());
	cout << "Kreirani niz: ";
	for(int i=0;i<broj_elemenata;i++)
	{
		cout << pok[i] << " ";
	}

		delete[] pok;
	}
	catch(...)
	{
		cout << "Nedovoljno memorije!";
	}
	return 0;
}
-----------------------------------------------------------------------------------
3
/*
    TP 2018/2019: Tutorijal 6, Zadatak 3

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <cmath>

using namespace std;

int **KreirajTrougao(int n)
{
	if(n <= 0)
		throw domain_error("Broj redova mora biti pozitivan");
	int **mat(nullptr);
	try
	{
		mat = new int*[n]{};
		for(int i=0;i<n;i++)
		{
			mat[i] = new int[i*2 + 1];
		}


		for(int i=0;i<n;i++)
		{
			for(int j=0;j<i*2+1;j++)
			{
				if(i == j)
					mat[i][j] = 1;

				if(j == i*2)
					mat[i][j] = i+1;
				if(i == j+(abs(i-j)) || j == i+abs(i-j))
					mat[i][j] = abs(i-j)+1;

			}

		}

		return mat;
	}
	catch(bad_alloc)
	{
		for(int i=0;i<n;i++)
		{
			delete[] mat[i];
		}

			delete[] mat;
			throw;
	}
}
int main ()
{
	int red;
	try
	{
		cout << "Koliko zelite redova: ";
			cin >> red;
		auto **pok(KreirajTrougao(red));

		for(int i=0;i<red;i++)
		{
			for(int j=0;j<i*2+1;j++)
				cout << pok[i][j] << " ";

			cout << endl;
		}
		for(int i=0;i<red;i++)
			delete[] pok[i];

		delete[] pok;

	}
	catch(domain_error izuzetak)
	{
		cout << "Izuzetak: " << izuzetak.what();
	}
	catch(bad_alloc)
	{
		cout << "Izuzetak: Nedovoljno memorije!";
	}

	return 0;
}
-----------------------------------------------------------------------------------------------------------
4
/*
    TP 2018/2019: Tutorijal 6, Zadatak 4

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <cmath>

using namespace std;

bool StepenDvojke(int broj)
{
	while(broj !=0)
	{
		if(broj % 2 != 0)
			return false;
		broj /= 2;
	}
	return true;
}

int **KreirajTrougao(int n)
{
	if(n <= 0)
		throw domain_error("Broj redova mora biti pozitivan");
	int **mat(nullptr);
	try
	{
		mat = new int*[n]{};
		mat[0] = new int [n*n];
		for(int i=1;i<n;i++)
		{
			mat[i] = mat[i-1] + 2;
		}
		// Ne znam, prepravljao sam, pa ne radi sada kako treba

		for(int i=0;i<1;i++)
		{
			for(int j=0;j<n*n;j++)
			{
				if(
					mat[i][j] = 1;

				if(j == i*2)
					mat[i][j] = i+1;
				if(i == j+(abs(i-j)) || j == i+abs(i-j))
					mat[i][j] = abs(i-j)+1;

			}

		}

		return mat;
	}
	catch(bad_alloc)
	{
		delete[] mat[0];

		delete[] mat;
			throw;
	}
}
int main ()
{
	int red;
	try
	{
		cout << "Koliko zelite redova: ";
			cin >> red;
		auto **pok(KreirajTrougao(red));

		for(int i=0;i<red;i++)
		{
			for(int j=0;j<i*2+1;j++)
				cout << pok[i][j] << " ";

			cout << endl;
		}

		delete[] pok[0];

		delete[] pok;

	}
	catch(domain_error izuzetak)
	{
		cout << "Izuzetak: " << izuzetak.what();
	}
	catch(bad_alloc)
	{
		cout << "Izuzetak: Nedovoljno memorije!";
	}

	return 0;
}
---------------------------------------------------------------------------------------------
5
/*
    TP 2018/2019: Tutorijal 6, Zadatak 5

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <vector>
#include <deque>
#include <new>

using namespace std;

template <typename Kontenjer>
auto KreirajDinamickuKopiju2D(Kontenjer c) -> decltype(c[0][0] + c[0][0])**
{
	decltype(c[0][0] + c[0][0]) **mat(nullptr);
	try
	{
		mat = new decltype(c[0][0] + c[0][0])*[c.size()]{};
		for(int i = 0; i < c.size();i++)
			mat[i] = new decltype(c[0][0] + c[0][0])[c[i].size()];

		for(int i=0;i<c.size();i++)
			for(int j=0;j<c[i].size();j++)
				mat[i][j] = c[i][j];
	}
	catch(...)
	{
		for(int i=0;i<c.size();i++)
			delete[] mat[i];

		delete[] mat;

		throw;
	}
	return mat;
}
int main ()
{
	try
	{
		int br_elemenata;
	cout << "Unesite broj redova kvadratne matrice: ";
		cin >> br_elemenata;
	vector<deque<int>>	v(br_elemenata, deque<int>(3));
	cout << "Unesite elemente matrice: ";
	for(int i=0;i<v.size();i++)
		for(int j=0;j<v[i].size();j++)
			cin >> v[i][j];

	auto pok(KreirajDinamickuKopiju2D(v));
		for(int i=0;i<v.size();i++)
		{
			for(int j=0;j<v[i].size();j++)
				cout << pok[i][j] << " ";

			cout << endl;
		}

		for(int i=0;i<v.size();i++)
			delete[] pok[i];

		delete[] pok;


	}
	catch(...)
	{
		cout << "Nedovoljno memorije";
	}
	return 0;
}
------------------------------------------------------------------------------------------------------------
6
/*
    TP 2018/2019: Tutorijal 6, Zadatak 6

	Autotestovi by Kerim Hodzic. Prijave gresaka, pitanja
	i sugestije saljite na mail: khodzic2@etf.unsa.ba

	Napomene: testovi su konacni tek pred tutorijal
			  za krsenje zabrana dobiva se 0 bodova za zadatak

*/
#include <iostream>
#include <vector>
#include <deque>
#include <new>

using namespace std;

template <typename Kontenjer>
auto KreirajDinamickuKopiju2D(Kontenjer c) -> decltype(c[0][0] + c[0][0])**
{
	decltype(c[0][0] + c[0][0]) **mat(nullptr);
	try
	{
		mat = new decltype(c[0][0] + c[0][0])*[c.size()]{};

		int broj_elemenata(0);
		for(int i = 0; i < c.size();i++)
			broj_elemenata += c[i].size();
		mat[0] = new decltype(c[0][0] + c[0][0])[broj_elemenata];

		for(int i=1;i<c.size();i++)
			mat[i] = mat[i-1] + c[i-1].size();


		for(int i=0;i<c.size();i++)
			for(int j=0;j<c[i].size();j++)
				mat[i][j] = c[i][j];
	}
	catch(...)
	{

			delete[] mat[0];

		delete[] mat;

		throw;
	}
	return mat;
}
int main ()
{
	try
	{
		int br_elemenata;
	cout << "Unesite broj redova kvadratne matrice: ";
		cin >> br_elemenata;
	vector<deque<int>>	v(br_elemenata, deque<int>(3));
	cout << "Unesite elemente matrice: ";
	for(int i=0;i<v.size();i++)
		for(int j=0;j<v[i].size();j++)
			cin >> v[i][j];

	auto pok(KreirajDinamickuKopiju2D(v));
		for(int i=0;i<v.size();i++)
		{
			for(int j=0;j<v[i].size();j++)
				cout << pok[i][j] << " ";

			cout << endl;
		}


			delete[] pok[0];

		delete[] pok;

	}
	catch(...)
	{
		cout << "Nedovoljno memorije";
	}
	return 0;
}
------------------------------------------------------------------------------
Tutorijal 5
1
/*
    TP 2018/2019: Tutorijal 5, Zadatak 1

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje niz[i] ili simulacija indeksiranja
			  npr. *(niz + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>

using namespace std;

void unesi(char niz[], int velicina) {

	char znak(getchar());
	if(znak == '\n') znak = getchar();

	int i(0);
	while(i < velicina - 1 && znak != '\n') {

		niz[i] = znak;
		i++;
		znak = getchar();

	}
	niz[i] = '\0';

}
int main ()
{
	char niz[1000];

	cout << "Unesite recenicu: ";
		unesi(niz, 1000);

	char *pocetak(niz);
	int brojac(0), br(0);
	while(*pocetak != '\0')
	{
		if(*pocetak != ' ')
		{
			while(*pocetak != ' ' && *pocetak != '\0')
			{
				pocetak++;
				br++;
			}

			brojac++;
		}

		if(brojac == 2)
		{
			if(br != 1)
			{
				while(br != 0)
				{
					pocetak--;
					br--;
				}
				break;
			}

			else
			{
				brojac = 1;
				br = 0;
			}
		}
		br = 0;
		if(*pocetak == '\0')
			pocetak--;

		pocetak++;
	}

	cout << "Recenica bez prve rijeci glasi: ";
	while(*pocetak != '\0')
	{
		cout << *pocetak;
		pocetak++;
	}
	cout << endl;
	return 0;
}
--------------------------------------------------------------------
2
/*
    TP 2018/2019: Tutorijal 5, Zadatak 2

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje niz[i] ili simulacija indeksiranja
			  npr. *(niz + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>
#include <vector>
#include <deque>
#include <string>

template <typename svaki_tip1, typename svaki_tip2>
svaki_tip2 RazmijeniBlokove(svaki_tip1 pocetak_prvog, svaki_tip1 kraj_prvog, svaki_tip2 pocetak_drugog)
{
	while(pocetak_prvog != kraj_prvog)
	{
	//	auto da_vidim_drugi(*pocetak_drugog);
		auto temp(*pocetak_prvog);
		*pocetak_prvog = *pocetak_drugog;
		*pocetak_drugog = temp;

		pocetak_prvog++;
		pocetak_drugog++;
	}
	return pocetak_drugog;
}

int main ()
{
int a[]{1, 2, 3, 4, 5}, b[]{6, 7, 8, 9, 10};
RazmijeniBlokove(std::begin(a), std::end(a), std::begin(b));
std::cout << "Prvi niz: ";
for(int x : a) std::cout << x << " ";
std::cout << "\nDrugi niz: ";
for(int x : b) std::cout << x << " ";
	return 0;
}
-----------------------------------------------------------------------------------
3
/*
    TP 2018/2019: Tutorijal 5, Zadatak 3

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje niz[i] ili simulacija indeksiranja
			  npr. *(niz + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <deque>
#include <cmath>


using namespace std;

void Unos(int &n)
{
	//int m;
	cin>>n;
	//n=m;
}
int main ()
{
	int broj_elemenata;
	//char za_vektor[1000];
	//int niz[1000];
	cout << "Unesite broj elemenata (max. 1000): ";
		cin >> broj_elemenata;
		cin.ignore(10000, '\n');
	//string za_vektor;
	int niz[1000];
	cout << "Unesite elemente: ";
		//getline(cin, za_vektor, '\n');
		for_each(niz, niz+broj_elemenata, Unos);
	int max(*max_element(begin(niz), niz + broj_elemenata));
	cout << "Najveci element niza je " << max;
	cout << endl << "Najmanji element niza se pojavljuje " << count(begin(niz), niz+broj_elemenata, *min_element(begin(niz), niz+broj_elemenata)) << " puta u nizu";
	cout << endl << "U nizu ima " << count_if(begin(niz), niz+broj_elemenata, [](int broj) {
		//double broj1(broj);
		if(sqrt(broj)*(int)sqrt(broj) == broj)
			return true;
		return false;

	}) << " brojeva koji su potpuni kvadrati";
	cout << endl << "Prvi element sa najmanjim brojem cifara je " << *min_element(begin(niz), niz+broj_elemenata, [](int broj1, int broj2) {

		int suma1(log10(abs(broj1)) + 1);
		int suma2(log10(abs(broj2)) + 1);
		if(suma1 < suma2) return true;
		return false;
	});
	int trocifreni[1000], broj_trocifrenih(count_if(niz, niz+broj_elemenata, [](int broj)
		{
			if(broj / 10 == 0)
				return false;
			if(broj / 100 == 0)
				return false;
			if(broj / 1000 == 0)
				return true;

			return false;
		}));

		remove_copy_if(niz, niz+broj_elemenata, trocifreni, [](int broj)
		{
			if(broj / 10 == 0)
				return false;
			if(broj / 100 == 0)
				return false;

			if(broj / 1000 == 0)
				return true;

			return false;
		});
		cout << endl <<"Elementi koji nisu trocifreni su: ";
	for_each(trocifreni, trocifreni+broj_elemenata-broj_trocifrenih, [](int broj)
	{
		cout << broj << " ";
	});

	//for(int i=0;i<broj_elemenata;i++)
	//cout << niz[i] << " ";

	return 0;
}
----------------------------------------------------------------------------------
4
/*
    TP 2018/2019: Tutorijal 5, Zadatak 3

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje dek[i] ili simulacija indeksiranja
			  npr. *(dek + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <deque>
#include <cmath>


using namespace std;

void Unos(int &n)
{
	//int m;
	cin>>n;
	//n=m;
}
int main ()
{
	int broj_elemenata;
	//char za_vektor[1000];
	//int dek[1000];
	cout << "Unesite broj elemenata: ";
		cin >> broj_elemenata;
		cin.ignore(10000, '\n');
	//string za_vektor;
	deque<int> dek(broj_elemenata);
	cout << "Unesite elemente: ";
		//getline(cin, za_vektor, '\n');
		for_each(dek.begin(), dek.end(), [](int &broj) { cin >> broj; });
	int max(*max_element(begin(dek), dek.end()));
	cout << "Najveci element deka je " << max;
	cout << endl << "Najmanji element deka se pojavljuje " << count(begin(dek), dek.end(), *min_element(begin(dek), dek.end())) << " puta u deku";
	cout << endl << "U deku ima " << count_if(begin(dek), dek.end(), [](int broj) {
		//double broj1(broj);
		if(sqrt(broj)*(int)sqrt(broj) == broj)
			return true;
		return false;

	}) << " brojeva koji su potpuni kvadrati";
	cout << endl << "Prvi element sa najmanjim brojem cifara je " << *min_element(begin(dek), dek.end(), [](int broj1, int broj2) {

		int suma1(log10(abs(broj1)) + 1);
		int suma2(log10(abs(broj2)) + 1);
		if(suma1 < suma2) return true;
		return false;
	});

	int broj_trocifrenih(count_if(dek.begin(), dek.end(), [](int broj)
		{
			if(broj / 10 == 0)
				return false;
			if(broj / 100 == 0)
				return false;
			if(broj / 1000 == 0)
				return true;

			return false;
		}));

	deque<int> trocifreni(broj_elemenata);


		remove_copy_if(dek.begin(), dek.end(), trocifreni.begin(), [](int broj)
		{
			if(broj / 10 == 0)
				return false;
			if(broj / 100 == 0)
				return false;

			if(broj / 1000 == 0)
				return true;

			return false;
		});
		cout << endl <<"Elementi koji nisu trocifreni su: ";
	for_each(trocifreni.begin(), trocifreni.begin() + broj_elemenata - broj_trocifrenih, [](int broj)
	{
		cout << broj << " ";
	});

	//for(int i=0;i<broj_elemenata;i++)
	//cout << dek[i] << " ";

	return 0;
}
------------------------------------------------------------------------------
5
/*
    TP 2018/2019: Tutorijal 5, Zadatak 5

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje niz[i] ili simulacija indeksiranja
			  npr. *(niz + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;
template <typename Tip1, typename Tip2>
double TrapeznoPravilo(double f(double), Tip1 a, Tip2 b, int interval)
{

	double suma(f(a)/2 + f(b)/2.);
	for(int i=1; i<interval;i++)
		suma += f(a + (b-a)*i/(double)interval);
	return (b-a)*suma/interval;
}
int main ()
{
	int interval;

	cout << "Unesite broj podintervala: ";
		cin >> interval;
	cout << "Za taj broj podintervala priblizne vrijednosti integrala iznose:" << endl;
	cout <<"- Za funkciju sin x na intervalu (0,pi): " << setprecision(5) << fixed << TrapeznoPravilo(sin, 0, 4*atan(1), interval);
	cout << endl << setprecision(2) <<"- Za funkciju x^3 na intervalu (0,10): " << fixed << TrapeznoPravilo([](double x) { return x*x*x;}, 0, 10, interval);
	cout << endl << setprecision(5)<<"- Za funkciju 1/x na intervalu (1,2): " << fixed << TrapeznoPravilo([](double x) { return 1./x;}, 1, 2, interval);

	return 0;
}
------------------------------------------------------------------------------------------------------------------------
6
/*
    TP 2018/2019: Tutorijal 5, Zadatak 6

	Autotestove pisala Nina Slamnik. Prijave gresaka, sugestije i pitanja
	mozete slati na mail nslamnik1@etf.unsa.ba.

	NAPOMENA: Tutorijal 5 sadrzi veliki broj ZABRANA, tipa zabrana
			  da se koristi indeksiranje niz[i] ili simulacija indeksiranja
			  npr. *(niz + i); dalje, da su zabranjene for petlje i slicno.

			  To ce tutori rucno pregledati u toku tutorijala te ako
			  student bude PREKRSIO BAREM JEDNU ZABRANU, smatrace se da
			  za taj zadatak NIJE PROSAO NITI JEDAN AUTOTEST!
*/
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int Suma(int suma);

int Suma(int suma)
{	if(suma == 0)
		return 0;

		return abs(suma)%10 + Suma(abs(suma)/10);

}



int main ()
{
	int broj_elemenata;

	cout << "Unesite broj elemenata: ";
		cin >> broj_elemenata;
		vector<int> v(broj_elemenata);
	cout << "Unesite elemente: ";
		for_each(v.begin(), v.end(), [](int &broj) { cin >> broj; });
		sort(v.begin(), v.end(), [](int x, int y) {
			int suma1(Suma(x)), suma2(Suma(y));
			if(suma1 == suma2)
				return x < y;
			else if(suma1 < suma2)
				return true;
			return false;
		});
		cout << "Niz sortiran po sumi cifara glasi: ";
		for_each(v.begin(), v.end(), [](int broj) { cout << broj << " ";});

		int trazim;
		cout << endl << "Unesite broj koji trazite: ";
			cin >> trazim;

		if(find(v.begin(), v.end(), trazim) == v.end())
			cout << "Trazeni broj ne nalazi se u nizu!";
		else
			cout << "Trazeni broj nalazi se na poziciji " << find(v.begin(), v.end(), trazim) - v.begin();
	return 0;
}
----------------------------------------------------------------------------------------------------
Tutorijal 4
1
//TP 2018/2019: Tutorijal 4, Zadatak 1
#include <iostream>
#include <cmath>

using namespace std;

int Cifre(long long int n, int &min, int &max)
{
    int br(0);
    // Ne treba mnoziti sa -1 ako je negativan, ima test koji provjerava za long long int min, a on je za jedan veci od max, pa se opet vrati u negativnu vrijednost
    if(n == 0)
    {
        br = 1;
        min = 0;
    }

    //Ovo ispod rijesi problem sa inicijalizacijom, ne znam zasto hahaha
    max = fabs(n%10);
    min = fabs(n%10);
    while(n != 0)
    {
        if(max < fabs(n%10))
            max = fabs(n%10);

        if(min > fabs(n%10))
            min = fabs(n%10);

        n /= 10;
        br++;
    }

    return br;
}

int main ()
{

    long long int broj;
    cout << "Unesite broj: ";
        cin >> broj;
    int min(9), max(0);
    int e(Cifre(broj, min, max));
    cout << "Broj " << broj << " ima " << e << " cifara, najveca je " << max << " a najmanja " << min << ".";
	return 0;
}
---------------------------------------------------------------------------------
//TP 2018/2019: Tutorijal 4, Zadatak 2
#include <iostream>
#include <string>

using namespace std;

void IzvrniString (string &s)
{
    int i(0), j(s.size()-1); // Minus 1 zato sto ukupno ima s.size() slova, ali posto ide od 0, to znaci da je zadnje slovo na s.size()-1
    while(i < j)// Ovdje ne moze != zato sto u slucaju da imamo paran broj rijeci, oni ce se mimoici
    {
        char temp(s.at(i));// Kontas kako se ovo mijenja
        s.at(i) = s.at(j);
        s.at(j) = temp;
        i++;
        j--;
    }
}

int main ()
{
    string s;
    cout << "Unesi string: ";
        getline(cin, s);

    IzvrniString(s);
    cout << "Izvrnuti string je: " << s;
	return 0;
}
--------------------------------------------------------------------------
//TP 2018/2019: Tutorijal 4, Zadatak 3
#include <iostream>
#include <vector>
#include <string>

using namespace std;
// Vrijedi isto
string Provjera_max(string s1, string s2)
{
    char znak1, znak2;
    for(int i=0;i<s1.size() && i<s2.size();i++)
    {
        znak1 = toupper(s1.at(i));
        znak2 = toupper(s2.at(i));
        if((int)znak1 != (int)znak2)
        {
            if((int)znak1 < (int)znak2)
                return s2;

            else
                break;
        }
    }
    return s1;
}

string Provjera_min(string s1, string s2)
{
    char znak1, znak2;
    for(int i=0;i<s1.size() && i<s2.size();i++)
    {
        // Ova dva chara sam stavio samo da mogu provjeriti sta radi program kroz debugger
        znak1 = toupper(s1.at(i));
        znak2 = toupper(s2.at(i));
        if((int)znak1 != (int)znak2) // Ako su isti u oba stringa, program ne radi nista, dok ako su razliciti znaci da je jedan znak ili veci ili manji
        {
            if((int)znak1 > (int)znak2) // Ako je manji u drugom stringu, to znaci da on ima veci abecedni poredak
                return s2; // Zato ovdje vracamo string 2

            else
                break; // Ako smo usli u ovaj if ikako to znaci nema potrebe da se for petlja nastavlja
        }
    }
    return s1; // U slucaju da su isti stringovi proslijedjeni
}

void IzdvojiKrajnjeRijeci(vector<string> v, string &prvi, string &zadnji)
{
    prvi = v[0];
    zadnji = v[0];
    for(int i=1;i<v.size();i++)
    {
        prvi = Provjera_min(prvi, v.at(i)); // Salje u funkciju koja vraca onaj string koji ima veci abecedni poredak
        zadnji = Provjera_max(zadnji, v.at(i)); // Salje u funkciju koja vraca onaj string koji ima manji abecedni poredak
    }
}
// Predajem se...
void ZadrziDuplikate(vector<string> &v)
{
    vector<string> provjera(v);
    vector<string> vraca(1);
    int nije(1);
    for(int i=0;i<v.size();i++)
    {
        for(int j=i+1;j<v.size()-1;j++)
        {
            if(v[i] == provjera[j])
            {
                nije = 1;
                for(int k=0;k<vraca.size();k++)
                    if(vraca.at(k) == v.at(i))
                    {
                        nije = 0;
                        break;
                    }
                if(nije)
                    vraca.push_back(v.at(i));
            }
        }

    }
    v = vraca;


}

int main ()
{
    int elementi;
    cout << "Koliko zelite unijeti rijeci: ";
        cin >> elementi;

        cin.ignore(10000, '\n'); // Retardirani \n me zeza vec 2 sata, treba cin.ignore jer poslije unosenja broja pritisnemo enter

    vector<string> v(elementi);
    cout << "Unesite rijeci: ";
    for(int i=0;i<elementi;i++)
        {
            if(i < elementi-1)
                getline(cin, v.at(i), ' '); // Poslije svako unosa osim posljednjeg ce biti space
            else
                getline(cin,v.at(i)); // Ovo kada unesemo posljednji enter

        }

    string prvi, zadnji;
    IzdvojiKrajnjeRijeci(v, prvi, zadnji);
    ZadrziDuplikate(v);
    cout << "Prva rijec po abecednom poretku je: " << prvi << endl;
    cout << "Posljednja rijec po abecednom poretku je: " << zadnji << endl;
    cout << "Rijeci koje se ponavljaju su: ";
    for(int i=0;i<v.size();i++)
        cout << v.at(i) << " ";
	return 0;
}
---------------------------------------------------------------------------------
//TP 2018/2019: Tutorijal 4, Zadatak 4
#include <iostream>
#include <string>

using namespace std;

template <typename TipBroja>
void UnosBroja(string unos, string greska, TipBroja &broj)
{
    int provjera(0);
    do
    {
        cout << unos;

        if(!(cin >> broj) || cin.peek() != '\n') //ako nije broj ni novi red
        {
            cout << endl << greska;
            cin.clear();
            cin.ignore(10000, '\n');
        }
        else
            provjera = 1;
        cout << endl;
    }while(!provjera);
}


int main ()
{
    double baza, suma(1);
    int eksponent;

    UnosBroja("Unesite bazu: ", "Neispravan unos, pokusajte ponovo...", baza);
    cout << endl;
    UnosBroja("Unesite cjelobrojni eksponent: ", "Neispravan unos, pokusajte ponovo...", eksponent);
    cout << endl;
    if(eksponent < 0)
    {
        for(int i=0;i<eksponent*-1;i++)
            suma *= 1./baza;
    }
    else
    {
        for(int i=0;i<eksponent;i++)
            suma *= baza;
    }

    cout << baza << " na " << eksponent << " iznosi " << suma;
	return 0;
}
----------------------------------------------------------------------------------