ZPrPr projekt

/*Vytvoril KOVatOr
*sluzi to ako pomocka pri tvorbe projektu
*ak to niekto copypastne a odovzda nikdy viac to uz nepostnem
*vyhradne pre nasu studijnu skupinu - toto paste sa nesmie nikam postnut bez mojho vedomia
*mozete si to skopirovat tak akurat sebe na komp a nikomu dalsiemu o tom nehovorit
*ak sa o tom dozvedia na STU budem mat pruser a uz nikdy nic nepostnem
*s pozdravom
*kovo*/

/* Definicia kniznic a makier ktore budem pouzivat*/

#include <stdio.h>
#include <stdlib.h>
#define MAX 1000 //maximalna dlzka retazca
#define SUBOR "DNAsekvencia.dat" //nazov citaneho suboru

/*V tejto casti su hlavicky vsetkych
*funkcii ktore pri praci pouzijeme*/

int vypis();
int retazec(char pole[]);
int histogram(char *p_pole);
int podsekvencie (char *p_pole);
int komplementarne(char pole[]);
int vynuluj(char *p_pole);
int velke(char *p_pole, int j);

/*Hlavna funkcia ktora sa spusti ako prva
*mame v zadefinovane pole do ktoreho nacitame
*zo suboru retazec a switch ktorym
*budeme volat funkcie*/

int main()
{
    char volba, pole[MAX]; //pole o velkosti MAX
    vynuluj(&pole[0]); //zavolame funkciu ktora nam pole vynuluje
    do { //cyklus ktory nacitava znaky, az kym nie je stlacena validna klavesa ktora vyvola funkciu
    while((volba=getchar())!='v' && volba!='n' && volba!='h' && volba!='p' && volba!='c' && volba!='k')
        ;
    switch (volba) { //stlacenim prislusneho tlacitka zavolame prislusnu funkciu
    case 'v': vypis(); break;
    case 'n': retazec(pole); break;
    case 'h': histogram(&pole[0]); break;
    case 'p': podsekvencie(&pole[0]); break;
    case 'c': komplementarne(pole); break;
    case 'k': printf("koniec\n"); break;
    }
    } while(volba!='k'); //do-while cyklus skonci ked stlacime k
    return 0;
}

/*Funkcia vlozi do celeho pola na kazdu adresu 0
*a prepise vsetko sa tam vyskytovalo doteraz
*funkcia nie je nutnou sucastou programu*/

int vynuluj(char *p_pole)
{
    int i;
    for(i=0; i<MAX; i++)
        *(p_pole+i)=0;
    return 0;
}

/*funkcia otvori subor a vypise jeho obsah
*na obrazovku, pricom v riadku bude
*zvoleny pocet znakov z intervalu*/

int vypis() //vypis retazca na obrazovku
{
    FILE *fr;
    int p, n, c;
    scanf("%d", &p);
    if (p<0 || p>20)    //nacitanie znakov na riadok
    {
        printf("Nespravny pocet nukleotidov na riadok\n");
        return 1;
    }
    if ((fr=fopen(SUBOR, "r"))==NULL)
    {
        printf("Neotvoreny subor\n"); //otvorenie suboru
        return 1;
    }
    do      //vypisanie znakov na obrazovku
    {
        n=p;
        while (n>0 && (c=getc(fr))!=EOF) //keby nebolo n prve, vypadavali by nam znaky
        {
            putchar(c);
            n--;
        }
        putchar('\n');
    } while(c!=EOF);
    if (fclose(fr)==EOF)
        printf("Subor sa nepodarilo zatvorit");
    return 0;
}

/*funkcia otvori subor a nacita z neho
*znaky do pola. ak je v subore znak,
*ktory nepatri do abecedy X tak vyhodi
*chybovu hlasku a pole vynuluje*/

int retazec(char pole[]) //funkcii posielame pole do ktoreho chceme zapisovat
{
    FILE *fr;
    int i=0;
    char c;
    if((fr=fopen(SUBOR, "r"))==NULL)
    {
       printf("Neotvoreny subor\n");
       return 1;
    }
    while(i++<MAX && ((c=toupper(getc(fr)))!=EOF))  //overenie ci su znaky v subore z abecedy X
        if(c!='A' && c!='G' && c!='C' && c!='T')
        {
            printf("Sekvencia nesplna podmienky\n");  //ak niesu tak return
            return 0;
        }
    rewind(fr);
    vynuluj(&pole[0]);
    fscanf(fr, "%s", pole); //nacitanie sekvencie
    velke(&pole[0], MAX); //konverzia znakov na velke
    #ifdef LADENIE //vypis nacitaneho pola pri ladeni //definovanim modu LADENIE si mozeme nacitane znaky vypisat
    for(i=0; i<MAX; i++)
    {
        if (pole[i]=='\0')
            break;
        else
            putchar(pole[i]);
    }
    putchar('\n');
    #endif // Ladenie
    printf("Sekvenciu sa podarilo nacitat\n");
    if (fclose(fr)==EOF)
        printf("Subor sa nepodarilo zatvorit");
    return 0;
}

/*Histogram vypise pocetnost pismen ACGT v retazci*/

int histogram(char *p_pole) //funkcii posielame pole
{
    int histo[4], n;
    if (*p_pole!='A' && *p_pole!='G' && *p_pole!='C' && *p_pole!='T') //overenie ci je retazec nacitany
    {
        printf("Sekvencia nie je nacitana\n");
        return 1;
    }
    for(n=4; n>0; n--)
        histo[n-1]=0;
    while (n<MAX && *(p_pole+n)!='\0') //v tom pripade sa oplati switch, lebo mame iba 4 znakovu abecedu
    {
        switch (*(p_pole+n)) {
        case 'A': histo[0]++; break;
        case 'C': histo[1]++; break;
        case 'G': histo[2]++; break;
        case 'T': histo[3]++; break;
        default: ; break;
        }
        n++;
    }
    printf("A: %d\nC: %d\nG: %d\nT: %d\n", histo[0], histo[1], histo[2], histo[3]);
    return 0;
}

/*Funkcia vypise na obrazovku vsetky
*vyskyty zadanej podsekvencie najvasej
*dlzky 5 znakov*/

int podsekvencie (char *p_pole) //funkcii posielame pole
{
    char sekvencia[5];
    int i=0, n, j=0, k;
    if (*p_pole!='A' && *p_pole!='G' && *p_pole!='C' && *p_pole!='T')
    {
        printf("Sekvencia nie je nacitana\n");
        return 1;
    }
    for(n=0; n<5; n++)
        sekvencia[n]=0; //vynulovanie sekvencie
    scanf("%s", sekvencia);
    while(sekvencia[j]!='\0' && j<5)
        j++;    //zistenie dlzky retazca
    velke(&sekvencia[0], j);
    while(i<MAX-j && (*(p_pole+i)=='A' || *(p_pole+i)=='G' || *(p_pole+i)=='C' || *(p_pole+i)=='T'))
    {
        for(n=0; n<j; n++)   //zistujeme ci su v retazci podsekvencie
            if(sekvencia[n]!=*(p_pole+i+n))
                break;
        if (n==j)   //ak su, tak ich vypiseme
        {
            printf("\n%d ", i+1);
            for(k=i-3; k<i+n+3; k++)
                if(k<MAX && (*(p_pole+k)=='A' || *(p_pole+k)=='G' || *(p_pole+k)=='C' || *(p_pole+k)=='T'))
                    putchar(*(p_pole+k));
                else
                    putchar('-');
        }
        i++;
    }
    putchar('\n');
    return 0;
}

/*Funkcia vypise retazec komplementarny
*k povodnemu retazcu podla zadania*/

int komplementarne(char pole[])
{
    int i=0, n, j=0;
    char komp[MAX];
    if (pole[0]!='A' && pole[0]!='G' && pole[0]!='C' && pole[0]!='T')
    {
        printf("Sekvencia nie je nacitana\n");
        return 1;
    }
    while(i<MAX && pole[i]!=0)
        i++; //zistenie dlzky retazca
    for(n=--i;n>=0; n--)
        komp[n]=pole[j++];
    #ifdef LADENIE //zapnutim modu LADENIE mozno vypisat co sme zatial urobili, sluzi na lahsiu kontrolu
    for(n=0;n<=i; n++)
        putchar(komp[n]);
        putchar('\n');
    #endif // LADENIE
    for(n=0; n<=i; n++)
    {
        switch (komp[n]) {
        case 'A': printf("T"); break;
        case 'G': printf("C"); break;
        case 'C': printf("G"); break;
        case 'T': printf("A"); break;
        }
    }
    putchar('\n');
    return 0;
}

/*Funkcia zmeni znaky v poli na velke
*funkcia nie je nutnou sucastou programu*/

int velke(char *p_pole, int j)
{
    int i=0;
    while(i<j && *(p_pole+i)!='\0')
    *(p_pole+i++)=toupper(*(p_pole+i));
    return 0;
}