Škôlka jazyka C

/***********************************************
 *
 * 1.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pouzita diakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

#include <stdio.h>

char ss = 231, uu = 163, z = 167, l = 150, t = 156;

typedef struct {
    float f;
    char  c;
    int   i;
} STRUKTURA;

typedef union {
    float f;
    char  c;
    int   i;
} UNIONY;

int main(void)
{
    STRUKTURA  s;
    UNIONY  u;

    printf("Adresa %ctrukt%cry 's' : %p \n", ss, uu, &s);
    printf("Adresa polo%cky 's.f' : %p \n", z, &s.f);
    printf("Adresa polo%cky 's.c' : %p \n", z, &s.c);
    printf("Adresa polo%cky 's.i' : %p \n", z, &s.i);
    printf("Ve%ckos%c %ctrukt%cry je %d bajtov.\n", l, t, ss, uu,  sizeof(STRUKTURA));

    putchar('\n');

    printf("Adresa unionu 'u'    : %p \n", &u);
    printf("Adresa polo%cky 'u.f' : %p \n", z, &u.f);
    printf("Adresa polo%cky 'u.c' : %p \n", z, &u.c);
    printf("Adresa polo%cky 'u.i' : %p \n", z, &u.i);
    printf("Ve%ckos%c unionu je %d bajty.\n", l, t, sizeof(UNIONY));

    return 0;
}

/***********************************************
 *
 * 2.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pouzita siakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

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

char ss = 231, uu = 163, z = 167, l = 150, t = 156, ii = 161, aa = 160, ae = 132;

typedef struct {
    char jmeno[30];
    int stari;
} OSOBA;

void napln(OSOBA *p_osoba, char *meno, int vek)
{
    strcpy(p_osoba->jmeno, meno);
    p_osoba->stari = vek;
}

int main(void)
{
    int vek;
    char meno[30];
    OSOBA ja;
    OSOBA *p_kamos;

    printf("Nap%c%c svoje meno a priezvisko: ", ii, ss);
    gets(meno);
    printf("Nap%c%c ko%cko m%c%c rokov: ", ii, ss, l, aa, ss);
    scanf("%d", &vek);
    while (getchar() != '\n'); /* zahodenie <ENTER>, inaksie to bude blbnut */
        ;
    napln(&ja, meno, vek);

    /* alokovanie pamati pre dynamicku strukturu */
    if ((p_kamos = (OSOBA *) malloc(sizeof(OSOBA))) == NULL) {
        printf("\nM%clo pam%cti! \n", aa, ae);
        return;
    }
    printf("\n\nNap%c%c meno a priezvisko kamar%cta: ", ii, ss, aa);
    gets(meno);
    printf("Nap%c%c jeho vek: ", ii, ss);
    scanf("%d", &vek);
    napln(p_kamos, meno, vek);

    /* vytlacenie obsahu struktur */
    printf("\n\nJa sa vol%cm %s a m%cm %d rokov.\n", aa, ja.jmeno, aa, ja.stari);
    printf("Kamar%ct sa vol%c %s a m%c %u rokov.\n", aa, aa, p_kamos->jmeno, aa, p_kamos->stari);

    return 0;
}

/***********************************************
 *
 * 3.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pridana diakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DLZKAMENA 30

char ss = 231, uu = 163, z = 167, l = 150, t = 156, ii = 161, aa = 160, ae = 132, yy = 236;

typedef struct {
    char jmeno[DLZKAMENA];
    int stari;
} OSOBA;

void napln(OSOBA *p_osoba, char *meno, int vek)
{
    strcpy(p_osoba->jmeno, meno);
    p_osoba->stari = vek;
}

int main(void)
{
    OSOBA osoby[1000];
    FILE *fr;
    int i,
        pocet = 0,         /* skutocny pocet osob v subore */
        vek;               /* pomocny vek pre nacitanie */
    double sucet_vek = 0.0,
           priemerny_vek;
    char meno[DLZKAMENA];  /* pomocne meno pre nacitanie */
    /* otvorenie suboru */
    if ((fr = fopen("OSOBY.TXT", "r")) == NULL) {
        printf("\nS%cbor sa ned%c otvori%c! \n", uu, aa, t);
        return;
    }
    /* citanie suboru po riadkoch a vlozenie udajov do pola struktur
       spocitanie celkoveho veku */
    while (fscanf(fr, "%s %d", meno, &vek) == 2) {
        napln(&osoby[pocet++], meno, vek);
        sucet_vek += vek;
    }
    /* zavretie suboru */
    if (fclose(fr) == EOF)
        printf("\nS%cbor sa ned%c zavrie%c! \n", uu, aa, t);

    /* vypocet priemerneho veku */
    priemerny_vek = (int) sucet_vek / pocet;

    /* vypis mien vsetkych ludi v priemernom veku */
    printf("Priemern%c vek %d-ich %cud%c zo s%cboru \"OSOBY.TXT\" je %.0f rokov.\n", yy, pocet, l, ii, uu, priemerny_vek);
    printf("V tomto veku s%c nasleduj%cci %cudia: \n", uu, uu, l);
    /* ak ma v strukture meno priradeny vypocitany priemerny vek, tak ho vypise */
    for (i = 0;  i < pocet;  i++) {
        if (priemerny_vek == osoby[i].stari)
            printf(" - %s \n", osoby[i].jmeno);
    }
    return 0;
}

/***********************************************
 *
 * 4.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pridana diakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DLZKAMENA 30

char ss = 231, uu = 163, z = 167, l = 150, t = 156, ii = 161, aa = 160, ae = 132, yy = 236;

typedef struct osoba {
    char jmeno[DLZKAMENA];
    int stari;
    struct osoba *p_dalsi;
} OSOBA;

void napln(OSOBA *p_osoba, char *meno, int vek)
{
    strcpy(p_osoba->jmeno, meno);
    p_osoba->stari = vek;
}

int main(void)
{
    OSOBA *p_prvy = NULL, /* prva polozka zoznamu */
          *p_aktualny,    /* jednosmerne zreťazeny dynamicky zoznam struktur*/
          *p_pomocny;     /* pomocna polozka zoznamu */
    FILE  *fr;
    int i,
        pocet = 0,         /* skutocny pocet osob v subore */
        vek;               /* pomocny vek pre nacitanie */
    double sucet_vek = 0.0,
           priemerny_vek;
    char meno[DLZKAMENA];  /* pomocne meno pre nacitanie */

    /* otvorenie suboru */
    if ((fr = fopen("OSOBY.TXT", "r")) == NULL) {
        printf("\nS%cbor sa ned%c otvori%c! \n", uu, aa, t);
        return;
    }
    /* citanie suboru po riadkoch a vlozenie udajov do
       jednosmerne zreťazeného dynamického zoznamu */
    while (fscanf(fr, "%s %d", meno, &vek) == 2) {
        /* dynamicke alokovanie novej struktury */
        if ((p_pomocny = (OSOBA *) malloc(sizeof(OSOBA))) == NULL) {
            printf("\nM%clo pam%cti!\n", aa, ae);
            /* program sa neukonci, ale pracuje len s tymi datami, ktore
               sa podarilo ulozit do pamati */
            break;
        }
        pocet++;
        if (p_prvy == NULL)
            p_prvy = p_pomocny;
        else
            p_aktualny->p_dalsi = p_pomocny; /* pripojenie struktury do retazce */

        p_aktualny = p_pomocny;              /* soucasny prvok se stava aktualnym */
        p_aktualny->p_dalsi = NULL;          /* nulovanie ukazovatela = koniec retaze */
        napln(p_aktualny, meno, vek);        /* vlozenie udajov do zoznamu */
        sucet_vek += vek;                    /* sucet vsetkych poloziek vek */
    }
    /* zavretie suboru */
    if (fclose(fr) == EOF)
        printf("\nS%cbor sa ned%c zavrie%c! \n", uu, aa, t);

    /* vypocet priemerneho veku */
    priemerny_vek = (int) sucet_vek / pocet;

    /* vypis mien vsetkych ludi v priemernom veku */
    printf("Priemern%c vek %d %cud%c zo s%cboru \"OSOBY.TXT\" je %.0f rokov.\n", yy, pocet, l, ii, uu, priemerny_vek);
    printf("V tomto veku s%c nasleduj%cci %cudia: \n", uu, uu, l);
    /* ak ma v zozname struktur meno priradeny vypocitany priemerny vek, tak ho vypise */
    for (p_aktualny = p_prvy; p_aktualny->p_dalsi != NULL; p_aktualny = p_aktualny->p_dalsi) {
        if (priemerny_vek == p_aktualny->stari)
            printf(" - %s \n", p_aktualny->jmeno);
    }
    return 0;
}

/***********************************************
 *
 * 5.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pridana diakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_DLZKA 80 /* maximalna dlzka riadka */

/* globalne pomocne premenne k diakritike */
char ss = 231, uu = 163, z = 167, l = 150, t = 156, ii = 161, aa = 160, ae = 132, yy = 236;

/* struktura s dynamickým prvkom *p_dalsi */
typedef struct riadky {
    char riadok[MAX_DLZKA];
    int aktualna_dlzka;
    struct riadky *p_dalsi;
} RIADOK;

/* funkcia - dynamická alokácia prvku, ak je pamat alokovana, vrati sa struktura */
RIADOK *alokuj_a_testuj(void)
{
    RIADOK *p_pom;
    p_pom = (RIADOK *) malloc(sizeof(RIADOK));
    if (p_pom == NULL) {
        printf("\nM%clo pam%cti!\n", aa, ae);
        exit(1);
    }
    return p_pom;
}

int main(void)
{
    int i, max_dlzka = 0;
    RIADOK *p_prvy = NULL,
           *p_aktualny;
    FILE   *fr;

    /* otvorenie suboru */
    if ((fr = fopen("SUBOR.TXT", "r")) == NULL) {
        printf("\nS%cbor sa ned%c otvori%c! \n", uu, aa, t);
        return;
    }

    /* vytvorenie prveho prvku struktury */
    p_prvy = alokuj_a_testuj();
    if ((fgets(p_prvy->riadok, MAX_DLZKA - 1, fr)) != NULL) {
        p_prvy->aktualna_dlzka = strlen(p_prvy->riadok);
    }
    p_prvy->p_dalsi = NULL;
    p_aktualny = p_prvy;

    /* vytvorenie vsetkych ostatnych prvkov */
    for (;;) {
        p_aktualny->p_dalsi = alokuj_a_testuj();
        p_aktualny = p_aktualny->p_dalsi;
        if ((fgets(p_aktualny->riadok, MAX_DLZKA - 1, fr)) != NULL) {
            p_aktualny->aktualna_dlzka = strlen(p_aktualny->riadok);
            /* zistenie dlzky najdlhsieho riadku */
            if (max_dlzka < p_aktualny->aktualna_dlzka)
                max_dlzka = p_aktualny->aktualna_dlzka;
            /* posun na dalsiu strukturu */
            p_aktualny->p_dalsi = NULL;
        }
        else
            break;
    }

    /* zavretie suboru */
    if (fclose(fr) == EOF)
        printf("\nS%cbor sa ned%c zavrie%c! \n", uu, aa, t);

    /* v cykle najde najdlhsi riadok a vypise ho */
    printf("Najdlh%cie riadky s%cboru maj%c %d znakov a s%c to tieto riadky:\n\n"
                   , ss, uu, uu, max_dlzka, uu);
    for (p_aktualny = p_prvy; p_aktualny->p_dalsi != NULL; p_aktualny = p_aktualny->p_dalsi) {
        if (max_dlzka == p_aktualny->aktualna_dlzka)
            puts(p_aktualny->riadok);
    }

    return 0;
}

/***********************************************
 *
 * 6.c        ver. 1.0
 * popis je vyssie
 * ===========================================
 * pridana diakritika
 *
 * libcosenior,     oktober 2012
 *
 ***********************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_DLZKA 80 /* maximalna dlzka riadka */

/* globalne pomocne premenne k diakritike */
char ss = 231, uu = 163, z = 167, l = 150, t = 156, ii = 161, aa = 160, ae = 132, yy = 236;

/* struktura s dynamickým prvkom *p_dalsi */
typedef struct riadky {
    char *p_riadok;
    int aktualna_dlzka;
    struct riadky *p_dalsi;
} RIADOK;

/* funkcia - dynamická alokácia prvku, ak je pamat alokovana, vrati sa struktura */
RIADOK *alokuj_a_testuj(void)
{
  RIADOK *p_pom;

    p_pom = (RIADOK *) malloc(sizeof(RIADOK));
    if (p_pom == NULL) {
        printf("\nM%clo pam%cti!\n", aa, ae);
        exit(1);
    }
    return p_pom;
}

int main(void)
{
    int i, priem_dlzka = 0, pocitaj = 1;
    RIADOK *p_prvy = NULL,
           *p_aktualny;
    char pom[MAX_DLZKA];
    FILE   *fr;

    /* otvorenie suboru */
    if ((fr = fopen("SUBOR.TXT", "r")) == NULL) {
        printf("\nS%cbor sa ned%c otvori%c! \n", uu, aa, t);
        return;
    }

    /* vytvorenie prveho prvku struktury */
    p_prvy = alokuj_a_testuj();
    if ((fgets(pom, MAX_DLZKA - 1, fr)) != NULL) {
        if ((p_prvy->p_riadok = (char *) malloc(strlen(pom) + 1)) != NULL) {
            strcpy(p_prvy->p_riadok, pom);
            p_prvy->aktualna_dlzka = strlen(p_prvy->p_riadok);
        }
        else {
            printf("Malo pamati");
            exit(1);
        }
    }
    p_prvy->p_dalsi = NULL;
    p_aktualny = p_prvy;
    priem_dlzka = p_aktualny->aktualna_dlzka;

    /* vytvorenie vsetkych ostatnych prvkov */
    for (;;) {
        p_aktualny->p_dalsi = alokuj_a_testuj();
        p_aktualny = p_aktualny->p_dalsi;
        if ((fgets(pom, MAX_DLZKA - 1, fr)) != NULL) {
            if ((p_aktualny->p_riadok = (char *) malloc(strlen(pom) + 1)) != NULL) {
                strcpy(p_aktualny->p_riadok, pom);
                p_aktualny->aktualna_dlzka = strlen(p_aktualny->p_riadok);
                /* zistenie dlzky vsetkych riadkov */
                priem_dlzka += p_aktualny->aktualna_dlzka;
                /* pocitadlo riadkov */
                pocitaj++;
            }
            else {
                printf("Malo pamati");
                exit(1);
            }
            /* posun na dalsiu strukturu */
            p_aktualny->p_dalsi = NULL;
        }
        else
            break;
    }

    /* zavretie suboru */
    if (fclose(fr) == EOF)
        printf("\nS%cbor sa ned%c zavrie%c! \n", uu, aa, t);

    /* v cykle vypise vsetky riadky o priemernej velkosti */
    priem_dlzka /= pocitaj;
    printf("Priemerne riadky suboru maju %d znakov a su to tieto riadky:\n\n",priem_dlzka);
    for (p_aktualny = p_prvy; p_aktualny->p_dalsi != NULL; p_aktualny = p_aktualny->p_dalsi) {
        if (priem_dlzka == p_aktualny->aktualna_dlzka)
            puts(p_aktualny->p_riadok);
    }

    /* zaverecne uvolnenie pamati */
    for (p_aktualny = p_prvy; p_aktualny->p_dalsi != NULL; p_aktualny = p_aktualny->p_dalsi) {
        free((void *) p_aktualny);
    }

    return 0;
}

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

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

#define MAX_DLZKA_RIADOK  80
#define MAX_RIADKOV     1000

/* vhniezdena struktura */
typedef struct {
    int pismena;
    int nie_pismena;
} ZNAKY;

/* hlavna struktura */
typedef struct {
    int dlzka_riadku;
    ZNAKY pocet;
} RIADKY;

int main(void)
{
    int i, pocet_pismen, pocet_nie_pismen, pocet_riadkov = 0;
    FILE *fr;
    char pom[MAX_DLZKA_RIADOK];
    RIADKY riadky[MAX_RIADKOV];

    /* otvorenie suboru */
    if ((fr = fopen("SUBOR.TXT", "r")) == NULL) {
        printf("\nSubor sa neda otvorit! \n");
        return;
    }

    /* nacitanie údajov zo suboru do struktury */
    /* zistenie dlzky riadku */
    while (fgets(pom, MAX_DLZKA_RIADOK - 1, fr) != NULL) {
        pocet_pismen = pocet_nie_pismen = 0;
        /* ulozenie dlzky riadku do struktury */
        riadky[pocet_riadkov].dlzka_riadku = strlen(pom);
        /* zistenie poctu pismen a nie pismen v riadku */
        for (i = 0; i < riadky[pocet_riadkov].dlzka_riadku; i++)
            isalpha (pom[i]) ? pocet_pismen++ : pocet_nie_pismen++;
        /* ulozenie poctu pismen a nie pismen do struktury */
        riadky[pocet_riadkov].pocet.pismena = pocet_pismen;
        riadky[pocet_riadkov].pocet.nie_pismena = pocet_nie_pismen;
        /* pocitadlo riadkov */
        pocet_riadkov++;
    }

    /* zavretie suboru */
    if (fclose(fr) == EOF)
        printf("\nSubor sa neda zavriet! \n");

    /* zistenie v cykle poctu pismen v subore a vypis vysledku */
    pocet_pismen = 0;
    for (i = 0; i < pocet_riadkov; i++)
        pocet_pismen += riadky[i].pocet.pismena;
    printf("V subore je spolu %d pismen.\n", pocet_pismen);

    return 0;
}

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

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

/* definicia vyctoveho typu */
typedef enum {
    NIE, ANO
} BOOLEAN;

/* funkcia zistuje ci subor je v pc na zadanej ceste */
BOOLEAN je_tu(char *meno)
{
    FILE  *fr;

    if ((fr = fopen(meno, "r")) != NULL) {
        fclose(fr);
        return (ANO);
    }
    else
        return (NIE);
}

int main(void)
{
    char meno[100];

    do {
        printf("Zadej meno suboru aj s cestou [Q - koniec]:\n"
               "\n ________________________________________\b\b\b\b\b\b\b\b\b\b"
               "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
        scanf("%s", meno);

        if (je_tu(meno) == ANO)
            printf("\nSoubor '%s' existuje.\n\n", meno);
        else
            printf("\nSoubor '%s' nie je na na zadanej ceste na PC.\n\n", meno);
    } while (toupper(meno[0]) != 'Q');

    return 0;
}

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

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

/* definicia vyctoveho typu */
typedef enum {
    ZIGULI, TRABANT, LADA, SKODA, OLCIT
} AUTOMOBILY;

int main(void)
{
    int i, j;
    char *mena_aut[] = { "Ziguli", "Trabant",
                         "Lada", "Skoda", "Olcit" };

    printf("Pacia sa vam tieto auta? printf()\n");
    for (i = ZIGULI;  i <= OLCIT;  i++)
        printf("%d. %s \n", i, mena_aut[i]);
    putchar('\n');

    printf("Nepaci sa mi ani jedno z tychto aut: puts() v opacnom poradi\n");
    for (i = OLCIT;  i >= ZIGULI;  i--) {
        printf("%d. ", i);
        puts(mena_aut[i]);
    }
    putchar('\n');

    return 0;
}

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

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

/* definicia vyctoveho typu */
typedef enum {
    ZIGULI  = 259,
    TRABANT = 1000,
    LADA    = 157,
    SKODA,          /* tu sa implicitne prideli cislo o jedna vacsie ako predchadzajuce */
    OLCIT   = 99
} AUTOMOBILY;

void vytlac(AUTOMOBILY inicialy)
{
    switch (inicialy) {
        case ZIGULI:
            printf("Typ Ziguli\t cena %4d euro.\n", ZIGULI);
            break;
        case TRABANT:
            printf("Typ Trabant\t cena %4d euro.\n", TRABANT);
            break;
        case LADA:
            printf("Typ Lada\t cena %4d euro.\n", LADA);
            break;
        case SKODA:
            printf("Typ Skoda\t cena %4d euro.\n", SKODA);
            break;
        case OLCIT:
            printf("Typ Olcit\t cena %4d euro.\n", OLCIT);
            break;
    }
}

int main(void)
{
    AUTOMOBILY automobil;
    automobil = ZIGULI; /* test spravnosti */

    printf("Na vyber su tieto automobily : \n\n");
    vytlac(automobil);  /* test spravnosti */
    vytlac(TRABANT);
    vytlac(LADA);
    vytlac(SKODA);
    vytlac(OLCIT);

    return 0;
}