necasova

/*
                ***************************************

                    ZPRS-projekt: seznam hracu tymu
                    author: Michaela Necasova
                ***************************************
*/


#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX 20//max pocet hracu ktere se daji ulozit, lze menit
typedef struct
{
        char jmeno[MAX];
        char prijmeni[MAX];
        int fauly;
        int minuty;
        int goly;
        int asistence;
        int body;
        int strely;
        double uspesnost; // %
        double prinos;
}seznam;//vytvori novy datovy typ s nazvem seznam

//funkci prototypy
void tisk_tabulky();
void tisk_seznamu(int pocet, seznam *p);
void add(int *pocet, seznam *p);
void nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(int pocet, seznam *p, char a);



void tisk_tabulky()//funkce ktera popise sloupce tabulky
{
printf("----------------------seznam hracu----------------------------:\n");
printf("   |  Prijmeni |  Jmeno   | Goly   | Asistence |  Minuty  |  Fauly | Body \n"  );
//| strely | uspesnost (goly/strely) | prinos (uspesnost*minuty) tyto hodnoty se netisknou v seznamu, ale jsou ulozeny ve strukture, je to tu jen pomocne napsano
}

void tisk_seznamu(int pocet, seznam *p)//funkce ktera vytiskne udaje ve strukture
{

        int i = 0;
        for (i=0; i<pocet;i++)
        {
            printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",i+1,p[i].prijmeni,p[i].jmeno,p[i].goly, p[i].asistence,p[i].minuty,p[i].fauly, p[i].body);
        }
        printf("-----------------------------------------------------------------------------------------:\n");
}


void add(int *pocet, seznam *p)//funkce prida hrace do seznamu,
{
        if (*pocet == MAX)//v pripade, ze je uz dosazen max pocet lidi, ktery se do te struktury vleze(hodnota MAX)..
        {
                printf("seznam je jiz plny\n");//tak to vypise tohle a funkce skonci...
        }
        else//jinak se pokracuje tady
        {
        printf("zadejte prijmeni\n");
        fflush(stdin);//funkce ktera vyprazdni ze zasobniku "enter" ktery tam zustal z predchoziho vlozeni do promenne, u nekterych to byt nemusi, ja to dal vsudue, protoze i kdyz to tam byt nemusi tak to nic nezkazi, abys to pochopila tak si jich par smaz, at vidis jaky to udela bordel
        gets(p[*pocet].prijmeni);//nacte z klavesnice cely radek a ulozi ho do promenne, ktera je v zavorkach

        printf("zadejte jmeno\n");
        fflush(stdin);
        gets(p[*pocet].jmeno);

        printf("zadejte pocet golu\n");
        fflush(stdin);
        scanf("%d",&p[*pocet].goly);

        printf("zadejte pocet asistenci\n");
        fflush(stdin);
        scanf("%d",&p[*pocet].asistence);

        printf("zadejte pocet faulu\n");
        fflush(stdin);
        scanf("%d",&p[*pocet].fauly);

        printf("zadejte pocet odehranych minut\n");
        fflush(stdin);
        scanf("%d",&p[*pocet].minuty);

        printf("zadejte pocet strel na branku\n");
        fflush(stdin);
        scanf("%d",&p[*pocet].strely);

        p[*pocet].body= (p[*pocet].goly * 3)+ (p[*pocet].asistence); // do poctu bodu se uklada:3*pocet golu + 1*pocet asistenci(1gol=3body, 1 asistence = 1bod)

        if(p[*pocet].strely==0)//kdyz da nekdo 0 strel, automaticky ma uspesnost 0%, navic nulou nelze delit
        {
            p[*pocet].uspesnost=0;
        }
        else
        {
            double gol;
            gol=(double)p[*pocet].goly;//pretypovani na double, protoze o par radku nahore je nacitam jako int
            double str;
            str=(double)p[*pocet].strely;//pretypovani na double, protoze o par radku nahore je nacitam jako int
            p[*pocet].uspesnost= (gol)/(str)*100;//podelim goly/strely a vynasobim 100 abych ziskal hodnotu v procentech

        }

        p[*pocet].prinos= ((p[*pocet].uspesnost)*(p[*pocet].minuty))/100;//prinos = uspesnost * odehrane minuty, musi se vydelit nulou protoze predtim sem uspesnost vynasobil 100 abych ziskal procenta
        *pocet+=1;//a zvetsi pocet existujicich hracu o 1
        }
}

void nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(int pocet, seznam *p, char a)//jedna funkce na cele hledani, posilam tam char a, coz je promenna kterou pouzivam, kdyz se me to zepta jestli chci pridat hrace nebo najit takoveho a takoveho...a podle toho co tam je tak to vypisuje...
{
    int i;

    int pom1=0; //pomocna promenna kam se uklada pozice nejvytizenejsiho
    int pom2=0;//nejmene vytizeneho
    int pom3=0;//nejvic faulu
    int pom4 = 0;//nejuspesnejsiho
    int pom5=0;//nejuzitecnejsiho

    if (pocet==0)//kdyz neni nikdo v seznamu tak v nem nemuzes hledat...
    {
        printf("nelze hledat, seznam je prazdny");
    }
    else
    {
    int max= p[0].minuty; //tady se uklada prubezne hodnota poctu minut, ktera je nejvetsi...
    int min = p[0].minuty;//ktera je nejmensi...
    int faul=p[0].fauly;//nejvic faulu..
    double uspech=p[0].uspesnost;//nejvetsi uspesnost
    double prin=p[0].prinos;//.....
    for(i =0; i <pocet; i++)//cyklus na hledani vsech minim a maxim
    {
        if(p[i].minuty>max)
        {
            max=p[i].minuty;
            pom1=i;
        }
        if(p[i].minuty<min)
        {
            min=p[i].minuty;
            pom2=i;
        }
        if(p[i].fauly>faul)
        {
            faul=p[i].fauly;
            pom3=i;
        }
        if(p[i].uspesnost>uspech)
        {
            uspech=p[i].uspesnost;
            pom4=i;
        }
        if (p[i].prinos>prin)
        {
            prin=p[i].prinos;
            pom5=i;
        }
    }


    if(a=='n')//kdyz si zadala ze chces dat nejvytizenejsiho, tak se vykona tohle...
    {
        printf("nejvytizenejsi hrac je:\n");
        tisk_tabulky();
        printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",1,p[pom1].prijmeni,p[pom1].jmeno,p[pom1].goly, p[pom1].asistence,p[pom1].minuty,p[pom1].fauly, p[pom1].body);
    }
    else if(a=='m')//kdyz nejmene vytizeneho, tak tohle...
    {
    printf("nejmene vytizeny hrac je:\n");
    tisk_tabulky();
    printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",1,p[pom2].prijmeni,p[pom2].jmeno,p[pom2].goly, p[pom2].asistence,p[pom2].minuty,p[pom2].fauly, p[pom2].body);
    }
    else if (a=='f')//atd..
    {
    printf("nejvice faulujici hrac je:\n");
    tisk_tabulky();
    printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",1,p[pom3].prijmeni,p[pom3].jmeno,p[pom3].goly, p[pom3].asistence,p[pom3].minuty,p[pom3].fauly, p[pom3].body);
    }
    else if (a=='r')//atd...
    {
    printf("hrac s nejvetsim prinosem pro tym je:\n");
    tisk_tabulky();
    printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",1,p[pom4].prijmeni,p[pom4].jmeno,p[pom4].goly, p[pom4].asistence,p[pom4].minuty,p[pom4].fauly, p[pom4].body);
    printf ("s hodnotou  (uspesnost*minuty): %lf\n",p[pom4].prinos);
    }
    else if (a=='u')//atd..
    {
    printf("hrac s nejvetsi uspesnosti je:\n");
    tisk_tabulky();
    printf("%d.  %11s|%10s|%8d|%11d|%10d|%8d|%4d\n",1,p[pom5].prijmeni,p[pom5].jmeno,p[pom5].goly, p[pom5].asistence,p[pom5].minuty,p[pom5].fauly, p[pom5].body);
    printf ("s hodnotou (goly/strely): %lf (v procentech)\n",p[pom5].uspesnost);
    }
    }
}

int main()
{

   seznam p[MAX];//vytvori pole struktur datoveho typu seznam a pojmenuje je p
   int pocet = 0;//zde se uchovava aktuzalni pocet hracu v seznamu
        char x;//promenna kde ukladas 'y' 'Y' pro pokracovani
        char a;//promenna pouzivana pro rozhodovani, co chces udelat
        printf("vitejte v seznamu hracu\n");
        do
        {
        printf("stisknete 'p' pro pridani hrace, 'n' pro zobrazeni nejvytizenejsiho,'m' pro nejmene hrajiciho,\n 'u' pro nejuspesnejsiho hrace, 'f pro nejvice faulujiciho\n a 'r' pro hrace s nejvetsim prinosem pro tym'\n");
        scanf("%c",&a);
        switch (a)
        {
        case 'p':
                {
                        system("cls");//vymaze obrazovku
                        add(&pocet,p);//zavola funkci add
                        tisk_tabulky();//vytisne tabulku
                        tisk_seznamu(pocet,p);//avytiskne vsechny polozky struktury
                        break;
                }

        case 'n':
                {
                        system("cls");
                        nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(pocet, p, a);     //zavola tu funkci
                        break;
                }

        case 'm':
                {
                        system("cls");
                        nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(pocet, p, a);//zavola tu funkci
                        break;
                }

        case 'u':
                {
                        system("cls");
                        nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(pocet, p, a);//zavola tu funkci
                        break;
                }
        case 'f':
                {
                        system("cls");
                        nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(pocet, p, a); //zavola tu funkci
                        break;
                }

        case 'r':
                {
                        system("cls");
                        nejvice_nejmene_hrajici_maxFauly_prinos_uspesnost(pocet, p, a);//zavola tu funkci
                        break;
                }
        default:
            {
                printf("spatne zadani\n");//kdybys zadala neco jineho tak ti to rekne spatne zadani
            }
        }

        printf("chcete pokracovat? 'y'/ 'Y' pro ano\n");
        fflush(stdin);
        scanf("%c",&x);
        fflush(stdin);
        system("cls");
        }while (x == 'y' || x == 'Y');

        return 0;
}
/*
pozn:
void tisk_seznamu(int pocet, seznam *p)
void add(int *pocet, seznam *p)

v jedne je int pocet a v druhe int *pocet (s hvezdickou)

a ta kde neni hvezdicka tak se funkce vola:
tisk_seznamu(pocet,p);

a tam kde je se vola:
add(&pocet,p)

v tom je velky rozdil, verze s hvezdickou by fungovala vzdy, ale verze bez hvezdicky by tam, kde ji mam nefungovala
protoze kdyz se funkce napise bez hvezdicky, tak se ta promenna pocet nakopiruje do te funkce, kde ji muzes jakkoli zvetsovat, zmensovat atd
ale jak funkce skonci, tak se ta nakopirovana hodnota smaze a v programu by byla zase ta puvodni hodnota, takze kdybys
tu funkci na pridani noveho hrace napsala bez te hvezdicky, tak bys mela treba pocet = 0 (zatim bys nemela zadneho hrace), ve funkci by
se hodnota pocet zvetsila o +1, takze bys mela pocet hracu 1, ale jakmile by program skoncil, tak v te hlavni promenne, ktera plati
pro cely program a ktera se bude dal posilat do dalsich funkci, tak by tam bylo porad 0

&pocet=ziskani adresy, kde je ulozena promenna pocet
*pocet=ziskani hodnoty, ktera je ulozene na adrese

add(&pocet,p): tady posilam do funkce adresu, kde je ulozena ta hlavni promenna pocet,  a pak pomoci *pocet tu hodnotu na adrese zvetsim o jedno nebo k ni pristupuju

asi to neni moc pochopitelne bo to je docela slozite, ale jinak to napsat nejde no.....


*/