C Programazio Ariketak

Pig Latin Itzultzailea

Programa honek erabiltzaileak sartutako esaldi bat Pig Latinera itzultzen du. Pig Latin hizkuntza-joko bat da, non hitz bakoitzaren lehenengo kontsonantea (edo kontsonante-multzoa) hitzaren amaierara mugitzen den eta "ay" atzizkia gehitzen zaion.

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

void hitza_pig_latinez(char hitza[]);

int main() {
    char esaldia[250], h[250];
    int i, j;
    fflush(stdin);
    printf("\nHitz multzo batez osatutako esaldi bat tekleatu: \n");
    gets(esaldia);
    i = 0;
    while (esaldia[i] != '\0') {
        while (esaldia[i] == ' ') {
            i = i + 1;
        }
        if (esaldia[i] != '\0') {
            j = 0;
            while (esaldia[i] != '\0' && esaldia[i] != ' ') {
                h[j] = esaldia[i];
                i = i + 1;
                j = j + 1;
            }
            h[j] = '\0';
            hitza_pig_latinez(h);
            printf("%s ", h);
        }
    }
    system("pause");
    return 0;
}

void hitza_pig_latinez(char hitza[]) {
    int i;
    char lehenengoa;
    lehenengoa = hitza[0];
    i = 1;
    while (hitza[i] != '\0') {
        hitza[i - 1] = hitza[i];
        i = i + 1;
    }
    hitza[i - 1] = lehenengoa;
    hitza[i] = 'a';
    hitza[i + 1] = '\0';
}

Funtzioen Azalpena

• hitza_pig_latinez(char hitza[]): Hitz bat hartu eta Pig Latinera itzultzen du.
• main(): Erabiltzaileari esaldia eskatzen dio, esaldia hitzez hitz prozesatzen du, eta Pig Latinera itzulitako esaldia inprimatzen du.

Otello Zenbakiak

Programa honek erabiltzaileak zehaztutako lehenengo n Otello zenbakiak kalkulatzen eta bistaratzen ditu. Otello zenbaki bat zenbaki oso bakoiti bat da, bere alderantzizkoarekin (digituak alderantzizko ordenan jarrita) zatitzaile kopuru bera duena, eta gutxienez 4 zatitzaile dituena.

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

int zenbakia_eskatu();
int zenbakia_bueltatu(int zen);
int zatitzaile_kopurua(int n);
int otello_zenbakia_da(int n1);

int main() {
    int n;
    int kont = 0;
    int zen = 1;
    n = zenbakia_eskatu();
    printf("\nLehenengo %d Otello zenbakiak hauek dira: ", n);
    do {
        if (otello_zenbakia_da(zen) == 1) {
            printf(" %d", zen);
            kont = kont + 1;
        }
        zen = zen + 1;
    } while (kont < n);
    printf("\n\n");
    system("pause");
    return 0;
}

int zenbakia_eskatu() {
    int n;
    do {
        printf("\nn-rentzako balioa sartu: ");
        scanf("%d", &n);
        if (n <= 0) {
            printf("\nERROREA. Zenbaki desegokia.\n");
        }
    } while (n <= 0);
    return (n);
}

int zenbakia_bueltatu(int zen) {
    int nez = 0;
    int h;
    int n = zen;
    while (n > 0) {
        h = n % 10;
        nez = nez * 10 + h;
        n = n / 10;
    }
    return (nez);
}

int zatitzaile_kopurua(int n) {
    int i, kont = 0;
    for (i = 1; i <= n; i = i + 1) {
        if (n % i == 0) {
            kont = kont + 1;
        }
    }
    return (kont);
}

int otello_zenbakia_da(int n1) {
    int n2, z1, z2;
    n2 = zenbakia_bueltatu(n1);
    z1 = zatitzaile_kopurua(n1);
    z2 = zatitzaile_kopurua(n2);
    if (n1 != n2 && n1 % 2 == 1 && n2 % 2 == 1 && z1 == z2 && z1 > 4) {
        return (1);
    }
    else {
        return (0);
    }
}

Funtzioen Azalpena

• zenbakia_eskatu(): Erabiltzaileari zenbaki positibo bat eskatzen dio.
• zenbakia_bueltatu(int zen): Zenbaki baten digituak alderantziz jartzen ditu.
• zatitzaile_kopurua(int n): Zenbaki baten zatitzaile kopurua kalkulatzen du.
• otello_zenbakia_da(int n1): Zenbaki bat Otello zenbakia den ala ez egiaztatzen du.
• main(): Erabiltzaileari Otello zenbakien kopurua eskatzen dio, eta Otello zenbakiak kalkulatu eta bistaratzen ditu.

ADN Kateen Egonkortasuna

Programa honek bi ADN kate hartzen ditu sarrera gisa, haien kate osagarriak kalkulatzen ditu, eta bi kateetatik zein den egonkorrena zehazten du, G eta Z baseen kopuruaren arabera (Guanina eta Zitosina, hurrenez hurren).

#include <stdio.h>
#include <stdlib.h>
#define N 100

void katea_eskatu(char adn_katea[]);
void kate_osagarria(char adn_katea[], char kate_osag[]);
int g_z_kopurua(char katea[]);
int egonkortasun(char katea1[], char katea2[]);

int main() {
    char adn_katea1[N], kate_osag1[N], adn_katea2[N], kate_osag2[N];
    int egonkor;
    char erantzuna;
    do {
        katea_eskatu(adn_katea1);
        kate_osagarria(adn_katea1, kate_osag1);
        printf("Kate horren osagarria honako hau da: %s\n", kate_osag1);
        katea_eskatu(adn_katea2);
        kate_osagarria(adn_katea2, kate_osag2);
        printf("Kate horren osagarria honako hau da: %s\n", kate_osag2);
        egonkor = egonkortasun(adn_katea1, adn_katea2);
        if (egonkor != 0) {
            printf("\n%d. ADN molekula egonkorragoa da", egonkor);
        }
        else {
            printf("\nADN molekula biek egonkortasun berdina dute");
        }
        do {
            printf("\n\nKontsulta errepikatu nahi duzu (b/e)?");
            fflush(stdin);
            scanf("%c", &erantzuna);
            if (erantzuna != 'b' && erantzuna != 'B' && erantzuna != 'e' && erantzuna != 'E') {
                printf("Erantzuna ez da zuzena.");
            }
        } while (erantzuna != 'b' && erantzuna != 'B' && erantzuna != 'e' && erantzuna != 'E');
    } while (erantzuna == 'b' || erantzuna == 'B');
    return 0;
}

void katea_eskatu(char adn_katea[]) {
    printf("Sartu ADN katea: ");
    fflush(stdin);
    gets(adn_katea);
}

void kate_osagarria(char adn_katea[], char kate_osag[]) {
    int i = 0;
    while (adn_katea[i] != '\0') {
        if (adn_katea[i] == 'A') {
            kate_osag[i] = 'T';
        }
        else if (adn_katea[i] == 'T') {
            kate_osag[i] = 'A';
        }
        else if (adn_katea[i] == 'G') {
            kate_osag[i] = 'Z';
        }
        else {
            kate_osag[i] = 'G';
        }
        i++;
    }
    kate_osag[i] = '\0';
}

int g_z_kopurua(char katea[]) {
    int kop = 0, i = 0;
    while (katea[i] != '\0') {
        if ((katea[i] == 'G') || (katea[i] == 'Z')) {
            kop++;
        }
        i++;
    }
    return (kop);
}

int egonkortasun(char katea1[], char katea2[]) {
    int kop1, kop2, emaitza;
    kop1 = g_z_kopurua(katea1);
    kop2 = g_z_kopurua(katea2);
    if (kop1 > kop2) {
        emaitza = 1;
    }
    else {
        if (kop2 > kop1) {
            emaitza = 2;
        }
        else {
            emaitza = 0;
        }
    }
    return (emaitza);
}

Funtzioen Azalpena

• katea_eskatu(char adn_katea[]): Erabiltzaileari ADN kate bat eskatzen dio.
• kate_osagarria(char adn_katea[], char kate_osag[]): ADN kate baten kate osagarria kalkulatzen du (A->T, T->A, G->Z, Z->G).
• g_z_kopurua(char katea[]): Kate batean dauden G eta Z baseen kopurua kalkulatzen du.
• egonkortasun(char katea1[], char katea2[]): Bi ADN kateen egonkortasuna konparatzen du G eta Z kopuruaren arabera.
• main(): Bi ADN kate eskatzen ditu, haien kate osagarriak eta egonkortasuna kalkulatzen ditu, eta emaitzak bistaratzen ditu.

Edari Makina Simulagailua

Programa honek edari makina baten funtzionamendua simulatzen du. Erabiltzaileak edariaren prezioa eta sartutako diru kopurua sartzen ditu, eta programak itzuli beharreko dirua kalkulatzen du, erabilgarri dauden txanponak kontuan hartuta.

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

void hasieratu(int taula1[], int taula2[]);
int eskatu_dirua(int prezioa);
int eskatu_zenbatekoa();
int txanponak_zenbatu(int kenketa, int txanpon);

int main() {
    int txanponak[8] = { 200, 100, 50, 20, 10, 5, 2, 1 };
    int izakinak[8];
    int dirua, prezioa, kenketa, i, txanpon, zenbat, guztira, geratzen_dira;
    char eran;
    hasieratu(txanponak, izakinak);
    do {
        prezioa = eskatu_zenbatekoa();
        dirua = eskatu_dirua(prezioa);
        kenketa = dirua - prezioa;
        printf("\nKANBIOAK:\n");
        i = 0;
        guztira = 0;
        while (kenketa > 0 && i < 8) {
            txanpon = txanponak[i];
            if (izakinak[i] > 0) {
                zenbat = txanponak_zenbatu(kenketa, txanpon);
                if (zenbat > 0) {
                    geratzen_dira = izakinak[i];
                    if (geratzen_dira >= zenbat) {
                        geratzen_dira = geratzen_dira - zenbat;
                    }
                    else {
                        zenbat = geratzen_dira;
                        geratzen_dira = 0;
                    }
                    izakinak[i] = geratzen_dira;
                    guztira = guztira + zenbat;
                    printf("%d zentimotako %d txanpon.\n", txanpon, zenbat);
                    kenketa = kenketa - zenbat * txanpon;
                }
            }
            i++;
        }
        printf("Guztira, %d txanpon.\n", guztira);
        if (kenketa > 0) {
            printf("Txanponak agortu dira. Zorra: %d zentimo.\n", kenketa);
        }
        printf("\nBeste edaririk nahi ahal duzu? (b/e): ");
        fflush(stdin);
        scanf("%c", &eran);
    } while (eran == 'b');
    printf("\n\n");
    printf("\nSakatu tekla bat amaitzeko...");
    getch();
    return 0;
}

void hasieratu(int taula1[], int taula2[]) {
    int i, zenbat;
    printf("Ongietorri Vending24H-ra.\n");
    printf("Izakinen array-a hasieratzen:\n");
    for (i = 0; i < 8; i++) {
        printf("%d zentimotako zenbat txanpon ditugu?", taula1[i]);
        scanf("%d", &zenbat);
        taula2[i] = zenbat;
    }
}

int eskatu_dirua(int prezioa) {
    int dirua;
    do {
        printf("Sartutako diru-kopurua tekleatu zentimotan: ");
        scanf("%d", &dirua);
        if (dirua <= 0) {
            printf("Diru-kopuru okerra, 0 baino handiagoa izan behar du.\n");
        }
        else if (dirua < prezioa) {
            printf("Diru-kopurua ez da nahikoa.\n");
        }
    } while (dirua <= 0 || dirua < prezioa);
    return (dirua);
}

int eskatu_zenbatekoa() {
    int prezioa;
    do {
        printf("\nEdariaren zenbateko zehatza tekleatu zentimotan: ");
        scanf("%d", &prezioa);
        if (prezioa <= 0) {
            printf("Zenbateko okerra, 0 baino handiagoa izan behar du.\n");
        }
    } while (prezioa <= 0);
    return (prezioa);
}

int txanponak_zenbatu(int kenketa, int txanpon) {
    int zenbat = 0;
    if (kenketa >= txanpon) {
        zenbat = kenketa / txanpon;
    }
    return (zenbat);
}

Funtzioen Azalpena

• hasieratu(int taula1[], int taula2[]): Txanpon mota bakoitzeko izakinak hasieratzen ditu.
• eskatu_dirua(int prezioa): Erabiltzaileak sartutako diru kopurua eskatzen eta balioztatzen du.
• eskatu_zenbatekoa(): Edariaren prezioa eskatzen eta balioztatzen du.
• txanponak_zenbatu(int kenketa, int txanpon): Txanpon mota jakin batetik zenbat txanpon itzuli behar diren kalkulatzen du.
• main(): Edari makinaren logika nagusia inplementatzen du.

Diru Kutxaren Konbinazioak

Programa honek diru kutxa bat irekitzeko bi biraketa-sekuentzia hartzen ditu sarrera gisa, eta bi sekuentziek baliozko konbinazio bat osatzen duten ala ez zehazten du. Baliozko konbinazio bat izateko, bi sekuentziek posizio kopuru bera ibili behar dute.

#include <stdlib.h>
#include <stdio.h>
#define MAX 9
#define TRUE 1
#define FALSE 0

void sekuentzia_eskatu(int seq[]);
int ibilitako_posizioak(int seq[]);
int baliozko_konbinazioa(int seq1[], int seq2[]);

int main() {
    int seq1[MAX], seq2[MAX];
    sekuentzia_eskatu(seq1);
    sekuentzia_eskatu(seq2);
    if (baliozko_konbinazioa(seq1, seq2) == TRUE) {
        printf("\nAurreko bi biraketa-sekuentziek baliozko konbinazioa osatzen dute.\n");
    }
    else {
        printf("\nAurreko bi biraketa-sekuentziek osatzen duten konbinazioa ez da baliozko konbinazio bat.\n");
    }
    system("PAUSE");
    return 0;
}

int baliozko_konbinazioa(int seq1[], int seq2[]) {
    int kont1, kont2;
    kont1 = ibilitako_posizioak(seq1);
    kont2 = ibilitako_posizioak(seq2);
    if (kont1 == kont2) {
        return (TRUE);
    }
    else {
        return (FALSE);
    }
}

int ibilitako_posizioak(int seq[]) {
    int kont = 0, i = 1, oraingoa;
    int aurrekoa = seq[0];
    while (i < MAX && seq[i] != 0) {
        if (seq[i] < 0) {
            oraingoa = seq[i] * -1;
            if (oraingoa < aurrekoa) {
                kont = kont + (aurrekoa - oraingoa);
            }
            else {
                kont = kont + aurrekoa + (60 - oraingoa);
            }
            aurrekoa = -1 * seq[i];
        }
        else {
            oraingoa = seq[i];
            if (oraingoa > aurrekoa) {
                kont = kont + (oraingoa - aurrekoa);
            }
            else {
                kont = kont + (60 - aurrekoa) + oraingoa;
            }
            aurrekoa = seq[i];
        }
        i++;
    }
    return (kont);
}

void sekuentzia_eskatu(int seq[]) {
    int egokia, i;
    do {
        i = 0;
        egokia = TRUE;
        printf("\nSartu biraketa-sekuentzia egokia: ");
        do {
            scanf("%d", &seq[i]);
            i++;
        } while ((i < MAX) && (seq[i - 1] != 0));
        if (seq[0] % 2 != 0 || seq[0] < 0) {
            egokia = FALSE;
        }
        for (i = 1; (i < MAX) && (seq[i] != 0) && (egokia == 1); i++) {
            if ((seq[i] < -60) || (seq[i] > 60)) {
                egokia = FALSE;
            }
            else if ((i % 2 == 0) && (seq[i] < 0)) {
                egokia = FALSE;
            }
            else if ((i % 2 != 0) && (seq[i] > 0)) {
                egokia = FALSE;
            }
            if (abs(seq[i]) == abs(seq[i - 1]) && i != (MAX - 1)) {
                if (seq[i + 1] != 0) {
                    egokia = FALSE;
                }
            }
        }
        if (egokia == FALSE) {
            printf("\nBiraketa-sekuentzia DESEGOKIA da.\n");
        }
    } while (egokia == FALSE);
}

Funtzioen Azalpena

• sekuentzia_eskatu(int seq[]): Erabiltzaileari biraketa-sekuentzia bat eskatzen dio eta balioztatzen du.
• ibilitako_posizioak(int seq[]): Biraketa-sekuentzia batek ibilitako posizio kopurua kalkulatzen du.
• baliozko_konbinazioa(int seq1[], int seq2[]): Bi biraketa-sekuentziek baliozko konbinazio bat osatzen duten ala ez egiaztatzen du.
• main(): Bi biraketa-sekuentzia eskatzen ditu, baliozko konbinazioa den ala ez egiaztatzen du, eta emaitza bistaratzen du.