PR I // II. PARCIJALA - NAPREDNI ZADACI

/*................................................................ZADATAK1.............................................................
Poštujući sve faze procesa programiranje, napisati program će odrediti i ispisati zadnje tri cifre broja x^n. Unos brojeva x i n vršiti u glavnoj funkciji uz uslov 10<x<100 i 2<n<10,
a funkciju za određivanje zadnje tri cifre napraviti zasebno.

Primjer izlaza:
Unesite brojeve x i n: 64 i 5
Zadnje tri cifre broja su: 824
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

void ZadnjeTri(int, int);

int main()
{

        int x, n;

        do {
            cout << "Unesite broj x : ";
            cin >> x;
            } while (x < 10 || x>100);


        do {
            cout << "Unesite n : ";
            cin >> n;
            } while (n < 2 || n > 10);

        ZadnjeTri(x, n);

system("pause>0");
return 0;
}

void ZadnjeTri(int x, int n)
{
        int broj, cifra = 0;

        broj = pow(x, n);
        for (int i = 0; i < 3; i++)
        {
            cifra += broj % 10 * pow(10, i);
            broj /= 10;
        }
        cout << "Zadnje 3 cifre : " << cifra;
}
/*.................................................................ZADATAK2............................................................
Napisati program koji će učitati prirodni broj n <= 10, a zatim n prirodnih trocifrenih brojeva koje treba pospremiti u odgovarajući niz.Taj niz brojeva treba sortirati uzlazno po
srednjoj cifri. Nakon sortiranja treba ispisati dobiveni niz. Za sortiranje koristiti zasebnu funkciju kojoj se proslijeđuje nesortiran niz.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

void unos(int[], int);
void sort(int[], int);
void ispis(int[], int);

int main() {
    int niz[10], n;

    cout << "Unesite prirodni broj n : ";
    do
        cin >> n;
    while (n < 1 || n >10);

    unos(niz, n);
    sort(niz, n);
    ispis(niz, n);

    system("pause>0");
    return 0;
}

void unos(int niz[], int v) {
    cout << "Unesite clanove niza : ";
    for (int i = 0; i < v; i++){
        cin >> niz[i];
        if (niz[i] < 100 || niz[i] > 999)
            i--;
    }
}

void sort(int niz[], int v) {
    int broj, cifra1, cifra2, temp;
    bool provjera;
    do{
        provjera = false;
    for (int i = 1; i < v; i++) {
        broj = niz[i-1];
        cifra1 = (broj / 10) % 10;
        broj = niz[i];
        cifra2 = (broj / 10) % 10;
        if (cifra1 > cifra2){
            temp = niz[i];
            niz[i] = niz[i - 1];
            niz[i - 1] = temp;
            provjera = true;
        }
    }
    } while (provjera);
}

void ispis(int niz[], int v) {
    cout << "Niz nakon sortiranja : " << endl;
    for (int i = 0; i < v; i++)
        cout << niz[i] << " ";
}

/*.................................................................ZADATAK3............................................................
Napisati program koji će omogućiti:
• 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
• Izvršiti transpoziciju niza tako što će se zamjeniti redovi i kolone – Koristiti funkciju transpose, a zatim na osnovu izmijenjenog 2D niza:
• Izračunati aritmetičku sredinu svih prostih brojeva ispod sporedne dijagonale – Koristiti dvije funkcije: aritmeticka i prost_broj (pozivati će se iz funkcije aritmeticka)
• Napisati funkciju simpatican koja će provjeriti da li su brojevi iznad sporedne dijagonale simpatični*.
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.
*/


#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 2;

void unos(int[][v]);
void transpose(int[][v]);
void ispis(int[][v]);
bool prost(int);
void art(int[][v]);
void simpaticni(int[][v]);
bool simpProvjera(int);
int Zbir(int);

int main() {

    int niz[v][v];

    unos(niz);
    ispis(niz);
    transpose(niz);
    ispis(niz);
    art(niz);
    simpaticni(niz);

    system("pause>0");
    return 0;
}

void unos(int niz[][v]) {
    cout << "Unesite clanove niza : ";
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            cin >> niz[i][j];
            if (niz[i][j] < 10 || niz[i][j] > 99)
                j--;
        }
    }
}

void transpose(int niz[][v]) {
    int niz2[v][v];
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            niz2[j][i] = niz[i][j];
        }
    }
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            niz[i][j] = niz2[i][j];
        }
    }

}

void ispis(int niz[][v]){
    cout << "Matrica : " << endl;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            cout << niz[i][j] << " ";
        }
        cout << endl;
    }
}

void art(int niz[][v]) {
    float art = 0;
    int brojac = 0;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            if (i + j >= v) {
                if (prost(niz[i][j])){
                    art += niz[i][j];
                    brojac++;
                }

            }
        }
    }
    cout << "Artimeticka sredina prostih brojeva ispod sporedne dijagonale je : " << art / brojac << endl;
}

bool prost(int x) {
    for (int i = 2; i <= x / 2; i++) {
        if (x%i == 0) {
            return false;
        }
    }
    return true;
}

void simpaticni(int niz[][v]) {
    int simp[10], brojac = 0;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            if (i + j < v - 1) {
                if (simpProvjera(niz[i][j]))
        {
                    simp[brojac++] = niz[i][j];
                }
            }
        }
    }
    cout << "Simpaticni brojevi iznad sporedne dijagonale su : ";
    for (int i = 0; i < brojac; i++)
        cout << simp[i];
}

bool simpProvjera(int x) {
    if (Zbir(x*x) == Zbir(x*Zbir(x)))
        return true;
    else
        return false;
}

int Zbir(int x) {
    int suma = 0, cifra;
    while (x > 0)
    {
        cifra = x % 10;
        suma += cifra;
        x /= 10;
    }
    return suma;
}

/*..............................................................ZADATAK4...............................................................
Napisati program koji od korisnika zahtijeva unos niza od najviše 20 realnih brojeva u rasponu od -100 do 100. U slučaju da korisnik unese bilo koji broj izvan datog raspona korisnik
ponavlja unos tog elementa niza. Također, unos je moguće prekinuti prije nego što se dostigne kapacitet niza unosom broja 0 koji ne treba da bude element niza i služi samo za prekid.
Nakon toga, program računa aritmetičku sredinu unesenih brojeva, te iz niza izbacuje sve one elemente čija je udaljenost od aritmetičke sredine veća od 10,
na način da se sačuva redoslijed dodavanja elemenata. Implementaciju uraditi upotrebom sljedećih funkcija:
• void unos (double[], int, int&); gdje je treći parametar stvarna veličina niza nakon unosa;
• double aritmeticka_sredina(double[], int);
• void ukloni(double[], int, double, int&); gdje je drugi parametar aritmetička sredina, a posljednji veličina niza nakon uklanjanja elemenata.
U glavnom programu testirati dostupne funkcije, te obaviti ispis elemenata niza nakon uklanjanja vodeći se datim primjerom izlaza.
*/


#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 20;

void unos(double[], int, int&);
double aritmeticka_sredina(double[], int);
void ukloni(double[], int, double, int&);
void ispis(double[], int);

int main()
{

    double niz[v], ar;
    int sv = 0;

    unos(niz, v, sv);
    ar = aritmeticka_sredina(niz, sv);
    cout << "Artimeticka sredina je : " << ar << endl;
    ispis(niz, sv);
    ukloni(niz, 20, ar, sv);
    cout << "Velicina novog niza je : " << sv << endl;
    ispis(niz, sv);

    system("pause>0");
    return 0;
}

void unos(double niz[], int v, int &sv)
{

    cout << "Unesite clanove niza : " << endl;

    for (int i = 0; i < v; i++) {
        do
            cin >> niz[i];
        while (niz[i] < -100 || niz[i]>100);

        if (niz[i] == 0)
            return;

        sv++;
    }
}


void ispis(double niz[], int v)
{
    for (int i = 0; i < v; i++)
        cout << niz[i] << "  ";
    cout << endl;
}


double aritmeticka_sredina(double niz[], int sv)
{
    double as = 0;
    for (int i = 0; i < sv; i++)
        as += niz[i];

    return as / sv;
}


void ukloni(double niz[], int s, double ar, int &sv)
{
    int brojac = 0, removed = 0;
    for (int i = 0; i < sv; i++)
    {
        if (ar - niz[i] < 10 && niz[i] - ar < 10)
            niz[brojac++] = niz[i];
        else
            removed++;
    }

    sv = sv - removed;
}


/*.....................................................ZADATAK 5 N I J E   Z A V R Š E N...............................................
Neka je data matrica kompetencija studenata dimenzija 10x5, gdje svaki red matrice predstavlja studenta, a svaka kolona matrice kompetenciju koju je potrebno evaluirati.
Matrica sadrži podatke o studentima sa dva studijska programa, prvih 5 redova za jedan i drugih 5 redova za drugi program. Kompetencije se definišu putem sljedeće skale:
A (ekspert), B (stručnjak), C (zadovoljava), D (djelimično zadovoljava) i E (ne zadovoljava). Napisati program koji će implementirati i testirati sljedeće funkcije:
• evaluiraj – funkcija omogućava unos evaluacije za određenog (odabranog u glavnom programu) studenta (unosi se samo jedan red matrice), na način da su dozvoljene samo
vrijednosti usvojene prethodnom skalom (A, B, C, D i E). U slučaju unosa bilo kojeg karaktera izvan ovog opsega, potrebno je ponoviti unos. Prilikom unosa ispisati poruku za svaku
kompetenciju na sljedeći način: „Unesite evaluaciju za kompetenciju C1“, i tako redom za svaku kolonu.
• najuspjesnija_kompetencija – funkcija pronalazi kompetenciju (u oba studijska programa) koja je najuspješnija, odnosno na kojoj su studenti ostvarili najbolji rezultat,
te vraća i prosječnu ocjenu za tu kompetenciju.
Napomena: Pridružiti svakoj oznaci numeričku vrijednost, radi jednostavnosti kalkulacije i poređenja uspjeha pojedinih kompetencija. Koristiti prosljeđivanje najmanje jednog parametra
po referenci, te ispis rezultata ne vršiti u funkciji.
• najuspjesniji_student – funkcija pronalazi najuspješnijeg studenta u odabranom studijskom programu (studijski program se bira u glavnom programu putem vrijednost 1
(prvih 5 redova) ili 2 (drugih 5 redova), te vraća i prosječnu ocjenu tog studenta. Vrijede iste napomene kao i za prethodnu funkciju.
U glavnom programu testirati implementirane funkcije na način da se uz uspjeh kompetencije ili studenta definiše opisna evaluacija (ekspert, stručnjak,...). Dodatno ispisati podatke o
najuspješnijem studentu, posmatrajući oba studijska programa. Ispis najsupješnije kompetencije ili studenta izvršiti sa oznakama C ili S, uz redni broj kolone ili reda gdje se nalaze u
matrici. Npr. Najuspješniji student je S2 sa prosječnom ocjenom „stručnjak“.

*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int r = 10, k = 5;

void evaluiraj(char[], int);
void ispis(char[][k]);
double najkomp(int[][k], int&);
void konverzija(char[][k], int[][k]);
void ispisk(int[][k], int);

int main() {

    char niz[r][k] = {};
    int niz2[r][k] = {};
    int izbor, iz2, najK;
    do {
        cout << "Kojeg studenta zelite evaluirati ? " << endl;
        do {
            cin >> izbor;
        } while ((izbor > 10 || izbor < 1) || niz[izbor - 1][0] != 0);
        evaluiraj(niz[izbor - 1], k);
        cout << "Da li zelite jos evaluacija ? (0 za ne)" << endl;
        cin >> iz2;
    } while (iz2 != 0);
    konverzija(niz, niz2);
    ispis(niz);
    najkomp(niz2, najK);
    ispisk(niz2, najK);
    cout << "Najbolji prosjek ima kompetencija : " << najK + 1;


    system("pause>0");
    return 0;
}

void ispisk(int niz[][k], int najK) {

    cout << "Prosjek naj kompetencije je : " << najkomp(niz, najK) << endl;

}


double najkomp(int niz[][k], int &najK) {
    int naj = 0, temp = 0, brojac = 0;
    for (int i = 0; i < k; i++)
    {
        brojac = 0;
        for (int j = 0; j < r; j++)
        {
            temp += niz[j][i];
            if (niz[j][i] != 0)
                brojac++;
        }
        if (naj < temp) {
            naj = temp;
            najK = i;
        }
        temp = 0;

    }
    return (naj / brojac);

}

void evaluiraj(char niz[], int k) {

    for (int i = 0; i < k; i++) {
        cout << "Unesite evaluaciju za " << i + 1 << " : " << endl;
        do {
            cin >> niz[i];
        } while (!(niz[i] == 'A' || niz[i] == 'B' || niz[i] == 'C' || niz[i] == 'D' || niz[i] == 'E'));
    }
}


void ispis(char niz[][k]) {
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < k; j++) {
            cout << niz[i][j] << "  ";
        }
        cout << endl;
        if (i == 4)
            cout << endl;
    }
}

void konverzija(char niz[][k], int niz2[][k]) {
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < k; j++)
            switch (niz[i][j]) {
                {
            case 'A':
                niz2[i][j] = 5;
                break;
            case 'B':
                niz2[i][j] = 4;
                break;
            case 'C':
                niz2[i][j] = 3;
                break;
            case 'D':
                niz2[i][j] = 2;
                break;
            case 'E':
                niz2[i][j] = 1;
                break;
                }
            }
    }

}


/*..............................................................ZADATAK6...............................................................
Napisati program koji će korisniku omogućiti unos pozitivnih neparnih cijelih brojeva za koje će se ispitivati da li im je prva cifra parna (npr. 4993 ili 4999). Ukoliko je zadovoljen
uslov broj se smješta u niz od 10 elemenata. Unos se ponavlja dok se ne popuni niz od 10 elemenata koji zadovoljavaju uslov unosa. Unos se prekida ukoliko korisnik unese vrijednost 0
te se i izvršenje program završava uz poruku „Forsirani prekid“. Zatim se za sve elemente niza ispituje da li je broj prost i da li ima samo jednu parnu cifru. Ako broj nije prost i
ako ima više od jedne parne cifre, broj se izbacuje iz niza tako što se njegova vrijednost mijenja sa 0. Na kraju niz sortirati od najvećeg ka najmanjem broju te ga ispisati.
Koristiti odvojene funkcije za provjeru da li je broj prost, za sortiranje i ispis niza.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 10;

void unos(int[], int);
bool prost(int);
bool jednaParna(int);
bool prvaParna(int);
void ispis(int[], int);
void promjena(int[], int);
void sort(int[], int);

int main() {
    int niz[v] = {};

    unos(niz, v);
    ispis(niz, v);
    promjena(niz, v);
    ispis(niz, v);
    sort(niz, v);
    ispis(niz, v);

    system("pause>0");
    return 0;
}

void unos(int niz[], int v) {
    cout << "Unesite clanove niza : ";
    for (int i = 0; i < v; i++) {
        cin >> niz[i];
        if (niz[i] == 0)
        {
            cout << "Forsirani prekid " << endl;
            return;
        }
        if (niz[i] % 2 == 0 || prvaParna(niz[i]) || niz[i] < 0)
            i--;
    }
}

bool prvaParna(int x) {
    int brojCifri = 0, kopija = x, prva;
    do {
        brojCifri++;
        kopija /= 10;
    } while (kopija > 0);
    prva = x / pow(10, brojCifri - 1);
    if (prva % 2 == 0)
        return false;
    else
        return true;
}

bool prost(int x) {
    for (int i = 2; i <= x / 2; i++) {
        if (x%i == 0) {
            return false;
        }
    }
    return true;
}

bool jednaParna(int x) {
    int cifra;
    do {
        cifra = x % 10;
        if (x % 2 == 0)
            return false;
        x /= 10;
    } while (x > 10);

    return true;
}

void ispis(int niz[], int v) {
    for (int i = 0; i < v; i++)
        cout << niz[i] << " ";
    cout << endl;
}

void promjena(int niz[], int v) {
    for (int i = 0; i < v; i++) {
        if (!(jednaParna(niz[i]) && prost(niz[i])))
            niz[i] = 0;

    }
}

void sort(int niz[], int v) {
    bool promjena;
    do {
        promjena = false;
        for (int i = 1; i < v; i++) {
            if (niz[i - 1] < niz[i]) {
                swap(niz[i - 1], niz[i]);
                promjena = true;
            }

        }
    } while (promjena);
}

/*.................................................................ZADATAK7............................................................
Deklarisati kvadratnu matricu cijelih brojeva proizvoljnih dimenzija, te implementirati sljedeće funkcije:
• Funkciju za unos i formiranje elemenata matrice prema sljedećem obrascu: elemente neparnih redova matrice (1., 3., 5. itd.) čine minimalno trocifreni brojevi koje unosi korisnik
programa (u slučaju unosa bilo kojeg broja koji ne zadovoljava postavljeni uslov, ponoviti unos); elementi parnih redova matrice se formiraju na osnovu elemenata iz prethodnog reda u
istoj koloni matrice i to na način da je svaki novokreirani element matrice zapravo element s obrnutim redoslijedom cifri elementa iznad njega.
• Za određivanje broja s obrnutim redoslijedom cifri kreirati zasebnu funkciju obratno, te je pozvati u funkciji unos.
• Takvu matricu proslijediti zasebnoj funkciji max koja će formirati novi jednodimenzionalni niz čije članove čine najveći članovi matrice po redovima te ispisati ove članove.
• Formirati posebnu funkciju iznad_dijagonala koja će ispisati broj elemenata matrice koji se nalaze iznad glavne i sporedne dijagonale. Ove elemente unutar funkcije spremati u
niz čija veličina zavisi od dimenzije matrice. Veličina niza treba biti fiksna i mora odgovarati točnom broju elemenata.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 4;

void unos(int[][v]);
void ispis(int[][v]);
void obratno(int[][v]);
void max(int[][v]);
void iznad_dijagonala(int[][v]);

int main() {

    int niz[v][v];

    cout << "Unesite minimalno trocifrene brojeve : " << endl;
    unos(niz);
    ispis(niz);
    max(niz);
    iznad_dijagonala(niz);


    system("pause>null");
    return 0;
}


void unos(int niz[][v]) {
    int unos;

    for (int i = 0; i < v; i += 2) {
        for (int j = 0; j < v; j++) {
            do
                cin >> unos;
            while (unos < 100);
            niz[i][j] = unos;
        }
        cout << endl;
    }
    obratno(niz);
}

void ispis(int niz[][v]) {
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            cout << niz[i][j] << " ";
        }
        cout << endl;
    }
}

void obratno(int niz[][v]) {
    int cifra, novi = 0, temp, brojac = 0;
    for (int i = 1; i < v; i += 2) {
        for (int j = 0; j < v; j++) {
            temp = niz[i - 1][j];
            do {
                temp /= 10;
                brojac++;
            } while (temp > 0);
            temp = niz[i - 1][j];
            do {
                cifra = temp % 10;
                temp /= 10;
                novi = novi + cifra * pow(10, --brojac);
            } while (brojac > 0);
            niz[i][j] = novi;
            novi = 0;
            brojac = 0;
        }
    }
}


void max(int niz[][v])
{
    int novi[v], naj = INT_MIN;
    for (int i = 0; i < v; i++)
    {
        for (int j = 0; j < v; j++)
         {
            if (niz[i][j] > naj)
                naj = niz[i][j];
              }
        novi[i] = naj;
        naj = INT_MIN;
        }
    cout << "Najveci clanovi redova : " << endl;
    for (int i = 0; i < v; i++) {
        cout << novi[i] << endl;
    }
}

void iznad_dijagonala(int niz[][v])
{
    int n[v], a = 0;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            if (j > i && i + j < v - 1) {
                n[a] = niz[i][j];
                a++;
            }
        }
    }

    cout << "Elementi iznad obe dijagonale su : " << endl;
    for (int i = 0; i < a; i++) {
        cout << n[i] << "  ";
    }
}



/*...............................................................ZADATAK8..............................................................
Napisati funkciju koja niz od 10 cijelih brojeva sortira u opadajućem ili rastućem poretku. Unos elemenata niza se obavlja u glavnom programu, kao i odabir opcije koja određuje
da li rezultirajući niz treba biti opadajući ili rastući. Obavezno testirati implementiranu funkciju vodeći se datim primjerom ispisa.
(Pojasnjenje: Nema posebnog pojasnjenja jer se radi o najjednostavijem sortiranju uzlazno ili silazno u odnosu na korisnicki izbor.)
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

int const v = 10;

void sort(int[], int, int);
void ispis(int[], int);

int main() {
    int niz[v], izbor;
    cout << "Unesite elemente niza : " << endl;
    for (int i = 0; i < v; i++)
        cin >> niz[i];
    cout << "Kako zelite sortirati niz (unesite 1 ili 2)\n1. U opadajucem poretku\n2. U rastucem poretku" << endl;
    do{
        cin >> izbor;
    } while (izbor != 1 && izbor != 2);

    sort(niz, v, izbor);
    ispis(niz, v);

    system("pause>0");
    return 0;
}

void sort(int niz[], int v , int izbor) {
    bool promjena;
    do {
        promjena = false;
        for (int i = 1; i < v; i++) {
            if ((izbor == 1 && niz[i - 1] < niz[i]) || (izbor == 2 && niz[i - 1] > niz[i])) {
                swap(niz[i - 1], niz[i]);
                promjena = true;
            }
        }
    } while (promjena);
}

void ispis(int niz[], int v) {
    for (int i = 0; i < v; i++)
        cout << niz[i] << " ";
}


/*...........................................................ZADATAK9..................................................................
Uz pomoć matrice realnih brojeva dimenzija 5x7 izraditi program za evidenciju i kalkulaciju uspješnosti vremenskih prognoza (prosječnih dnevnih temperatura) određenog grada.
Redovi matrice predstavljaju meteorologe čije se prognoze unose, dok se kolone odnose na vremenski period od 7 dana. Uz matricu je neophodno krerati globalni jednodimenzionalni niz od
7 elemenata koji će čuvati stvarna mjerenja temperatura za isti vremenski period, a na osnovu kojeg će se procijeniti uspješnost prognoza pojedinih meteorologa.
Vrijednosti elemenata ovog niza prilikom deklaracije postaviti na: 25.5, 26.8, 21, 32, 35.6, 36, 33.5.
Implementaciju programa uraditi pomoću sljedećih funkcija:
• UnesiPrognoze – funkcija za unos prognoza određenog meteorologa za kompletan period od 7 dana. Vrijednosti prosječnih temperatura moraju biti unutar intervala [-20, 50] °C.
(Pojasnjenje: unose se podaci za samo jedan izabrani red. Tako ce se korisniku omoguciti da unese prognoze za jednog po jednog meteorologa.)
• IzracunajUspjesnost – funkciju koja vraća procentualnu vrijednost uspješnosti prognoza za željenog meteorologa. Prognoza, odnosno prosječna temperatura na određeni dan,
smatra se uspješnom ako od stvarnog mjerenja ne odstupa više od 5 °C. (Pojasnjenje: poredi se podaci iz jednog reda odnosno za jednog meteorologa sa podacima iz posebnog niza koji sadrži
stvarne vrijednosti mjerenja, te ako je razlika manja od +/-5 taj podatak se smatra uspjesnom prognozom. Na kraju treba podjeliti broj uspjesnih prognoza sa 7 koliko ima dana u sedmici i
vratiti procenat uspjesnosti.)
• PronadjiNajuspjesnijegMeteorologa – funkciju koja pronalazi meteorologa sa najtačnijim vremenskim prognozama, odnosno najvećim procentom uspjeha. (Pojasnjenje: Red koji ima
najveci procenat koji se dobije iz prethodno opisane funkcije IzracunajUspjesnost je u stvari red sa najuspjesnijim meteorologom.)
• PronadjiDanSaNajnizimPrognozama – funkciju koja pronalazi dan koji je imao u prosjeku najnize prognoze. (Pojasnjenje: Naci kolonu sa najnizom aritmetickom sredinom svih svojih
vrijednosti. Nije potrebno porediti sa nizom sa stvarnim temperaturama.)
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;


const double temp[7] = { 25.5, 26.8, 21, 32, 35.6, 36, 33.5 };
const int r = 5, k = 7;

void unos(double[]);
void ispis(double[][k]);
double uspjesnost(double[]);
int najm(double[][k]);
int najdan(double[][k]);

int main() {

    double niz[r][k] = {};
    int izbor, iz2, iz3;
    do {
        cout << "Za kojeg meteorologa zelite unijeti prognozu ?" << endl;
        do {
            cin >> izbor;
        } while (izbor < 1 || izbor>5);

        unos(niz[izbor - 1]);
        cout << "Da li zelite unijeti za jos nekog meteorologa ?" << endl;
        cin >> iz2;
        system("CLS");
    } while (iz2 != 0);

    cout << "Za kojeg meteorologa zelite provjeriti uspjesnost ? " << endl;
    do{
    cin >> iz3;
    } while (iz3 < 1 || iz3>5);
    cout << "Uspjesnost za odabranog meteorologa je " << uspjesnost(niz[iz3 - 1]) << "%." << endl;

    cout << "Najuspjesniji meteorolog je : " << najm(niz) << endl;
    cout << "Dan sa najnizim temperaturama je : " << najdan(niz) << ". dan" << endl;
    ispis(niz);

    system("pause>0");
    return 0;
}

void unos(double niz[]) {
    for (int i = 0; i < k; i++)
    {
        cin >> niz[i];
        if (niz[i] > 50 || niz[i] < -20)
            i--;
    }
}

void ispis(double niz[][k]) {
    for (int i = 0; i < r; i++)
    {
        for (int j = 0; j < k; j++) {
            cout << setw(7) << niz[i][j];
        }
        cout << endl;
    }
}

double uspjesnost(double niz[]) {
    double uspjesnost = 0;
    for (int i = 0; i < k; i++) {
        if (niz[i] > temp[i] - 5 && niz[i] < temp[i] + 5)
            uspjesnost += 100;
    }
    return uspjesnost = uspjesnost/7;
}

int najm(double niz[][k]) {
    double naj = uspjesnost(niz[0]);
    int najindex = 1;
    for (int i = 1; i < r; i++) {
        if (uspjesnost(niz[i]) > naj) {
            naj = uspjesnost(niz[i]);
            najindex = i + 1;
        }
    }
    return najindex;
}

int najdan(double niz[][k]) {
    int naj =0;
    double art = 0, najart = INT_MAX;
    for (int i = 0; i < k; i++) {
        for (int j = 0; j < r; j++) {
            art += niz[j][i];
        }
        art = art / r;
        if (art < najart) {
            najart = art;
            naj = i + 1;
        }
        art = 0;
    }
    return naj;
}





/*.............................................................ZADATAK10...............................................................
Napisati funkciju koja kao parametare prima dva niza char recenica[200] i char rijec[10] odnosno rečenicu (niz od najviše 200 karaktera) i riječ (niz od najviše 10 karaktera) te
u nizu recenica[200] pretrazuje i pronalazi sekvencu karaktera unesenih u niz rijec[10]. Radi jednostavnosti rjesenja podrazumjeva se da i recenica i rijec koja se pretrazuje
zavrsavaju tackom. Poslije pronalaska trazene rijeci, pomenutu rijec treba zamijeniti karakterima „FIT“ (Pomoc: Treba voditi racuna koliko karaktera ima rijec koja je pronadjena i
zamjenjena).

Npr. ako je data rečenica u nizu recenica[200]:
    "Ja studiram na fakultetu jer zelim biti expert."
i rijec[10]:
„fakultet“,
funkcija je treba pronaci rijec „fakultet“ u recenici i pretvoriti je u „FIT“:
    " Ja studiram na FITu jer zelim biti expert." (ima ukupno manje slova a zadrzan je samo po jedan space izmedju rijeci)
 Obavezno u main funkciji omoguciti unos recenice, zatim trazene rijeci i ispisati novu recenicu poslije zamjene.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

void ispis(char niz[], int v);
void zamjena(char[], char[], int, int);

int main() {
    char recenica[200] = "Ja sam. student faksa.", rijec[10];
    int brojac = 0, brojac2 = 0;

    cout << "Unesite recenicu : " << endl;
    do {
    cin >> recenica[brojac++];

    } while (recenica[brojac-1] != '.');

    cout << "Unesite rijec koju zelite zamjeniti : " << endl;
    do {
        cin >> rijec[brojac2++];
    } while (rijec[brojac2 - 1] != '.');
    zamjena(recenica, rijec, 200, brojac2);

    system("pause>0");
    return 0;
}

void ispis(char niz[], int v) {
    for (int i = 0; i < v; i++)
        cout << niz[i];
}

void zamjena(char recenica[], char rijec[], int v1, int v2) {
    int brojac = 0, brojac2, br = 0;
    char r2[200];
    for (int i = 0; i < v1; i++) {
        brojac2 = i;
        if (recenica[i] == rijec[brojac])
            for (int j = 0; j < v2; j++) {
                if (recenica[brojac2++] != rijec[brojac++]) {
                    brojac = 0;
                    break;
                }
            }
        if (brojac == v2) {
            r2[br++] = 'F';
            r2[br++] = 'I';
            r2[br++] = 'T';
            i = i + v2;
            brojac = 0;
        }

        r2[br++] = recenica[i];
    }

    ispis(r2, br);
}


/*...........................................................ZADATAK11.................................................................
Neka je dat 2D niz tipa int dimenzija 5x5. Kreirati, a potom u glavnom programu testirati, sljedeće funkcije:
a)  Funkciju koja vrši generisanje Fibonaccijevih brojeva u 2D nizu dok se niz ne popuni
b)  Funkcija koja ispisuje najveće zajedničke djelitelje brojeva na suprotnim indeksima matrice koristeći Euklidov algoritam, kad se indeksi izjednače petlja se treba prekinuti:
Euklidov algoritam(a,b):
Dok(b>0)
    p=a;
    a=b;
    b = p mod b;
NZD=a;
Gdje je 'p' pomoćna varijabla. Suprotni indeksi matrice su matrica[0,0] i matrica[5,5], zatim matrica[0,1] i matrica [5,4] itd .
Primjer:
Najveći zajednički djelitelj za brojeve 610 i 34 je 2. Najveći zajednički djelitelj za brojeve 8 i 2584 je 8 itd.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 5;

void Unos(int[][v]);
void Ispis(int[][v]);
void Euklid(int[][v]);

int main() {

    int niz[v][v];
    Unos(niz);
    Ispis(niz);
    Euklid(niz);

    system("pause>0");
    return 0;
}

void Unos(int niz[][v]) {
    int prvi = 0, drugi = 1, sljedeci = 0;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            prvi = drugi;
            drugi = sljedeci;
            sljedeci = prvi + drugi;
            niz[j][i] = drugi;
        }
    }
}

void Ispis(int niz[][v]) {
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            cout << niz[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

void Euklid(int niz[][v]) {
    int a, b, p, nzd;

    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {

            if (i == v / 2 + 1 && j == v / 2 - 1) {
                break;
            }

            a = niz[i][j];
            b = niz[v - i - 1][v - j - 1];

            while (b > 0) {
                p = a;
                a = b;
                b = p % a;
            }
            nzd = a;
            cout << "Najveci zajednicki djelitelj za " << niz[i][j] << " i " << niz[v - i - 1][v - j - 1] << " je " << nzd << endl;

        }
    }
}


/*.............................................................ZADATAK12...............................................................
Neka je dat 2D niz tipa int dimenzija 10x10. Kreirati, a potom u glavnom programu testirati, sljedeće funkcije:
a)  Funkciju koja za vrsi generisanje podataka u 2D nizu na nacin da se u elementu sa indexom [0][0] upise vrijednost 1 a svaki slijedeci element da ima vrijednost prethodnog
elementa pomnozenog sa 2 kao na slici. Generisanje se prekida ako se desi overflow na varijabli int.
b)  Funkciju koja popunjenu matricu iz pod-zadatka a) transponuje tako sto joj zamjeni redove i kolone.
c)  Funkciju koja kao parametar prima pomenuti niz i index kolone te silazno sortira kompletan 2D niz po izabranoj koloni na nacin da se kompletni redovi zamjene prema vrijednosti
u izabranoj koloni (princip sortiranja po koloni kao u MS Excel tabeli)
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

const int v = 10;
void ini(int[][v]);
void trans(int[][v]);
void sort(int[][v],int);
void ispis(int[][v]);

int main() {
    int niz[10][10] = {}, izbor;

    ini(niz);
    trans(niz);
    ispis(niz);

    cout << "Koju kolonu zelite sortirati ?";
    do
        cin >> izbor;
    while (izbor < 1 || izbor > 10);

    sort(niz, izbor-1);
    ispis(niz);

    system("pause>0");
    return 0;
}

void ini(int niz[][v]) {
    int vr = 1;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            niz[i][j] = vr;

            vr *= 2;
            if (vr < 0)
                break;
        }
    }
}

void trans(int niz[][v]) {
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            niz[j][i] = niz[i][j];
        }
    }
}

void ispis(int niz[][v]) {
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            cout << setw(10) << niz[i][j];
        }
        cout << endl;
    }
    cout << endl;
}

void sort(int niz[][v], int izbor) {
    bool promjena = false;

    do {
        promjena = false;
        for (int j = 1; j < v; j++) {
            if (niz[j-1][izbor] < niz[j][izbor]) {
                swap(niz[j-1][izbor], niz[j][izbor]);
                promjena = true;
            }
        }
    } while (promjena);
}

/*................................................................ZADATAK13............................................................

Napisati program koji će učitati cijeli broj n (1?n?10), (ukoliko unesena vrijednost nije unutar intervala, učitavanje treba ponavljati sve dok se ne unese ispravna vrijednost) i
elemente matrice dimenzija n x n te ispisati je li matrica centralno simetrična s obzirom na središnji element. Ako jest, program treba ispisati 1, ako nije, ispisati 0, a ako je broj
redaka paran broj  (pa nema središnjeg elementa), ispisati -1. Koristiti zasebne funkcije za unos elemenata i provjeru simetričnosti.
*/

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>

using namespace std;

void unos(int[][10], int);
void ispis(int[][10], int);
int provjera(int[][10], int);

int main() {
    int niz[10][10], n;

    cout << "Unesite n(1-10) : " << endl;
    do
        cin >> n;
    while (n < 1 || n > 10);

    unos(niz, n);
    ispis(niz, n);
    cout << provjera(niz, n);

    system("pause>0");
    return 0;
}

void unos(int niz[][10], int v) {
    cout << "Unesite niz : " << endl;
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++)
            cin >> niz[i][j];
    }
}

void ispis(int niz[][10], int v) {
    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++)
            cout << niz[i][j] << " ";
        cout << endl;
    }
    cout << endl;
}

int provjera(int niz[][10], int v){
    if (v % 2 == 0)
        return -1;

    for (int i = 0; i < v; i++) {
        for (int j = 0; j < v; j++) {
            if (niz[i][j] != niz[v - i - 1][v - j - 1])
                return 0;
        }
    }
    return 1;
}