xbeke.c

#define _CRT_SECURE_NO_WARNINGS

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

void premenNaMalePismena(char *retazec);
char *charVStringu(const char *s, int c);
char *nacitajSekvenciuZoSuboru();
void vypisSekvencieOdPozicie(char *sekvencia, unsigned int od, unsigned int potial);
signed int hladaj(char *prvyRetazec, char *druhyRetazec, int pozicia);
int zratajPismena(char * sekvencia, char pismeno);
void histogramSekvencie(char *sekvencia);
void najdlhsiPodretazecVSekvencii(char *retazec);
char *vlozSekvenciuOdPozicie(unsigned int pozicia, unsigned int dlzka, char *novaSekvencia, char *sekvencia);
void najdiPodretazecVSekvencii(unsigned int len, char *sekvencia, char *pattern);
char *podretazec(char *vstup, int start, int len);
void najdiPozicie(char *sekvencia, char pismeno, int velkost);

int main()
{
    char *dnaSekvencia = NULL;
    char novaSekvencia[1000];
    char vyber = '\0';
    unsigned int od = 0, potial = 0;

    while (vyber != 'k')
    {
        scanf(" %c", &vyber);
        if (vyber == 'n')
        {
            if (dnaSekvencia != NULL)
            {
                free(dnaSekvencia);
                dnaSekvencia = NULL;
            }
            dnaSekvencia = nacitajSekvenciuZoSuboru();
        }
        else if (vyber == 'p')
        {
            scanf("%d %s", &potial, novaSekvencia);
            najdiPodretazecVSekvencii(potial, dnaSekvencia, novaSekvencia);
        }
        else if (vyber == 'h')
        {
            histogramSekvencie(dnaSekvencia);
        }
        else if (vyber == 'o')
        {
            najdlhsiPodretazecVSekvencii(dnaSekvencia);
        }
        else if (vyber == 'v')
        {
            scanf("%d %d", &od, &potial);
            vypisSekvencieOdPozicie(dnaSekvencia, od, potial);
        }

        else if (vyber == 'l')
        {
            scanf("%d %d %s", &od, &potial, novaSekvencia);
            dnaSekvencia = vlozSekvenciuOdPozicie(od, potial, novaSekvencia, dnaSekvencia);
        }
    }

    return 0;
}

//funkcia na orezanie retazca
char *podretazec(char *vstup, int start, int len)
{
    char *ret = (char *)malloc((len + 1) * sizeof (char));
    memcpy(ret, vstup + start, len);
    ret[len] = '\0';
    return ret;
}

//funkcia na premenu retazca na male pismena,
void premenNaMalePismena(char *string)
{
    char* sekvencia = string;
    for (; *sekvencia; ++sekvencia) *sekvencia = tolower(*sekvencia);
}

//funkcia na hladanie podretazca v retazci od pozicie
signed int hladaj(char *prvyRetazec, char *druhyRetazec, int pozicia)
{
    int i = pozicia, j = 0, vyskyt;
    char act = prvyRetazec[i];
    premenNaMalePismena(druhyRetazec);
    premenNaMalePismena(prvyRetazec);

    for (;;)
    {
        act = prvyRetazec[i];
        if ('\0' == act)
        {
            break;
        }
        while (prvyRetazec[i] != druhyRetazec[0] && prvyRetazec[i] != '\0')
        {
            i++;
        }
        if (prvyRetazec[i] == '\0')
        {
            return(-1);
        }

        vyskyt = i;

        while (prvyRetazec[i] == druhyRetazec[j] && prvyRetazec[i] != '\0' && druhyRetazec[j] != '\0')
        {
            i++;
            j++;
        }

        if (druhyRetazec[j] == '\0')
        {
            return vyskyt;
        }
        if (prvyRetazec[i] == '\0')
        {
            return -1;
        }

        i = vyskyt + 1;
        j = 0;
    }
    return -1;
}

//funkcia na zistenie ci je v stringu dane pismeno
char *charVStringu(const char *s, int c)
{
    const char ch = c;

    for (; *s != ch; s++)
    if (*s == '\0')
        return 0;
    return (char *)s;
}

//funkcia na nacitanie sekvencie zo suboru
char *nacitajSekvenciuZoSuboru()
{

    int ukazovatel = 0;
    int velkost = 0;
    char *sekvencia = NULL;
    //otvorime subor
    FILE *file = fopen("DNAsekvencia.txt", "r");

    //skontrolujeme, ci je subor otvoreny
    if (file == NULL)
    {
        printf("Subor sa nepodarilo otvorit\n");
        return NULL;
    }

    //spocitame pocet pismen v subore
    while (fgetc(file) != EOF) velkost++;

    //pretoze je ukazovatel na konci suboru, vratime ho na zaciatku
    rewind(file);

    //alokujeme string velkosti suboru + 1 na terminator znak
    sekvencia = (char *)malloc((velkost + 1) * sizeof(char));
    fgets(sekvencia, velkost + 1, file);

    //skontrolujeme, ci sa subor uzavrel
    if (fclose(file) == EOF)
    {
        printf("Subor sa nepodaril zavriet\n");
    }

    //skontrolujeme, ci je sekvencia platna
    for (ukazovatel; ukazovatel < velkost; ukazovatel++)
    {
        if (charVStringu("ACGTacgt", (int)sekvencia[ukazovatel]) != NULL)
        {
            continue;
        }
        else
        {
            printf("Sekvencia nesplna podmienky\n");
            return NULL;
        }
    }

    printf("Sekvenciu sa podarilo nacitat\n");
    return sekvencia;

}

//funkcia na vypis sekvencie
void vypisSekvencieOdPozicie(char *sekvencia, unsigned int od, unsigned int potial)
{
    if (sekvencia == NULL)
    {
        printf("Sekvencia nie je nacitana\n");
        return;
    }

    //osetrime nerealne scenare
    if (od < 1 || potial < 1 || od > potial || ((od + potial + -1) > strlen(sekvencia)))
    {
        printf("Zadanu podsekvenciu nie je mozne vypisat\n");
        return;
    }
    for (od; od <= potial; od++)
    {
        printf("%c", sekvencia[od - 1]);
    }
    printf("\n");

}

//funkcia ktora nam vrati pocet pismen v sekvencii
int zratajPismena(char * sekvencia, char pismeno)
{
    int var = 0;
    int i = 0;
    for (i; i < strlen(sekvencia); i++)
    {
        if (sekvencia[i] == toupper(pismeno) || sekvencia[i] == pismeno)
        {
            var++;
        }
    }
    return var;
}

//funkcia na vypis histogramu
void histogramSekvencie(char *sekvencia)
{
    unsigned int t = 0, a = 0, g = 0, c = 0, i = 0;

    if (sekvencia == NULL)
    {
        printf("Sekvencia nie je nacitana\n");
        return;
    }

    printf("A: %d\nC: %d\nG: %d\nT: %d\n",
        zratajPismena(sekvencia, 'a'),
        zratajPismena(sekvencia, 'c'),
        zratajPismena(sekvencia, 'g'),
        zratajPismena(sekvencia, 't'));
}

//funkcia na najdenie podretazcov v sekvencii
void najdiPodretazecVSekvencii(unsigned int dlzka, char *sekvencia, char *pattern)
{
    char *skopirovanyPattern;
    char *skopirovanaSekvencia;

    if (sekvencia == NULL)
    {
        printf("Sekvencia nie je nacitana\n");
        return;
    }
    skopirovanaSekvencia = (char *)malloc((strlen(sekvencia) + 1)* sizeof(char));

    strcpy(skopirovanaSekvencia, sekvencia);
    premenNaMalePismena(pattern);
    premenNaMalePismena(skopirovanaSekvencia);


    unsigned int i = 0, j, count = 0;

    //osetrime ze ak sme zadali dlhsi string, nez sme si zadali, tak nech oreze
    if (strlen(pattern) >= dlzka)
    {
        skopirovanyPattern = (char *)malloc(strlen(pattern) * sizeof(char));
        skopirovanyPattern = podretazec(pattern, 0, dlzka);
    }
    else
    {
        skopirovanyPattern = (char *)malloc(strlen(pattern) * sizeof(char));
        strcpy(skopirovanyPattern, pattern);
    }

    //najdeme prvy vyskyt podretazca
    i = hladaj(skopirovanaSekvencia, skopirovanyPattern, 0);

    for (i; i < strlen(skopirovanaSekvencia);)
    {
        count = 0;
        printf("%d ", i + 1);
        if (i == -1)
        {
            break;
        }
        //ak je to nahodou na zaciatku, tak nech nam to vyplni ciarkami
        if (i + 1 == 1)
        {
            //vypln ciarkami
            for (j = 0; j < 3; j++)
            {
                printf("-");
            }
            //povodny podretazec
            for (j = i; j < i + strlen(skopirovanyPattern); j++)
            {
                printf("%c", toupper(skopirovanaSekvencia[j]));
            }
            //ak je dalsi retazec za povodnym podretazcom v retazci, tak nam to vypise
            if ((i + strlen(skopirovanyPattern) + 3) < strlen(skopirovanaSekvencia))
            {
                for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
                {
                    printf("%c", toupper(skopirovanaSekvencia[j]));
                }
            }
            else
            {
                for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
                {
                    printf("-");
                }
            }
            printf("\n");
            //najdeme miesto dalsej sekvencie a nastavi index na miesto, kde sa to zacina
            i = hladaj(skopirovanaSekvencia, skopirovanyPattern, i + 1);
            continue;
        }
        //ak sa blizime ku koncu, tak dokym mame chary, dovtedy vypisujeme
        else
        {
            for (j = i; j < i + strlen(skopirovanyPattern); j++)
            {
                printf("%c", toupper(skopirovanaSekvencia[j]));
                count++;
            }
            for (j = i - 3; j < i; j++)
            {
                printf("%c", toupper(skopirovanaSekvencia[j]));
                count++;
            }
            if ((i + strlen(skopirovanyPattern) + 3) < strlen(skopirovanaSekvencia))
            {
                for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
                {
                    printf("%c", toupper(skopirovanaSekvencia[j]));
                    count++;
                }
            }
            else
            {
                //kym su chary
                while (*(skopirovanaSekvencia + j) != '\0')
                {
                    count++;
                    printf("%c", toupper(*(skopirovanaSekvencia + j)));
                    j++;
                }
                 //ak uz chary nie su, doplnime ciarkami na plnu dlzku, podla toho, ze count je jak velke
                for (j = count; j < 8; j++)
                {
                    printf("-");
                }
            }

            printf("\n");
            i = hladaj(skopirovanaSekvencia, skopirovanyPattern, i + 1);
            continue;
        }
    }
}

char *vlozSekvenciuOdPozicie(unsigned int pozicia, unsigned int dlzka, char *novaSekvencia, char *sekvencia)
{
    char *novaDNASekvencia = NULL;
    char *skopirovanyPattern = NULL;
    int velkost = 0;

    if (sekvencia == NULL)
    {
        printf("Sekvencia nie je nacitana\n");
        return sekvencia;
    }
    //osetrime scenare
    if (pozicia < 1 || pozicia > strlen(sekvencia) + 1)
    {
        printf("Do sekvencie nie je mozne podsekvenciu vlozit\n");
        return sekvencia;
    }
    velkost = (dlzka + strlen(sekvencia) + 2);

    //naalokujeme novy retazec
    novaDNASekvencia = (char *)malloc(velkost * sizeof(char));
    memset(novaDNASekvencia, '\0', velkost);
    skopirovanyPattern = podretazec(novaSekvencia, 0, dlzka);
    //prekopirujeme zaciatok
    strncpy(novaDNASekvencia, sekvencia, pozicia - 1);
    //sekvenciu na vlozenie
    strcpy(novaDNASekvencia + strlen(novaDNASekvencia), skopirovanyPattern);
    //ostatok sekvencie
    strcpy(novaDNASekvencia + strlen(novaDNASekvencia), sekvencia + pozicia - 1);
    printf("Podsekvencia vlozena\n");
    return novaDNASekvencia;

}

//pomocna funkcia na najdenie pozicii kde sa podretazec v retazci nachadza
void najdiPozicie(char *sekvencia, char pismeno, int velkost)
{
    int i = 0;
    char *kontrolnyRetazec = (char *)malloc((velkost + 1) * sizeof(char));
    memset(kontrolnyRetazec, pismeno, (velkost)+1 * sizeof(char));
    kontrolnyRetazec[velkost] = '\0';
    i = hladaj(sekvencia, kontrolnyRetazec, 0);

    for (i; i < strlen(sekvencia);)
    {
        printf("%c %d\n", toupper(pismeno), i + 1);
        i = hladaj(sekvencia, kontrolnyRetazec, i + 1);
        if (i == -1)
        {
            break;
        }
    }
}

//pomocna funkcia na zistenie, ci sa sekvencia z pismen nachadza v retazci
int skontrolujStringy(char *str1, char pismeno, int inkrement)
{
    char *kontrolnyRetazec = (char *)malloc((strlen(str1) - inkrement + 1) * sizeof(char));
    memset(kontrolnyRetazec, pismeno, (strlen(str1) - inkrement + 1) * sizeof(char));
    kontrolnyRetazec[strlen(str1) - inkrement + 1] = '\0';
    if (strstr(str1, kontrolnyRetazec) != NULL)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

//funkcia na najdlhsi podretazec v sekvencii
void najdlhsiPodretazecVSekvencii(char *retazec)
{
    unsigned int i = 0;
    char *kontrolnyRetazec = NULL;
    char *skopirovanyRetazec = NULL;
    unsigned int velkost, c = 0, g = 0, a = 0, t = 0;

    if (retazec == NULL)
    {
        printf("Sekvencia nie je nacitana\n");
        return;
    }

    kontrolnyRetazec = (char *)malloc((strlen(retazec) + 1) * (sizeof(char)));
    skopirovanyRetazec = (char *)malloc((strlen(retazec) + 1) * (sizeof(char)));
    strcpy(skopirovanyRetazec, retazec);

    premenNaMalePismena(skopirovanyRetazec);

    for (i; i < strlen(retazec); i++)
    {
        //nastavi nam vsetky hodnoty na dane pismo v sekvencii na N - i rozmedzi, cize ak je N 20 tak  20,19,18,17...
        //tym zistime, ze ake je najdlhsi retazec
        g = skontrolujStringy(skopirovanyRetazec, 'g', i);
        c = skontrolujStringy(skopirovanyRetazec, 'c', i);
        a = skontrolujStringy(skopirovanyRetazec, 'a', i);
        t = skontrolujStringy(skopirovanyRetazec, 't', i);


        if (a == 1 || c == 1 || g == 1 || t == 1)
        {
            break;
        }

        kontrolnyRetazec = (char *)malloc((strlen(retazec) - i + 1) * (sizeof(char)));
    }

    velkost = (strlen(retazec) - i + 1);

    free(kontrolnyRetazec);
    kontrolnyRetazec = NULL;
    kontrolnyRetazec = (char *)malloc((velkost + 1)* (sizeof(char)));
    printf("Najdlhsie useky opakujucich sa nukleotidov: %d\n", velkost);
    //najde vsetky pozicie, kde sa tie opakujuce sa veci nachadzaju
    if (c == 1)
    {
        najdiPozicie(skopirovanyRetazec, 'c', velkost);
    }
    if (a == 1)
    {
        najdiPozicie(skopirovanyRetazec, 'a', velkost);
    }
    if (t == 1)
    {
        najdiPozicie(skopirovanyRetazec, 't', velkost);
    }
    if (g == 1)
    {
        najdiPozicie(skopirovanyRetazec, 'g', velkost);
    }
}