TP - prvi popravni 2014.

/*Rješenje popravnog roka iz TP - prva parcijala*/

Zadatak 1:

#include <iostream>
#include <vector>

std::vector<int> NajmanjaCifraElemenata(std::vector<int> v)
{
    std::vector<int> VektorRezultata; //Pošto trebamo vratiti novi vektor, a ne modifikovati stari, treba nam jedan vektor
    for(unsigned int i(0); i < v.size(); i++)
    {
        //Krećemo se kroz vektor, klasičnom for petljom
        if(v[i] < 0)
            v[i]*=-1; //Rečeno je da elementi mogu biti i negativni, a pošto nam samo treba najmanja cifra, taj minus mora biti ingorisan
        //Da nismo množili sa -1, bukvalno bi uzimao najveću cifru, ali sa predznakom -, jer bi svaku cifru posmatrao kao negativnu,
        //pa bi najmanja cifra bila ona što je najviše negativna(logično)
        int NajmanjaCifra(v[i] % 10);
        while(v[i] > 0)
        {
            //Klasičan algoritam traženja najmanjeg elementa
            //Postavimo zadnju cifru kao referentnu i provjeravamo, da li je ona veća od ostalih
            //ako jeste, onda je nova najmanja ona s kojom smo poredili
            if(NajmanjaCifra > v[i] % 10)
                NajmanjaCifra = v[i] % 10;
            v[i]/=10;
        }
        VektorRezultata.push_back(NajmanjaCifra); //Nađenu najmanju cifru, ubacujemo u vektor koji ćemo vratiti iz funkcije
    }
    return VektorRezultata;
}

int main()
{
    std::vector<int> v1(10);
    for(unsigned int i(0); i < v1.size(); i++)
        std::cin >> v1[i];
    std::vector<int> v2(NajmanjaCifraElemenata(v1));
    for(int &x : v2)
        std::cout << x << " ";
    return 0;
}

Zadatak 2:

#include <iostream>
#include <vector>
#include <stdexcept>
#include <iomanip>

typedef std::vector<std::vector<double>> Matrica; //Pošto je konstrukcija rogobatna onda fino stavimo typedef

Matrica KreirajMatricu(int br_redova, int br_kolona) //Funkcija koja vraća matricu sa zadanim brojem redova i kolona
{
    return Matrica(br_redova, std::vector<double>(br_kolona));
}

void UnesiMatricu(Matrica &a) //Funkcija za unos matrice
                             //Razlika je samo što smo umjesto proslijeđivanja dimenzija matrice
                            //jednostavno proslijedili referencu, te kreiranu matricu samo modifikovali
{
    for(unsigned int i(0); i < a.size(); i++)
        for(unsigned int j(0); j < a[0].size(); j++)
        {
            std::cout << "Unesite element (" << i + 1 << "," << j + 1 << "): ";
            std::cin >> a[i][j];
        }
}

void IspisiMatricu(const Matrica &a) //Funkcija za ispis, sa rangovskom for petljom
{
    std::cout << std::endl;
    for(const auto &i : a)
    {
        for(const auto &j : i)
            std::cout << std::setw(8) << j;
        std::cout << std::endl;
    }
}

bool MoguLiSeMnoziti(const Matrica &a, const Matrica &b) //Testiramo da li su matrice saglasne za množenje
{
    return a[0].size() == b.size();
}

bool ImaLiFormuMatrice(const Matrica &a) //Testiramo da li parametar ima formu matrice
{
    for(unsigned int i(0); i < a.size(); i++)
        if(a[i].size() != a[0].size())
            return false;
    return true;
}

Matrica ProduktMatrica(const Matrica &a, const Matrica &b)
{
    if(!MoguLiSeMnoziti(a, b)) throw std::domain_error("Matrice nisu saglasne za mnozenje!");
    if(!ImaLiFormuMatrice(a) || !ImaLiFormuMatrice(b)) throw std::domain_error("Parametar nema formu matrice!");
    Matrica Produkt(KreirajMatricu(a.size(), b[0].size())); //Kreiramo neku matricu u koju cemo smjestati elemente
    for(unsigned int i(0); i < Produkt.size(); i++)
        for(unsigned int j(0); j < Produkt[i].size(); j++)
        {
            double Suma(0);
            for(unsigned int k(0); k < b.size(); k++)
                Suma+=a[i][k]*b[k][j];
            Produkt[i][j] = Suma;
        }
    return Produkt;
}

int main()
{
    int br_redova, br_kolona;
    std::cout << "Unesite dimenzije matrice A: ";
    std::cin >> br_redova >> br_kolona;
    Matrica A(KreirajMatricu(br_redova, br_kolona));
    UnesiMatricu(A);
    std::cout << "Unesite dimenzije matrice B: ";
    std::cin >> br_redova >> br_kolona;
    Matrica B(KreirajMatricu(br_redova, br_kolona));
    UnesiMatricu(B);
    try
    {
        Matrica C(ProduktMatrica(A, B));
        IspisiMatricu(C);
    }
    catch(std::domain_error izuzetak)
    {
        std::cout << izuzetak.what();
    }
    return 0;
}

Zadatak 3:

#include <iostream>
#include <vector>

template <typename NedefiniraniTip, typename TipFunkcije>
auto Funkcija(NedefiniraniTip x, TipFunkcije f, int n) -> decltype(x) //Jedina caka je prepustiti potpunoj dedukciji
                                                                      //da odredi povratni tip i tip parametara funkcije f
                                                                      //a povratni tip Funkcije se određuje naknadno
{
    auto Rezultat(f(x)); //Ovdje smo uzeli početnu vrijednost i izračunali onu prvu unutrašnju zagradu
    for(int i(1); i < n; i++) //Ovdje nastavljamo ali za jedan put manje jer smo već izračunali početnu vrijednost
        Rezultat = f(Rezultat);
    return Rezultat;
}

int main()
{
    int n;
    std::cout << "Unesite n: ";
    std::cin >> n;
    std::cout << Funkcija(10, [](int x) {return 3*x*x-5;}, n); //Testiramo našu funkciju, koristeći lambda funkcije
                                                               //jer nam više ta funkcija nije potrebna nigdje
    return 0;
}

Zadatak 6:

#include <iostream>
#include <vector>
#include <list>

template <typename IterTip1, typename IterTip2>
IterTip2 KumulativnaSuma(IterTip1 Pocetak1, IterTip1 Kraj, IterTip2 Pocetak2) //Deklaracija prototipa kao što je tražena u zadatku
{
    int Counter(1); //Jedan brojač koji će nam pomoći, da saznamo koliko elemenata treba sabrati
    for(auto p(Pocetak1); p != Kraj; p++, Counter++) //Uzmemo drugi iterator/pokazivač da bi kasnije mogli iskoristiti Pocetak1
    {
        auto q(Pocetak1); //Zabilježimo početak
        for(int i(0); i < Counter; i++) //Jedna petlja koja sabira svaki put po element više, krećući od prvog elementa
            *Pocetak2+=*q++; //Smjestimo u iterator/pokazivač sumu elemenata
        Pocetak2++; //Pomjerimo ga na idući element odredišnog bloka
    }
    return Pocetak2;
}
//Ovakvo nešto smo uradili jer npr indeksacije poput v.begin()-counter ili *(pok-2) ne bi radile za liste, jer se one ne mogu indeksirati
int main()
{
    std::list<int> lista {1, 2, 3, 4};
    std::vector<int> v(lista.size());
    KumulativnaSuma(lista.begin(), lista.end(), v.begin());
    for(const auto &x : v)
        std::cout << x << " ";
    return 0;
}

Zadatak 7:

#include <iostream>
#include <deque>
#include <complex>
#include <algorithm>

bool KriterijSortiranja(std::complex<double> z1, std::complex<double> z2)
{
    if(std::abs(z1) < std::abs(z2)) //Ako je z1 po modulu manji od z2, to je pravi poredak
        return true;
    if(std::abs(z1) == std::abs(z2)) //Ili ako su moduli jednaki, onda treba gledati da li je realni dio z1 manji od z2
                                    //Ako je realni dio z1 manji od realnog dijela z2, to je pravi poredak
        return std::real(z1) < std::real(z2);
    return false; //U svakom drugom slučaju poredak nije dobar
}

int main()
{
    std::deque<std::complex<double>> d;
    int n;
    std::cout << "Unesite broj elemenata deka: ";
    std::cin >> n;
    for(int i(0); i < n; i++)
    {
        std::complex<double> z;
        std::cin >> z;
        d.push_back(z);
    }
    std::sort(d.begin(), d.end(), KriterijSortiranja);
    for(auto &x : d)
        std::cout << x << " ";
    return 0;
}

Zadatak 8:

#include <iostream>
#include <string>
#include <vector>
#include <cstring>
#include "TestCurenja.h"

template <typename TipElemenata>
TipElemenata **Alociraj(std::vector<std::string> v)
{
    TipElemenata **NizPokazivaca(new TipElemenata*[v.size()]); //Dinamička alokacija niza pokazivača
                                                               //Ako ona ne uspije, baca se bad_alloc
                                                               //koji će biti uhvaćen tek u mainu, curenja neće biti jer nije ni
                                                               //alocirano ništa
    for(unsigned int i(0); i < v.size(); i++) //Postavimo sve pokazivače na nullptr, ukoliko neka od dole alokacija ne uspije
                                              //nullptr nam garantuje da neće biti double delete ako na njega primjenimo delete
        NizPokazivaca[i] = nullptr;
    try
    {
        for(unsigned int i(0); i < v.size(); i++) //Prolazimo kroz niz pokazivača
        {
            NizPokazivaca[i] = new TipElemenata[v[i].length() + 1]; //Svakom pokazivaču dodijelimo novi dinamički alociran niz tipa char
                                                                    //ali veličine koja je jednakak dužini odgovarajućeg stringa + 1 jer se
                                                                    //ovdje ipak radi o null terminiranom stringu, pa moramo imati 1 mjesto više
            std::strcpy(NizPokazivaca[i], v[i].c_str()); //Kopiramo string iz vektora stringova u odgovarajuće mjesto u dinamički alociranom
                                                        //nizu, uz eksplicitnu konverziju tipa string u niz znakova, jer automatska nije podržana
        }
    }
    catch(std::bad_alloc) //Ako neka od ovih alokacija u try bloku nije uspjela, eto nas ovdje
    {
        for(unsigned int i(0); i < v.size(); i++)
            delete[] NizPokazivaca[i]; //Brišemo svaki dinamički alociran niz na koji pokazuju pokazivači
        delete[] NizPokazivaca; //Brišemo sam niz pokazivača
        throw; //Proslijedimo izuzetak dalje, jer nas nije briga ko će ga uhvatiti
    }
    return NizPokazivaca;
}

int main()
{
    std::vector<std::string> v {"Test", "ovo", "ispisi"};
    try
    {
        auto p(Alociraj<char>(v));
        for(unsigned int i(0); i < v.size(); i++)
            std::cout << p[i] << " ";
        for(unsigned int i(0); i < v.size(); i++)
            delete[] p[i];
        delete[] p;
    }
    catch(std::bad_alloc)
    {
        std::cout << "Alokacija nije uspjela!";
    }
    return 0;
}