Gyakorlat, 2. hét: egyszerű programok

Írj C programot, amely kér a felhasználótól egy számot, és kirajzol egy + és - jelekből álló szakaszt! Pl. ha a szám 4, akkor a képernyőn a lenti ábra jelenjen meg, a belsejében 4 darab - legyen:

Mekkora legyen a szakasz?
4
+----+

A feladat megoldására 7 perc áll rendelkezésre.

#include <stdio.h>

int main(void) {
    int hossz;
    printf("Mekkora legyen a szakasz?\n");
    scanf("%d", &hossz);

    printf("+");
    for (int i = 0; i < hossz; i += 1)
        printf("-");
    printf("+");

    return 0;
}

Helyesség:
1p  Program kerete: include, int main, return 0 (ez utóbbi elmaradhat).
    Csak akkor jár, ha a feladatot oldja meg, pl. "helló világ" nem.
1p  Adat bekérése, scanf helyes használata (& ne maradjon le!)
1p  A szakasz elején és végén lévő + karakterek megvannak
1p  Ciklus szervezése: számláló inicializálása, feltétel, léptetés
1p  Ciklusmagban - kiírása, helyes darabszám (nem több, nem kevesebb)
Szépség:
1p  Vezérlési szerkezet: a + karakterek cikluson kívül vannak kiírva,
    nem a cikluson belül if-fel kiválasztva (mivel pontosan 1-1 darab
    kell, és pontosan lehet tudni, hol)
1p  A kód esztétikája:
    a) indentálva a ciklustörzs,
    b) a hossz változó neve utal a szerepre (hossz, h, l, len, n, db...)
    c) rendeltetésszerű ciklushasználat, pl. nincs külön sorban írt i=0
       miatt "lyukas", hiányos for (; i<hossz; i+=1)

···o
··ooo
·ooooo
ooooooo

A megoldás elve

A feladat megoldásának kulcsa egy rajz készítése… És annak meghatározása, hogy melyik sorban hány golyó és hány szóköz van. Aki ide eljut, annak nyert ügye van.

• Minden sor egyforma: sok szóköz, aztán sok golyó. A rajzon pötty helyettesíti a kiírandó szóközöket.
• Egy sor kiírása: ciklusban szóköz, ciklusban golyó. Aztán új sor kezdése.
• Ha ez megvan, ezt kell ciklusba tenni, ami a sorokon fut végig.

#include <stdio.h>

int main(void) {
    int magas;
    printf("Milyen magas legyen a kupac? ");
    scanf("%d", &magas);

    /* sorok ciklusa */
    for (int sor = 0; sor < magas; sor = sor+1) {
        /* a sor elejen kell valamennyi szokoz */
        for (int x = 0; x < magas-sor-1; x = x+1)
            printf(" ");
        /* utana valahany darab o */
        for (int x = 0; x < sor*2+1; x = x+1)
            printf("o");
        /* sor vege */
        printf("\n");
    }

    return 0;
}

A megoldás elve

• Addig kell végezni a kísérletezést – osztogatást, amíg 1-hez nem jutunk. Egy while (szam != 1)-ünk máris van!
• Ha osztható a szám, elosztjuk, kiírjuk. Ha nem osztható, másik osztót kell keresni.
• Növekvő sorban kell haladni az osztók vizsgálatával.
• Baj, ha megpróbálunk összetett számmal osztani (pl. 4-gyel, 6-tal)? Miért?

C-ben a % operátorral jelöljük az osztás maradékát (osztandó%osztó → maradék, pl. 9%7 értéke 2). Ezzel tudunk oszthatóságot vizsgálni.

A lenti megoldás mindig egy egész sort ír ki, pl. 150|2. Egy kiírás akkor történik meg, amikor az oszthatóságot már megvizsgáltuk, és a maradék nullának adódott. A 150|2 azt jelenti, hogy a 150-et osztjuk el 2-vel; ezért a konkrét osztás előtt írjuk ki a sort, hogy még az osztás előtti szám látszódjon. Így aztán az utolsó sort, amelyben az 1-es van, külön utasítással kell kiírni.

#include <stdio.h>

int main(void) {
    int szam;
    printf("Melyik számot? ");
    scanf("%d", &szam);

    int oszto;
    oszto = 2;
    while (szam > 1) {
        if (szam % oszto == 0) { /* ha osztható */
            printf("%5d|%d\n", szam, oszto);
            szam = szam / oszto;
        }
        else
            oszto = oszto + 1;  /* ha nem */
    }
    printf("%5d\n", 1);

    return 0;
}

Esetleg van, akinek jobban tetszik a következő megoldás: mindig kiírjuk előre a számot, amit osztani fogunk, és az oszthatóság vizsgálata után már csak az osztót. Ez is helyes megoldás. Ilyenkor az eredeti számot ki kell írni a ciklus előtt külön. A végén viszont az 1-et nem, mert az a legutolsó osztásnál megjelenik:

#include <stdio.h>

int main(void) {
    int szam;
    printf("Melyik számot? ");
    scanf("%d", &szam);

    int oszto;
    oszto = 2;
    printf("%5d|", szam);
    while (szam > 1) {
        if (szam % oszto == 0) { /* ha osztható */
            printf("%d\n", oszto);
            szam = szam / oszto;
            printf("%5d|", szam);
        }
        else
            oszto = oszto + 1; /* ha nem */
    }

    return 0;
}

Érdemes elgondolkozni azon, hogy jobb lenne-e előbb meghatározni a prímszámokat, hogy csak azokkal kelljen osztani. Mennyivel lenne hatékonyabb az a program?

A megoldás elve

• Csökkenő sorrendben kell haladni.
• Amit kiírtunk, azt levonhatjuk egy változóból. pl. 89 esetén a 80 (LXXX) kiírása után olyan, mintha eredetileg is csak 9 lett volna a kiírandó szám.

Rajzoljunk folyamatábrát vagy struktogramot a programhoz! Először írjunk pár példát római számra, és figyeljük meg, milyen sorrendben kell kiírni az egyes értékeket jelző betűket és betűpárokat! Vegyük észre, hogy az XC (90) csak egyszer szerepelhet, míg pl. az X (10) többször is!

#include <stdio.h>

int main(void) {
    int x;

    printf("Mi a szám? ");
    scanf("%d", &x);
    if (x < 1)
        printf("Pozitiv szamot kerek!\n");
    else if (x > 99)
        printf("Csak 99-ig tudom.\n");
    else {
        if (x >= 90) { printf("XC"); x = x-90; }
        if (x >= 50) { printf("L"); x = x-50; }
        if (x >= 40) { printf("XL"); x = x-40; }
        while (x >= 10) { printf("X"); x = x-10; }
        if (x >= 9) { printf("IX"); x = x-9; }
        if (x >= 5) { printf("V"); x = x-5; }
        if (x >= 4) { printf("IV"); x = x-4; }
        while (x >= 1) { printf("I"); x = x-1; }
        printf("\n");
    }

    return 0;
}

Lehetne máshogy is? Mi történne, ha mindenhol ciklust használnánk? Láthatóan mindegyik számjegynél ugyanazt kell csinálni (kiírni és csökkenteni), ezért aztán a program egy nagy sorminta lett. Egy későbbi gyakorlaton majd javítunk ezen, most egyelőre még hiányzik hozzá a megfelelő C nyelvi eszköz.

Az okos megoldás itt az, ha rájövünk, hogy végülis ezek a számok úgy alakulnak ki, hogy 10-től 99-ig számolunk, és minden szám mellé odaírjuk még egyszer az első számjegyet (pl. 10 mellé az 1-et, 101, vagy 57 mellé az 5-öt, 575). Érdemes ehhez két egymásba ágyazott ciklust írni. Az első számjegy nem lehet 0-s, a második, középső viszont igen, erre figyelni kell.

Megfigyelhetjük azt, hogy mindkét ciklus számlálásos jellegű: a külső 1-től 9-ig megy, a belső 0-tól 9-ig. Az alsó ábra egy nem szabályos, de nagyon szemléletes rajzot tartalmaz. Hasonlítsuk össze a két megoldást áttekinthetőség szempontjából!

#include <stdio.h>

int main(void) {
    int a, b;

    a = 1;
    while (a < 10) {
        b = 0;
        while (b < 10) {
            /* aba: tükörszám! */
            printf("%d%d%d ", a, b, a);
            b = b + 1;
        }
        a = a + 1;
    }

    return 0;
}

#include <stdio.h>

int main(void) {
    for (int a = 1; a <= 9; a = a + 1)
        for (int b = 0; b <= 9; b = b + 1)
            printf("%d%d%d ", a, b, a);

    return 0;
}

#include <stdio.h>

int main(void)
{
    double tipp = 1;
    double delta = 0.1;
    for (int i = 1; i <= 10; i = i+1) {
        while (tipp*tipp < 2) {
            tipp = tipp + delta;
        }
        tipp = tipp - delta;   /* miért? */
        delta = delta / 10;
    }
    printf("%.10f",tipp);

    return 0;
}