programavimo uzduotys

//2010 metai, 1 uzduotis "sachmatai"

#include <iostream>
#include <fstream>

using namespace std;

void ivestis(int &pestininku, int &bokstu, int &zirgu, int &rikiu, int &karaliu, int &valdoviu);
void skaiciavimas(int &pestininku, int &bokstu, int &zirgu, int &rikiu, int &karaliu, int &valdoviu, int &komplektu);
void isvedimas(int komplektu);

int main()
{
    int pestininku=0, bokstu=0, zirgu=0, rikiu=0, karaliu=0, valdoviu=0, komplektu=0;
    ivestis(pestininku, bokstu, zirgu, rikiu, karaliu, valdoviu);
    skaiciavimas(pestininku, bokstu, zirgu, rikiu, karaliu, valdoviu, komplektu);
    isvedimas(komplektu);
}

void ivestis(int &pestininku, int &bokstu, int &zirgu, int &rikiu, int &karaliu, int &valdoviu){
    int p, b, z, r, k, v, mokiniu;
    ifstream in("U1.txt");
    in >> mokiniu;
    for(int i=0; i<mokiniu; i++){
        in >> p >> b >> z >> r >> k >> v;
        pestininku+=p; bokstu+=b; zirgu+=z; rikiu+=r; karaliu+=k; valdoviu+=v;
    }
    in.close();
}

void skaiciavimas(int &pestininku, int &bokstu, int &zirgu, int &rikiu, int &karaliu, int &valdoviu, int &komplektu){
    while(pestininku>=8 && bokstu>=2 && zirgu>=2 && rikiu>=2 && karaliu>=1 && valdoviu>=1){
        pestininku-=8; bokstu-=2; zirgu-=2; rikiu-=2; karaliu-=1; valdoviu-=1;
        komplektu++;
    }
}

void isvedimas(int komplektu){
    ofstream out("U1rez.txt");
    out << komplektu;
    out.close();
}

//2011 metai. Pirstines

#include <iostream>
#include <fstream>

#define ne lytis[i]!=0 && lytis[u] !=0 && ranka[i]!=0 && ranka[u]!=0 && dydis[u]!=0 && dydis[i]!=0

using namespace std;

void ivedimas(int &n, int lytis[], int ranka[], int dydis[]);
void kiekPoru(int &n, int lytis[], int ranka[], int dydis[], int &vyrporu, int &motporu, int &vyriskos, int &moteriskos);
void koksLikutis(int &vyrlikutis, int &motlikutis, int vyrporu, int vyriskos, int motporu, int moteriskos);
void spausdinti(int motporu, int vyrporu, int vyrlikutis, int motlikutis);


int main()
{
    int n, lytis[100], ranka[100], dydis[100], vyrporu=0, motporu=0, vyriskos=0, moteriskos=0, vyrlikutis, motlikutis;
    ivedimas(n, lytis, ranka, dydis);
    kiekPoru(n, lytis, ranka, dydis, vyrporu, motporu, vyriskos, moteriskos);
    koksLikutis(vyrlikutis, motlikutis, vyrporu, vyriskos, motporu, moteriskos);
    spausdinti(motporu, vyrporu, vyrlikutis, motlikutis);
}

void ivedimas(int &n, int lytis[], int ranka[], int dydis[]){
    ifstream in("U1.txt");
    in >> n;
    for(int i=0; i<n; i++){
        in >> lytis[i];
        in >> ranka[i];
        in >> dydis[i];
    }
    in.close();
}

void kiekPoru(int &n, int lytis[], int ranka[], int dydis[], int &vyrporu, int &motporu, int &vyriskos, int &moteriskos){
    //lyciu apskaiciavimas
    for(int i=0; i<n; i++){
        if(lytis[i]==3){vyriskos++;}else{moteriskos++;}
    }
    //poru apskaiciavimas
    for(int i=0; i<n; i++){
        for(int u=0; u<n; u++){
            if(lytis[i]==lytis[u] && dydis[i]==dydis[u] && ranka[i]!=ranka[u] && ne){
                if(lytis[i]==3){vyrporu++; }else{motporu++;}
                lytis[i]=0; dydis[i]=0; ranka[i]=0; lytis[u]=0; dydis[u]=0; ranka[i]=0;
            }
        }
    }
}

void koksLikutis(int &vyrlikutis, int &motlikutis, int vyrporu, int vyriskos, int motporu, int moteriskos){
    vyrlikutis=(vyrporu*2-vyriskos)*-1;
    motlikutis=(motporu*2-moteriskos)*-1;
}

void spausdinti(int motporu, int vyrporu, int vyrlikutis, int motlikutis){
    ofstream off("U1rez.txt");
    off<<motporu << endl << vyrporu << endl << motlikutis << endl << vyrlikutis;
    off.close();
}

//2011 metai, antra uzduotis

#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>

using namespace std;

struct pora{
    string vardas;
    int taskai, technika[10], artistiskumas[10];
};

//funkciju prototipai
void ivedimas(int &n, int &k, pora A[]);
void skaiciuotibalus(int n, int k, pora A[], char kuri);
void skaiciutiTaskus(int n, int k, pora A[]);
void rikiavimas(int n, pora A[]);
void isvedimas(pora A[], int n);

int main()
{
    pora A[99];
    int n, k;
    ivedimas(n, k, A);
    skaiciuotibalus(n, k, A, 't');
    skaiciuotibalus(n, k, A, 'x');
    skaiciutiTaskus(n, k, A);
    rikiavimas(n, A);
    isvedimas(A, n);
}

void ivedimas(int &n, int &k, pora A[]){
    string vard;
    ifstream in("U2.txt");
    in >> n >> k;
    for(int i=0; i<n; i++){
        in.ignore(1, '\n');
        getline(in, A[i].vardas);
        for(int u=0; u<k; u++){
            in >> A[i].technika[u];
        }
        for(int u=0; u<k; u++){
            in >> A[i].artistiskumas[u];
        }
    }
    in.close();
}

void skaiciuotibalus(int n, int k, pora A[], char kuri){
    if(kuri=='t'){
        //skaiciuoti balus uz technika
        int maziausias=0, didziausias=0;
        for(int i=0; i<n; i++){
            for(int u=0; u<k; u++){
                if(A[i].technika[u]>=A[i].technika[didziausias]){didziausias=u;}
                else if(A[i].technika[u]<=A[i].technika[maziausias]){maziausias=u;}
            }
            A[i].technika[didziausias]=0; A[i].technika[maziausias]=0;
            maziausias=0, didziausias=0;
        }
    }else{
        //skaiciutoi balus uz artistiskuma
        int maziausias=0, didziausias=0;
        for(int i=0; i<n; i++){
            for(int u=0; u<k; u++){
                if(A[i].artistiskumas[u]>=A[i].artistiskumas[didziausias]){didziausias=u;}
                else if(A[i].artistiskumas[u]<=A[i].artistiskumas[maziausias]){maziausias=u;}
            }
            A[i].artistiskumas[didziausias]=0; A[i].artistiskumas[maziausias]=0;
            maziausias=0, didziausias=0;
        }
    }
}

void skaiciutiTaskus(int n, int k, pora A[]){
    for(int i=0; i<n; i++){
        for(int u=0; u<k; u++){
            A[i].taskai+=A[i].technika[u];
            A[i].taskai+=A[i].artistiskumas[u];
        }
    }
}

void rikiavimas(int n, pora A[]){
    for(int i=0; i<n; i++){
        for(int u=0; u<n; u++){
            if(A[u].taskai<A[u+1].taskai){
                A[n+1].vardas=A[u].vardas;
                A[n+1].taskai=A[u].taskai;

                A[u].vardas=A[u+1].vardas;
                A[u].taskai=A[u+1].taskai;

                A[u+1].vardas=A[n+1].vardas;
                A[u+1].taskai=A[n+1].taskai;
            }
        }
    }
}

void isvedimas(pora A[], int n){
    ofstream isv("U2rez.txt");
    for(int i=0; i<n; i++){
        isv << left << setw(20);
        isv << A[i].vardas;
        isv << " " << A[i].taskai << endl;
    }
    isv.close();
}

//2012m. krepsinis

#include <iostream>
#include <fstream>

using namespace std;

void rikiuoti(int startp[]);
void skaityti(int &n, int numeriai[], int buvoaikstelej[], int buvosuolely[], int startinispenk[]);
void skmazdaug(int n, int numeriai[], int buvo[], int &index);
void isvesti(int startinispenk[], int numeriai[], int buvoaikstelej[], int buvosuolely[], int dzaideindex, int mzaideindex);


int main()
{
    int n;
    int numeriai[12]={0}, buvoaikstelej[12]={0}, buvosuolely[12]={0}, startinispenk[5]={0};
    int dzaideindex=0, mzaideindex=0;

    skaityti(n, numeriai, buvoaikstelej, buvosuolely, startinispenk);
    rikiuoti(startinispenk);
    skmazdaug(n, numeriai, buvosuolely, mzaideindex);
    skmazdaug(n, numeriai, buvoaikstelej, dzaideindex);
    isvesti(startinispenk, numeriai, buvoaikstelej, buvosuolely, dzaideindex, mzaideindex);
}

void skmazdaug(int n, int numeriai[], int buvo[], int &index){
    int zaide=0;
    for(int i=0; i<n; i++){
        if(buvo[i]>zaide){index=i; zaide=buvo[i];}
    }
}

void skaityti(int &n, int numeriai[], int buvoaikstelej[], int buvosuolely[], int startinispenk[]){
    int laikas, laiku, sp=0;
    ifstream a("U1.txt");
    a>>n;
    for(int i=0; i<n; i++){
        a>>numeriai[i];
        a>>laiku;

        a>>laikas;
        if(laikas>0){buvoaikstelej[i]+=laikas; startinispenk[sp]=numeriai[i]; sp++;}else{buvosuolely[i]-=laikas;}
        for(int x=1; x<laiku; x++){
            a>>laikas;
            if(laikas>0){buvoaikstelej[i]+=laikas;}else{buvosuolely[i]-=laikas;}
        }
    }
    a.close();
}

void rikiuoti(int startp[]){
    for(int a=0; a<5; a++){
    for(int i=0; i<4; i++){
        if(startp[i]>startp[i+1]){int temp=startp[i]; startp[i]=startp[i+1]; startp[i+1]=temp;}
    }}
}

void isvesti(int startinispenk[], int numeriai[], int buvoaikstelej[], int buvosuolely[], int dzaideindex, int mzaideindex){
    ofstream isvedimas("U1rez.txt");
    for(int i=0; i<5; i++){
        isvedimas << startinispenk[i]<< " ";
    }
    isvedimas << endl << numeriai[dzaideindex] << " " << buvoaikstelej[dzaideindex] << endl;
    isvedimas << numeriai[mzaideindex]<<" "<< buvosuolely[mzaideindex] << endl;
    isvedimas.close();
}

//2, kauliukai

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

struct dievas{ // dievu struktura
    string vardas;
    int ismete[10]={0}, lyginiai=0, tasku=0;
};

//funkciju prototipai
void ivedimas(dievas A[], int &n, int &k);
int rastiLaimetoja(int n, int k, dievas A[]);
void isvedimas(dievas A[], int valdovas);

int main(){
    dievas A[51];
    int n, k, valdovoindex;
    ivedimas(A, n, k);
    valdovoindex=rastiLaimetoja(n, k, A);
    isvedimas(A, valdovoindex);
}

void ivedimas(dievas A[], int &n, int &k){
    ifstream in("U2.txt");
    in >> n >> k;
    for(int i=0; i<n; i++){
        in >> A[i].vardas;
        for(int y=0; y<k; y++){
            in >> A[i].ismete[y];
        }
    }
    in.close();
}

int rastiLaimetoja(int n, int k, dievas A[]){
    int valdovas=0, valdovas2;
    //sudedame visus valdovu taskus
    for(int i=0; i<n; i++){
        for(int y=0; y<k; y++){
            if(A[i].ismete[y]%2==0){
                A[i].tasku+=A[i].ismete[y]; A[i].lyginiai++;
            }else{A[i].tasku-=A[i].ismete[y];}
        }
    }
    //ieskome valdovo
    for(int i=0; i<n; i++){
        if(A[i].tasku>A[valdovas].tasku){valdovas2=valdovas; valdovas=i;}
    }
    if(A[valdovas].tasku==A[valdovas2].tasku){
        if(A[valdovas].lyginiai<A[valdovas2].lyginiai){valdovas=valdovas2;} else if(A[valdovas].lyginiai==A[valdovas2].lyginiai){
            if(valdovas2>valdovas){valdovas=valdovas2;}
        }
    }
    return valdovas; // grazinam valdovo indeksa
}

void isvedimas(dievas A[], int valdovas){
    ofstream out("U2rez.txt");
    if(A[valdovas].vardas.length()<10){//     Va cia tai ziauriai prihackitna funkcija - nezinau, kaip kitaip galima spausdinti
        int reikia=10-A[valdovas].vardas.length(); // butent 10 simboliu, nes nuskaito tai tik info iki tarpo. Na, bet kokiu
        out << A[valdovas].vardas; // atveju - spausdina viska gerai, tad manau tiks
        for(int i=0; i<reikia; i++){out << " ";}
    }
    out <<" "<< A[valdovas].tasku;
    out.close();
}


//2013 metai. 1, apskritys

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

struct miestas{ // miestu struktura
    string pavadinimas;
    string apskritis;
    long unsigned int gyvsk; // gyventoju skaicius mieste
};

struct apskritys{ // apskriciu struktura
    string pavadinimas;
    unsigned int maziausiai_gyv=500000; // maziausiame mieste gyventoju
    unsigned int gyv_viso=0; // is viso apskrityje gyventoju
};

//funkciju prototipai
void ivedimas(int &miestu, miestas A[]);
void skaiciuok(int &apskriciu, int miestu, miestas A[], apskritys B[]);
void rikiuok(apskritys B[], int apskriciu);
void isvedimas(apskritys B[], int apskriciu);

int main()
{
    int apskriciu=0, miestu;
    miestas A[103];
    apskritys B[10];
    ivedimas(miestu, A);
    skaiciuok(apskriciu, miestu, A, B);
    rikiuok(B, apskriciu);
    isvedimas(B, apskriciu);
}

void ivedimas(int &miestu, miestas A[]){ // funkcija, skirta ivesti duomenims
    ifstream ivesk("U2.txt");
    ivesk >> miestu;
    for(int i=0; i<miestu; i++){
        ivesk >> A[i].pavadinimas >> A[i].apskritis >> A[i].gyvsk; // ivedame duomenis i miestu masyva
    }
    ivesk.close();
}

void skaiciuok(int &apskriciu, int miestu, miestas A[], apskritys B[]){ // pagrindine funkcija, kurioje yra visa programos logika
    bool yra=false; int kelintas;
    for(int i=0; i<miestu; i++){
        for(int x=0; x<=apskriciu; x++){
            if(A[i].apskritis == B[x].pavadinimas){yra=true; kelintas=x;} // tikriname ar tokia apskritis jau yra, kad zinotume ar kurti ar ne, bei pasizymime kelinta ji
        }
        if(yra==false){ // jei tokios apskrities nera..
            B[apskriciu].pavadinimas=A[i].apskritis; //kuriame nauja apskriti strukturoje
            B[apskriciu].maziausiai_gyv=A[i].gyvsk;
            B[apskriciu].gyv_viso+=A[i].gyvsk;
            apskriciu++; // bei pridedame prie apskriciu skaiciaus vieneta
        }else{ // jei tokia apskritis jau yra
            B[kelintas].gyv_viso+=A[i].gyvsk; // pridedame miesto gyventoju skaiciu prie tos apskrities bendro gyv. sk.
            if(B[kelintas].maziausiai_gyv>A[i].gyvsk){B[kelintas].maziausiai_gyv=A[i].gyvsk;} // bei patikriname ar tai nera maziausias miestas apskrity
        }
        yra=false;
    }
}

void rikiuok(apskritys B[], int apskriciu){ // rikiavimo funkcija.
    // pastaba : B[apskriciu+1] yra lyg laikinas elementas strukturos, i kuri galime padeti laikinai elementus kai norime juos apkeisti vietomis.
    // apskriciu+1, nes jis jau yra nenaudojamas, t.y. jis yra sekantis po visu apskriciu.
    for(int x=0; x<apskriciu; x++){
    for(int i=0; i<apskriciu; i++){
        if(B[i].maziausiai_gyv==B[i+1].maziausiai_gyv){ // jeigu apskriciu maziausiu miestu gyventoju skaiciai yra lygus
            for(int x=0; x<apskriciu; x++){ // tai rikiuojame pagal pavadinimo pirmaja raide.
                for(int i=0; i<apskriciu; i++){
                    if(B[i].pavadinimas[0]>B[i+1].pavadinimas[0]){
                        B[apskriciu+1].pavadinimas=B[i].pavadinimas;
                        B[i].pavadinimas=B[i+1].pavadinimas;
                        B[i+1].pavadinimas=B[apskriciu+1].pavadinimas;

                        B[apskriciu+1].maziausiai_gyv=B[i].maziausiai_gyv;
                        B[i].maziausiai_gyv=B[i+1].maziausiai_gyv;
                        B[i+1].maziausiai_gyv=B[apskriciu+1].maziausiai_gyv;

                        B[apskriciu+1].gyv_viso=B[i].gyv_viso;
                        B[i].gyv_viso=B[i+1].gyv_viso;
                        B[i+1].gyv_viso=B[apskriciu+1].gyv_viso;
                    }
                }
            }// o jeigu maziausiu miestu gyv. sk. yra nelygus, tada rikiuojame pagal juos.
        } else if(B[i].maziausiai_gyv>B[i+1].maziausiai_gyv){
            B[apskriciu+1].pavadinimas=B[i].pavadinimas;
            B[i].pavadinimas=B[i+1].pavadinimas;
            B[i+1].pavadinimas=B[apskriciu+1].pavadinimas;

            B[apskriciu+1].maziausiai_gyv=B[i].maziausiai_gyv;
            B[i].maziausiai_gyv=B[i+1].maziausiai_gyv;
            B[i+1].maziausiai_gyv=B[apskriciu+1].maziausiai_gyv;

            B[apskriciu+1].gyv_viso=B[i].gyv_viso;
            B[i].gyv_viso=B[i+1].gyv_viso;
            B[i+1].gyv_viso=B[apskriciu+1].gyv_viso;
        }
    }
    }
}

void isvedimas(apskritys B[], int apskriciu){ // isvedimo i faila funkcija
    ofstream isvest("U2rez.txt"); // atidarom faila
    isvest << apskriciu << endl; // isvedam apskriciu skaiciu
    for(int i=0; i<apskriciu; i++){
        isvest << B[i].pavadinimas << " " << B[i].maziausiai_gyv << " " << B[i].gyv_viso << endl; // vedam visu apskriciu duomenis kurie jau surikiuoti
    }
    isvest.close();
}

//2, siuntu tarnyba

#include <iostream>
#include <string>
#include <fstream>
#include <cmath>

using namespace std;

struct imones{ // imoniu struktura
    string vardas; // imones vardas
    int koordx; // imones koordinate x
    int koordy; // imones koordinate y
};


//funkciju prototipai
void skaityti(int &n, int &m, imones A[]);
void vazinet(int &n, int &m, imones A[], int &nuvazkm, int &aptarnim, int &index);
void isvesti(int aptarnim, int nuvazkm, int index, imones A[]);

int main()
{
    imones A[50]; // sukuriamas strukturu masyvas, is 50 nariu, nes max. imoniu riba - 50
    int n, m, nuvazkm=0, aptarnim=0,index; // nuvaziavo kilometru, ir kiek aptarnavo imoniu ^^
    skaityti(n, m, A);
    vazinet(n, m, A, nuvazkm, aptarnim, index);
    isvesti(aptarnim, nuvazkm, index, A);

}

void skaityti(int &n, int &m, imones A[]){ // duomenu skaitymo funkcija
    ifstream ivest("U1.txt");
    ivest >> n >> m;
    for(int i=0; i<n; i++){
        ivest >> A[i].vardas >> A[i].koordx >> A[i].koordy;
    }
    ivest.close();
}

void vazinet(int &n, int &m, imones A[], int &nuvazkm, int &aptarnim, int &index){ // pagrindine skaiciavimo f-ja
    for(int i=0; i<n; i++){
    int nuvDb=(fabs(A[i].koordx)+fabs(A[i].koordy))*2; // apskaiciuojama, kiek nuvaziuos dabartiniu vaziavimu
        if(nuvazkm+nuvDb<=m){ // jei prie jau nuvaziuotu kilometru pridejus 39 eil. kilometrus nebus perzengtas limitas
            nuvazkm+=nuvDb;//prie nuvaziuotu kilometru pridedami naujai nuvaziuoti kilometrai
            aptarnim++; // aptarnautos imones +1
            index=i; // pasizymimas paskutines imones indeksas, kad veliau galetu me isvesti jos varda
        }
    }
}


void isvesti(int aptarnim, int nuvazkm, int index, imones A[]){ // isvedimo funkcija
    ofstream isvest("U2.txt"); // atidaromas isvedimo failas
    isvest << aptarnim << " " << nuvazkm << " " << A[index].vardas; // i faila isvedami visi reikalingi duomenys
    isvest.close(); // uzdaromas isvedimo failas
}


//2014m, pirma, imones

#include <iostream>
#include <fstream>
using namespace std;

int main(){
    int k, balsai[4]={0}, taskai[4]={0}, direktoriaus[4], laimetojas, visobalsai[4]={0};
    ifstream in;
    in.open("U1.txt");
    in >> k;

    for(int i=1; i<=k; i++){
        in >> balsai[1] >> balsai[2] >> balsai[3];
        if(balsai[1]>balsai[2] && balsai[1]>balsai[3]){
            taskai[1]+=4;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];
            }
        else if(balsai[2]>balsai[1] && balsai[2]>balsai[3]){
            taskai[2]+=4;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];
            }
        else if(balsai[3]>balsai[1] && balsai[3]>balsai[2]){
            taskai[3]+=4;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];}
        else if(balsai[1]==balsai[2] && balsai[2]>balsai[3]){
            taskai[1]+=2;
            taskai[2]+=2;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];
        }
        else if(balsai[1]==balsai[3] && balsai[3]>balsai[2]){
            taskai[1]+=2;
            taskai[3]+=2;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];
        }
        else if(balsai[2]==balsai[3] && balsai[3]>balsai[1]){
            taskai[2]+=2;
            taskai[3]+=2;
            visobalsai[1]+=balsai[1];
            visobalsai[2]+=balsai[2];
            visobalsai[3]+=balsai[3];
        }
    }
    if(((taskai[1]==taskai[2])&&taskai[1]>taskai[3]) || ((taskai[1]==taskai[3])&&taskai[1]>taskai[2])||((taskai[2]==taskai[3])&&taskai[2]>taskai[3])){
        in>>direktoriaus[1]>>direktoriaus[2]>>direktoriaus[3];
        taskai[1]+=direktoriaus[1];
        taskai[2]+=direktoriaus[2];
        taskai[3]+=direktoriaus[3];
    }
    in.close();
    if(taskai[1]>taskai[2] && taskai[1]>taskai[3]){laimetojas=1;}
    else if(taskai[2]>taskai[1] && taskai[2]>taskai[3]){laimetojas=2;}
    else {laimetojas=3;};

    ofstream out;
    out.open("U1rex.txt");
    out << visobalsai[1] << " " << visobalsai[2] << " " << visobalsai[3] << endl;
    out << taskai[1] << " " << taskai[2] << " " << taskai[3] << endl;
    out << laimetojas;
    out.close();
}


// antra, marsaeigis 2014m
#include <iostream>
#include <vector>
#include <fstream>

using namespace std;

struct kelione{
    int seka[30];
    int sekosilgis;
};
ofstream isvedimas("U2rez.txt");
void ivedimas(int &x, int &y, int &xt, int &yt, int &sekusk, kelione A[]);
void keliauk(int &x, int &y, int xt, int yt, int sekusk, kelione A[]);
void spausdink(bool pasiektas, int komanduivykd, kelione A[], int pg);


int main()
{
    int x, y, xt, yt, sekusk; //dabartines koord. x ir y; xt - x tikslas, yt - y tikslas.
    kelione A[30];
    ivedimas(x, y, xt, yt, sekusk, A);
    keliauk(x,y,xt,yt,sekusk, A);
    isvedimas.close();
}

void ivedimas(int &x, int &y, int &xt, int &yt, int &sekusk, kelione A[]){
    ifstream ivesk("U2.txt");
    ivesk >> x >> y;
    ivesk >> xt >> yt;
    ivesk >> sekusk;
    for (int i=0; i<sekusk; i++){
        ivesk >> A[i].sekosilgis;
        for(int x=0; x<A[i].sekosilgis; x++){
            ivesk >> A[i].seka[x];
        }
    }
    ivesk.close();
}

void keliauk(int &x, int &y, int xt, int yt, int sekusk, kelione A[]){
    int sekosnr=0, komanduivykd=0;
    bool pasiektas=false;
    for(int pg=0; pg<sekusk; pg++){
    pasiektas=false, sekosnr=0, komanduivykd=0;
    int xdab=x, ydab=y;
    while((xdab!=xt || ydab!=yt) && sekosnr<A[pg].sekosilgis){
        switch(A[pg].seka[sekosnr]){
            case 1:ydab++; sekosnr++; komanduivykd++;
            break;
            case 2:xdab++; sekosnr++; komanduivykd++;
            break;
            case 3:ydab--; sekosnr++; komanduivykd++;
            break;
            case 4:xdab--; sekosnr++; komanduivykd++;
            break;
            default:
            break;
        }
    }
    if(xdab==xt && ydab==yt){pasiektas=true; spausdink(pasiektas, komanduivykd, A, pg);}
    else {pasiektas=false; spausdink(pasiektas, komanduivykd, A, pg);}
    }
}

void spausdink(bool pasiektas, int komanduivykd, kelione A[], int pg){
    if(pasiektas==true){isvedimas << "pasiektas tikslas   ";}else {isvedimas << "sekos pabaiga       ";}
    int x;
    for(x=0; x<komanduivykd; x++){
        isvedimas << A[pg].seka[x] << " ";
    }
    isvedimas<<x;
    isvedimas << endl;
}

//2015 antra, avys

#include <iostream>
#include <string>
#include <fstream>

using namespace std;

struct Avis{
        string Vardas;
        string DNR;
        int koef=0;
};

void Nuskaitymas(Avis A[], int & avys, int & frag, int & eil_nr);
void Veiksmas(Avis A[], int avys, int frag, int tiriama_avis);
void Rikiavimas(Avis A[], int tiriama_avis, int avys);
void Output(Avis A[], int tiriama_avis, int avys);

int main(){
        int aviu_skaicius;
        int DNR_ilgis;
        int tiriama_avis;
        Avis A[10];
        Nuskaitymas(A, aviu_skaicius, DNR_ilgis, tiriama_avis);
        Veiksmas(A, aviu_skaicius, DNR_ilgis, tiriama_avis);
        Rikiavimas(A, tiriama_avis, aviu_skaicius);
        Output(A, tiriama_avis, aviu_skaicius);
}

void Nuskaitymas(Avis A[], int & avys, int & frag, int & eil_nr){
        ifstream fd("U2.txt");
        fd >> avys >> frag;
        fd >> eil_nr;
        for (int i = 0; i < avys; i++)
        {
                fd >> A[i].Vardas >> A[i].DNR;
        }
        fd.close();
}
void Veiksmas(Avis A[],int avys, int frag, int tiriama_avis){
        for (int i = 0; i < avys; i++)
        {
                if(i!=tiriama_avis-1){
                for (int j = 0; j < frag; j++)
                {
                        if (A[i].DNR[j] == A[tiriama_avis-1].DNR[j])
                        {
                                A[i].koef++;
                        }
                }
                }
        }
}

void Rikiavimas(Avis A[], int tiriama_avis, int avys){
    //tiriama avi i pirma poz
    A[avys+1].Vardas = A[0].Vardas;
    A[0].Vardas = A[tiriama_avis-1].Vardas;
    A[tiriama_avis-1].Vardas = A[avys+1].Vardas;
    A[avys+1].koef = A[0].koef;
    A[0].koef = A[tiriama_avis-1].koef;
    A[tiriama_avis-1].koef = A[avys+1].koef;
    //rikiuojam
    for(int i=1; i<avys; i++){
        for(int j=i+1; j<avys; j++){
            if(A[i].koef!=A[j].koef){
                if(A[i].koef<A[j].koef){
                    A[avys+1].Vardas=A[i].Vardas;
                    A[avys+1].koef=A[i].koef;
                    A[i].Vardas=A[j].Vardas;
                    A[i].koef=A[j].koef;
                    A[j].Vardas=A[avys+1].Vardas;
                    A[j].koef=A[avys+1].koef;
                }
            }else{
                if(A[i].Vardas>A[j].Vardas){
                    A[avys+1].Vardas=A[i].Vardas;
                    A[avys+1].koef=A[i].koef;
                    A[i].Vardas=A[j].Vardas;
                    A[i].koef=A[j].koef;
                    A[j].Vardas=A[avys+1].Vardas;
                    A[j].koef=A[avys+1].koef;
                }
            }
        }
    }
}

void Output(Avis A[], int tiriama_avis, int avys){
    ofstream out("U2rez.txt");
    out << A[0].Vardas << endl;
    for(int i=1; i<avys; i++){
        out << A[i].Vardas << " " << A[i].koef << endl;
    }
    out.close();
}


//2015 pirmos turiu kazkiek pasirases, bet manrods bugas yra, tai nemesiu.