Škôlka jazyka C

/***********************************************
 *
 * 1.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // funkcia malloc()
#include <string.h> // funkcia strlen()

/*********************************************
 * funkcia vykresli potrebny pocet hviezdiciek
 * podla poctu zadaneho pri jej volani
 *********************************************/
void hviezdy(int pocet) // nema navratovu hodnotu
{
    int i; // deklaracia premennej typu int

    for (i = 0; i < pocet; i++) // cyklus 0 - pocet, po jednom vzostupne
        putchar('*'); // tlaci '*'
    putchar('\n'); // ENTER
}

int main(void) {
    char *veta; // deklaracia pointera na retazec

    if ((veta = (char *) malloc(100)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Napis nejaku vetu a vytlacim ju v ramceku.\n\n");
    gets(veta); // zadanie retazca z klavesnice
    hviezdy(strlen(veta) + 4); // vytlaci stanoveny pocet hviezdiciek => dlzka retazca + 4
    printf("* %s *\n", veta);  // vytlaci * veta * ENTER
    hviezdy(strlen(veta) + 4); // vytlaci stanoveny pocet hviezdiciek => dlzka retazca + 4

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 2.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // funkcia malloc()
#include <string.h> // funkcia strcpy()

int main(void) {
    char s[20]; // definuje retazec o dlzke 20

    strcpy(s, "Toto je priklad."); // priradi stanoveny obsah do retazca s

    char *pointer; // definuje pointer na retazec pointer

    if ((pointer = (char *) malloc(20)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    strncpy(pointer, s, (strlen(s) + 1)); // skopiruje obsah z retazca s do retazca pointer
    printf("%s\n", pointer);  // vytlaci retazec pointer ENTER

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 3.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // funkcia malloc()
#include <string.h> // funkcia strlen()

int main(void) {
    int i, j; // deklaracia premenných typu int
    char *s, pomoc; // deklaracia pointeru na retazec a premennej typu char

    if ((s = (char *) malloc(22)) == NULL) { // dynamicka alokacia s kontrolou (pocitam so
        printf("Malo pamati!");              // znakom '\n' a '\0', teda dva pridavam
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Napis maximalne 20 roznych znakov, zoradim ich podla abecedy.\n\n");
    printf("12345678901234567890\n"); // vypise stanovany pocet prvkov ENTER, pod ne sa zadaju znaky
    fgets(s, 21, stdin); // nacitanie stanoveneho poctu znakov z klavesnice (vratane Enter)
    for (i = 0; i < strlen(s); i++) { // cyklus 0 - dlzka retazce po jednej vzostupne
        for (j = 0; j < strlen(s); j++) { // vnoreny cyklus 0 - dlzka retazce po jednej vzostupne

            /* ak je [0] prvok mensi ako [1], vymenia sa navzajom,
             * ak je [0] prvok mensi ako [2], vymenia sa navzajom,
             * tak az do konca pola, potom ak je [1] mensi ako [2],
             * vymenia sa navzajom, atd. az do konca pola */
            if (s[i] < s[j]) { // ak je prvok s[i] (napr. 0) menši ako prvok s[o], s[2] ... s[dlzka retazca]
                pomoc = s[i];  // premenna pomoc sa naplni obsahom prvku s[i]
                s[i] = s[j];   // prvok s[i] sa naplni obsahom prvku s[j]
                s[j] = pomoc;  // prvok s[j] sa naplni obsahom premennej pomoc
            }
        }
    }
    printf("\n12345678901234567890\n"); // vypise stanovany pocet prvkov ENTER
    printf("%s\n", s);  // vytlaci retazec podla abecedy vzostupne ENTER

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 4.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcia
#include <stdlib.h> // funkcia malloc()
#include <string.h> // funkcia strcpy()

int main(void) {
    int i; // deklaracia premennej
    char *s; // deklaracia pointera na retazec

    if ((s = (char *) malloc(50)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj jedno slovo, vygenerujem z neho nieco zaujimave.\n\n");
    scanf("%s", s); // zadanie retazca z klavesnice
    for (i = 0; i < strlen(s); i++) { // cyklus 0 - dlzka slova po jednom vzostupne
        if (i < (strlen(s) / 2)) // ak je dlzka polovica
            s[(strlen(s) - i - 1)] = s[i]; // zmeni znaky od konca na tie od zaciatku
    }
    printf("\n%s\n", s);  // vypise vygenerovany retazec

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 5.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // funkcia malloc()
#include <string.h> // funkcia strlen()
#include <ctype.h>  // funkcie isupper(), islower(), toupper(), tolower()

int main(void) {
    int i; // deklaracia premennej
    char c, *s; // deklaracia premennej typu char a pointeru na retazec

    if ((s = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Napis retazec, upravim ho podla zadania.\n\n");
    gets(s); // zadanie retazca z klavesnice
    c = s[strlen(s) - 1]; // premennu c naplni poslednym znakom retazca, ENTER sa nepocita
    switch (c) { // prepinac => ak je c:
        case 'l': // l
        case 'L': // alebo L,
            for (i = 0; i < strlen(s); i++) { // cyklus 0 - dlzka retazca po jednom vzostupne
                if (isupper(s[i])) // ak je znak velke pismeno
                    s[i] = tolower(s[i]); // zmeni ho na male pismeno
            }
            break; // nutný prikaz

        case 'u': // u
        case 'U': // alebo U,
            for (i = 0; i < strlen(s); i++) { // cyklus 0 - dlzka retazca po jednom vzostupne
                if (islower(s[i])) // ak je znak male pismeno
                    s[i] = toupper(s[i]); // zmeni ho na velke pismeno
            }
            break; // nutný prikaz
        case 'x': // x
        case 'X': // alebo X,
            for (i = 0; i < strlen(s); i++) { // cyklus 0 - dlzka retazca po jednom vzostupne
                if (isupper(s[i])) // ak je znak velke pismeno
                    s[i] = tolower(s[i]); // zmeni ho na male pismeno
                else if(islower(s[i])) // ak je znak male pismeno
                    s[i] = toupper(s[i]); // zmeni ho na velke pismeno
            }
            break; // nutný prikaz
    }
    printf("\n%s\n", s);  // vytlaci vygenerovany retazec ENTER

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 6.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie

int main(void)
{
    /* prvy sposob definicie s inicializaciou */
    char c[30] = "okuzhudheztara258465"; // definuje retazec s velkostou max. 30 znakov a inicializuje ho
    /* druhy sposob definicie s inicializaciou, priestor v pamati sa nemusi dynamicky alokovat */
    char *c_dyn = "okuzhudheztara258465"; // definuje pointer na retazec a inicializuje ho

    printf("Retazcova konstanta je ulozena od adresy %#x.\n", c); // vypise adresu umiestnenia prveho retazca
    printf("Retazcova konstanta je ulozena od adresy %#x.\n", c_dyn); // vypise adresu umiestnenia druheho retazca

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 7.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // malloc()
#include <string.h> // strchr()

int main(void) {
    int i, zaciatok, koniec; // deklaracia premenných typu int, stredna je inicializovana
    char znak, *riadok, *najdi; // deklaracia premennej typu char a dvoch pointerov na retazce

    if ((riadok = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((najdi = (char *) malloc(8)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Napis vetu na jeden riadok.\n\n");
    gets(riadok); // zadanie retazca z klavesnice
    printf("\nNapis jeden samostatny znak.\n\n");
    znak = getchar(); // zadanie jedneho retazca z klavesnice
    printf("\nVypis podla zadania je:\n\n%s\n", riadok); // vypis retazca ENTER

    najdi = strchr(riadok, znak); // do retazca sa nacita hodnota adresy pointera na prvy vyskyt znaku v retazci
    zaciatok = 0; //
    while (najdi != NULL) { // cyklus bezi kym funkcia strchr() nieco najde
        koniec = najdi - riadok; // do premennej koniec sa zapise poradove cislo najdeneho znaku
        for (i = zaciatok; i < koniec; i++) // cyklus zaciatok - (koniec - 1) po jednom vzostupne
            putchar(' '); // v cykle vypisuje medzery
        putchar('*'); // vypise hviezdicku
        najdi = strchr(najdi + 1, znak); // najde dalsi znak v retazci a adresu jeho pointeru ulozi do retazca najdi
        zaciatok = koniec + 1; // hodnotu zaciatku nastavi na hodnotu konca
    }
    putchar('\n'); // ENTER

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 8.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h> // I/O funkcie
#include <stdlib.h> // malloc()
#include <string.h> // funkcia strlen()

/******************************************************************************
 * funkcia vyziada zadanie mena suboru a pripony suboru z klavesnice samostatne
 * a ak ma pripona presne 3 znaky, prevedie to do tvaru meno.pripona a vrati
 * ten tvar tam, odkial bola funkcia volana
 ******************************************************************************/
char* nazov(void) // navratova hodnota funkcie je retazec
{
    char *meno, *prip; // definicia pointerov na retazce

    if ((meno = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((prip = (char *) malloc(4)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj nazov suboru bez pripony: ");
    gets(meno); // zadanie retazca z klavesnice
    printf("Zadaj nazov pripony suboru: ");
    gets(prip); // zadanie retazca z klavesnice
    if (strlen(prip) != 3) { // ak sa dlzka pripony nerovna 3
        printf("Pripona musi mat 3 znaky!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    sprintf(meno, "%s.%s", meno, prip); // spoji retazce do tvaru retazec.retazec
    return meno; // vrati novy vytvoreny retazec
}

int main(void)
{
    FILE *fr; // definicia pointera na subor
    char c; // deklaracia premennej typu char

    if ((fr = fopen(nazov(), "r")) == NULL) { // otvorenie suboru ak existuje tam, kde sa hlada
        printf("Subor sa neotvoril!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
        while ((c = getc(fr)) != EOF) // cyklus cita subor do konca po znakoch
            putchar(c); // v cykle vypisuje precitane znaky na obrazovku
        putchar('\n'); // ENTER
    fclose(fr); // zavretie suboru

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 9.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // funkcie malloc() a exit(1)
#include <string.h> // funkcia strlen() a  strstr()

/******************************************************************************
 * funkcia vyziada zadanie mena suboru a pripony suboru z klavesnice samostatne
 * a ak ma pripona presne 3 znaky, prevedie to do tvaru meno.pripona a vrati
 * ten tvar tam, odkial bola funkcia volana
 ******************************************************************************/
char* nazov(void) // navratova hodnota funkcie je retazec
{
    char *meno, *prip; // definicia pointerov na retazce

    if ((meno = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((prip = (char *) malloc(4)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj nazov suboru bez pripony: ");
    gets(meno); // zadanie retazca z klavesnice
    printf("Zadaj nazov pripony suboru: ");
    gets(prip); // zadanie retazca z klavesnice
    if (strlen(prip) != 3) { // ak sa dlzka pripony nerovna 3
        printf("Pripona musi mat 3 znaky!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    sprintf(meno, "%s.%s", meno, prip); // spoji retazce do tvaru retazec.retazec
    return meno; // vrati novy vytvoreny retazec
}

int main(void)
{
    FILE *fr; // definicia pointera na subor
    char *riadok, *slovo; //definicia pointerov na retazce

    if ((riadok = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((slovo = (char *) malloc(20)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((fr = fopen(nazov(), "r")) == NULL) { // otvorenie suboru ak existuje tam, kde sa hlada
        printf("Subor sa neotvoril!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("\nNapis slovo, ak sa nachadza v niektorych riadkoch\n"
           "otvoreneho suboru, vypisem tie riadky.\n");
    scanf("%s", slovo); // zadanie retazca z klavesnice
    putchar('\n'); // ENTER
    while (fgets(riadok, 80, fr) != NULL) { // cyklus cita subor do konca po riadkoch
        if (strstr(riadok, slovo)) // ak  sa zadane slovo nachadza v riadku
            printf("%s", riadok); // riadok sa vypise
    }
    fclose(fr); // zatvorenie suboru

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 10.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // malloc()
#include <string.h> // funkcia strlen()

/******************************************************************************
 * funkcia vyziada zadanie mena suboru a pripony suboru z klavesnice samostatne
 * a ak ma pripona presne 3 znaky, prevedie to do tvaru meno.pripona a vrati
 * ten tvar tam, odkial bola funkcia volana
 ******************************************************************************/
char* nazov(void) // navratova hodnota funkcie je retazec
{
    char *meno, *prip; // definicia pointerov na retazce

    if ((meno = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((prip = (char *) malloc(4)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj nazov suboru bez pripony: ");
    gets(meno); // zadanie retazca z klavesnice
    printf("Zadaj nazov pripony suboru: ");
    gets(prip); // zadanie retazca z klavesnice
    if (strlen(prip) != 3) { // ak sa dlzka pripony nerovna 3
        printf("Pripona musi mat 3 znaky!\n");
        exit(1); // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    sprintf(meno, "%s.%s", meno, prip); // spoji retazce do tvaru retazec.retazec
    return meno; // vrati novy vytvoreny retazec
}

int main(void)
{
    FILE *fr; // definicia pointera na subor
    int i = 1; // deklaracia premennej typu in aj s inicializáciou
    char *riadok; // definicia pointera na retazec

    if ((riadok = (char *) malloc(100)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((fr = fopen(nazov(), "r")) == NULL) { // otvorenie suboru ak existuje tam, kde sa hlada
        printf("Subor sa neotvoril!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    while (fgets(riadok, 100, fr) != NULL) { // cyklus cita cely subor po riadkoch max. dlzkx 100 znakov
        if (strchr(riadok, '\n'))
            printf("%d. riadok ma %d znakov.\n", i, strlen(riadok) - 1); // poradove cislo riadku a pocet znakov v nom
        else
            printf("%d. riadok ma %d znakov.\n", i, strlen(riadok)); // poradove cislo riadku a pocet znakov v nom
        i++; // dalsi riadok v poradi
    }
    fclose(fr); // zavretie suboru

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 11.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // malloc()
#include <string.h> // strchr() a strlen()

int main(void) {
    //int i, zaciatok, koniec, posledny; // deklaracia premenných typu int, stredna je inicializovana
    char *slova, *najdi; // definicia pointerov na retazce

    /* druha varianta */
    int i, j, k = 0, *pomoc; // deklaracia premenných typu int, posledna je inicializovana, definicia pointera na pole typu int

    if ((pomoc = (int *) malloc(80 * sizeof(int))) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }


    if ((slova = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((najdi = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj niekolko slov oddelenych od seba jednou medzerou \n"
           "a ja ich rozpisem po jednom do riadkov pod seba.\n\n");
    gets(slova); // zadanie retazca z klavesnice
    /* prva varianta
    zaciatok = 0; // vynulovanie premennej
    najdi = strchr(slova, ' '); // do retazca sa nacita hodnota adresy pointera na prvy vyskyt znaku v retazci
    putchar('\n'); // ENTER
    while (najdi != NULL) { // cyklus bezi kym funkcia strchr() nieco najde
        koniec = najdi - slova; // do premennej koniec sa zapise poradove cislo najdeneho znaku
        for (i = zaciatok; i < koniec; i++)  // cyklus zaciatok slova - (koniec - 1) po jednom vzostupne
            printf("%c", slova[i]); // v cykle vypisuje slova po znakoch
        najdi = strchr(najdi + 1, ' '); // najde dalsi znak v retazci a adresu jeho pointeru ulozi do retazca najdi
        zaciatok = koniec + 1; // hodnotu zaciatku nastavi na hodnotu konca
        putchar('\n'); // ENTER
    }
    for (i = zaciatok; i < strlen(slova); i++) // cyklus zaciatok slova - dlzka retazca po jednom vzostupne
            printf("%c", slova[i]); // v cykle vypisuje posledne slovo po znakoch

    putchar('\n'); // ENTER */

    /* druha varianta */
    najdi = strchr(slova, ' '); // do retazca sa nacita hodnota adresy pointera na prvy vyskyt znaku v retazci
    putchar('\n'); // ENTER
    while (najdi != NULL) { // cyklus bezi kym funkcia strchr() nieco najde
        j = najdi - slova + 1; // do premennej j vlozi poradove cislo zaciatku slova
        pomoc[k] = j; // do jednorozmerneho pola na dalsiu poziciu vlozi hodnotu j
        najdi = strchr(najdi + 1, ' '); // najde dalsi znak v retazci a adresu jeho pointeru ulozi do retazca najdi
        k++; // dalsi prvok v poradi v poli pomoc
    }
    for (i = 0; i < strlen(slova) + 1; i++) { // cyklus 0 - dlzka retazca + 1 po jednom vzostupne
        for (j = 0; j < k + 1; j++) { // cyklus 0 - pocet prvkov v poli pomoc po jednom vzostupne
            if (i == pomoc[j]) // ak sa poradove cislo znaku z retazca rovna cislu v poli pomoc
                slova[i - 1] = '\n'; // v retazci sa medzera prepise na ENTER
        }
    }
    puts(slova); // vypis zmeneneho retazca

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 12.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcie
#include <stdlib.h> // malloc()
#include <string.h> // strcat()

/*******************************************************************
 * funkcia vlozi do jedneho retazca druhy retazec od urcenej pozicie
 * v prvom retazci a vypise vysledok
 *******************************************************************/
void strings(char *s1, char *s2, int i) // funkcia nema navratovu hodnotu
{
    s1[i - 1] = '\0'; // nastavi koniec prveho retazca podla zadanej pozicie
    printf("%s\n", strcat(s1, s2)); // vlozi druhy retazec a vypise vysledok ENTER
}

int main(void)
{
    int pozicia; // deklaracia premennej typu int
    char *ret1, *ret2; // definicia pointerov na retazce

    if ((ret1 = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    if ((ret2 = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj prvy retazec.\n\n");
    gets(ret1); // zadanie retazca z klavesnice
    printf("Zadaj druhy retazec.\n\n");
    gets(ret2); // zadanie retazca z klavesnice
    printf("Zadaj od ktorej pozicie prveho retazca sa ma vlozit druhy retazec.\n\n");
    scanf("%d", &pozicia); // zadanie pozicie v retazci z klavesnice
    strings(ret1, ret2, pozicia); // volanie funkcie

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 13.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcia
#include <stdlib.h> // malloc() a exit(1)
#include <string.h> // strcpy()

/****************************************************************
 * funkcia zmaze v retazci urceny pocet znakov (int n) od urcenej
 * pozicie (int i) a vypise upraveny retazec
 ****************************************************************/
void strdel(char *s, int i, int n) // bez navratovej hodnoty
{
    strcpy(&s[i - 1], &s[i - 1 + n]); // vlozi od stanovenej adresy retazec od druhej stanovenej adresy
    puts(s); // vypise novy retazec na obrazovku
}

int main(void) {
    int i, j = 3, k = 5; // deklaracia premennych typu int, druha a tretia premenna je aj inicializovana
    char *ret; // definicia pointeru na retazec

    if ((ret = (char *) malloc(80)) == NULL) { // dynamicka alokacia s kontrolou volnej pamati
        printf("Malo pamati!");
        return 1; // ukonci beh programu - oznami pocitacu, ze program skoncil s chybou
    }
    printf("Zadaj retazec.\n\n");
    gets(ret); // zadanie retazca z klavesnice
    printf("Z retazca od pozicie 3 zmazem 5 znakov a vypisem ho.\n\n");
    strdel(ret, j, k); // volanie funkcie

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}

/***********************************************
 *
 * 14.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 *
 * libcosenior,     september 2012
 *
 ***********************************************/

#include <stdio.h>  // I/O funkcia
#define PI "3.141592653" //cislo pi na 9 desatinnych miest - format retazec

int main(void)
{
    int i; // deklaracia premennej typu int
    char pom[] = PI; // definicia retazca s inicializaciou

    for (;;) { // nekonecky cyklus
        printf("Zadaj na kolko desafinnych miest mam vytlacit ludolfovo cislo: ");
        scanf("%d", &i); // zadanie celeho cisla z klavesnice
        printf("\n%.*s\n\n", i + 2, pom); // orezanie retazca na urceny pocet desatinnych miest
                                          // (+ 2 je pre posun za desatinnu ciarku)
        printf("(program ukoncis dvojklikom Ctrl + c)\n\n"); // ako ukoncit beh programu
    }

    return 0; // ukonci beh programu - oznami pocitacu, ze program skoncil bez chyby
}