2. hét: logika, sorozatok, tömbök

Az egyes szabályok megfelelői:

1. marha || sonka || pulyka,
2. (marha && !sonka) || (!marha && sonka), ami egyébként marha ⊕ sonka XOR kapcsolatnak felel meg,
3. !pulyka || sajt, mert ha nincs benne pulyka, akkor mindegy, van-e sajt, viszont ha van benne pulyka (tehát !pulyka hamis), akkor muszáj lennie benne sajtnak.

Tehát a végleges szabály:
(marha || sonka || pulyka) && ((marha && !sonka) || (!marha && sonka)) && (!pulyka || sajt)

Az egyes szabályok:

1. !(szegfubors && szerecsendio), ez épp akkor lesz hamis, ha mindkét változó igaz (ha egyszerre használnánk őket),
2. (szerecsendio && fahej) || (!szerecsendio && !fahej), mert az is jó, ha mindkettő van, és az is, ha egyik sem: „akkor és csak akkor”.

A végleges szabály:
!(szegfubors && szerecsendio) && ((szerecsendio && fahej) || (!szerecsendio && !fahej))

Alex: (!o && !p) || (o && p),
Beth: p && !s,
Chris: (p && s && !o) || (p && !s && o) || (!p && s && o).
Kombinálva: ((!o && !p) || (o && p)) && (p && !s) && ((p && s && !o) || (p && !s && o) || (!p && s && o)).
Egyszerűsítve (az igazságtábla alapján is ellenőrizhető): p && !s && o.

A preferenciák logikai kifejezéssel:

• 1. vásárló: bacon && !salata && !paradicsom, mert nem elég csak azt mondani, hogy legyen benne bacon, azt is kell mondani, hogy a másik két összetevő nincs.
• 2. vásárló: !paradicsom || salata, mert ha van paradicsom, a kifejezés első fele hamis lesz, ilyenkor a második fele: salata muszáj igaz legyen, hogy az egész igaz tudjon lenni; ha pedig nincs paradicsom, az első fele mindenképp igaz, tehát lehet benne salata, de az se baj, ha nincs.
• 3. vásárló: !(bacon && salata), mert ha mindkettő van, a belső részkifejezés igaz lesz, és pont azt nem szereti, tehát tagadjuk.
• 4. vásárló: !paradicsom && !salata, mert egyik sem teljesülhet.

1. feladat. Meg kell fordítani a négyzetest, mert ha nem páratlan számot találunk a másik oldalán, akkor az megsérti a szabályt. Meg kell fordítani a hatost is, mert ha négyzet van a másik oldalán, a páros számával sérti a szabályt. A logikai kifejezés pedig !negyzet || paros.

2. feladat. A sört ivóról és a 16 évesről.

• A sört ivóról tudnia kell, elmúlt-e 18.
• Aki kólát iszik, bárhány éves lehet, nem szegi meg a tilalmat.
• Aki 25 éves, bármit ihat.
• Aki 16 éves, nem ihat sört – róla tudnia kell, mit iszik.

A két feladat matematikailag tökéletesen egyforma. Egyformák lettek a megoldásaid is?

#include <stdio.h>

int main(void) {
    char c;

    /* egyesevel a karakterek */
    while (scanf("%c", &c)==1) {
        /* ez a ketto specialis, mert "tulpordul" */
        if (c=='z') {
            c = 'a';
        }
        else if (c=='Z') {
            c = 'A';
        }
        else {
            /* tovabbi kodolando betuk: a..z és A..Z. C-ben:
               HA (if) a) a és z kozott van VAGY (||) b) A es Z kozott van */
            if ((c>='a' && c<'z') || (c>='A' && c<'Z'))
                c = c+1;
            /* tobbi valtozatlanul marad. */
        }
        printf("%c", c);
    }
    
    return 0;
}

#include <stdio.h>

int main(void) {
    char betu;
    while (scanf("%c", &betu)==1) {
        printf("%c", betu);
        /* Ha magánhangzó */
        if (betu=='a'||betu=='e'||betu=='i'||betu=='o'||betu=='u')
            printf("v%c", betu);  /* Írunk egy v-t és újból a karaktert */
    }

    return 0;
}

Sokféle megoldás lehet, hiszen az egyes feltételek megfogalmazhatóak úgy is, hogy egymást kizárják. Az egyik lehetséges változat, amely képes az érvénytelen pontszámot is jelezni:

#include <stdio.h>

int main(void) {
    int pont;
    printf("Hany pontos a dolgozat? ");
    scanf("%d", &pont);

    if (pont>=0 && pont<=23)
        printf("Elegtelen");
    if (pont>=24 && pont<=32)
        printf("Elegseges");
    if (pont>=33 && pont<=41)
        printf("Kozepes");
    if (pont>=42 && pont<=50)
        printf("Jo");
    if (pont>=51 && pont<=60)
        printf("Jeles");
    if (pont<0 || pont>60)      /* itt || kell! */
        printf("Ervenytelen pontszam");

    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    for (int szam = 1; szam <= 20; szam += 1) {
        bool harommal = szam%3 == 0;
        bool ottel = szam%5 == 0;
        if (harommal) {
            if (ottel)
                printf("fizzbuzz\n");
            else
                printf("fizz\n");
        } else {
            if (ottel)
                printf("buzz\n");
            else
                printf("%d\n", szam);
        }
    }

    return 0;
}

Az nem baj, ha az alapot tároló változó értéke elveszik. Ha a kitevő páros, éppen azt kell négyzetre emelni.

#include <stdio.h>

int main(void) {
    for (int i = 0; i < 16; i += 1) {
        double alap = 2;
        double hatvany;
        int kitevo = i;

        hatvany = 1;
        while (kitevo > 0) {
            if (kitevo % 2 == 1) {
                hatvany = hatvany * alap;
                kitevo--;
            } else {
                alap = alap * alap;
                kitevo/=2;
            }
        }

        printf("%g\n", hatvany);
    }

    return 0;
}

#include <stdio.h>

int main(void) {
    int szam1, szam2;
    printf("Egyik szam? ");
    scanf("%d", &szam1);
    printf("Masik szam? ");
    scanf("%d", &szam2);

    int lnko = 1;     /* ez mindennek osztoja :) */
    int oszto = 2;    /* legkisebb szam, amivel osztunk */
    while (szam1 > 1 && szam2 > 1) {
        /* amig mindkettonek osztoja */
        while (szam1%oszto==0 && szam2%oszto==0) {
            /* addig ez tenyezo, felszorozzuk */
            lnko *= oszto;
            szam1 /= oszto;
            szam2 /= oszto;
        }
        /* ha kijottunk a fenti ciklusbol, valamelyiknek
           nem osztoja mar. mindegy, melyiknek; a masikat
           osztogassuk le. a ket ciklus kozul az egyik
           olyan lesz, amibe egyszer sem megy be! */
        while (szam1 % oszto == 0)
            szam1 /= oszto;
        while (szam2 % oszto == 0)
            szam2 /= oszto;

        oszto += 1;
    }

    printf("LNKO: %d\n", lnko);

    return 0;
}

#include <stdio.h>

int main(void) {
    /* a ket szamot kerjuk a felhasznalotol */
    int a, b;
    printf("a="); scanf("%d", &a);
    printf("b="); scanf("%d", &b);

    int oszto = 2;
    int lkkt = 1;
    /* amig valamelyik meg nem egy */
    while (a>1 || b>1) {
        /* ha mindkettonek osztoja, felszorozzuk */
        while (a%oszto==0 && b%oszto==0) {
            lkkt *= oszto;
            a /= oszto;
            b /= oszto;
        }
        /* ha valamelyiknek osztoja, akkor is felszorozzuk */
        while (a%oszto==0) {
            lkkt *= oszto;
            a /= oszto;
        }
        while (b%oszto==0) {
            lkkt *= oszto;
            b /= oszto;
        }
        oszto += 1;
    }

    printf("LKKT: %d\n", lkkt);

    return 0;
}

#include <stdio.h>

int main(void) {
   /* Méret beolvasása */
   int meret;
   printf("Mekkora legyen? ");
   scanf("%d", &meret);

   printf("lada atloval, csak 2 ciklus\n");
   for (int y = 1; y <= meret; y += 1) {
      for (int x = 1; x <= meret; x += 1)
         /* Feltétel a 4 sarokpontra */
         if ((x==1 && (y==1 || y==meret)) || (x==meret && (y==1 || y==meret)))
            printf("+");
         else
            /* Feltétel a vízszintes oldalakra */
            if (y==1 || y==meret)
               printf("-");
            else
               /* Feltétel a függőleges oldalakra */
               if (x==1 || x==meret)
                  printf("|");
               else
                  /* Feltétel az átlóra */
                  if (x==y)
                     printf("\\"); /* A backslash spec. jelentése miatt duplán kell írni */
                  else
                     printf(" ");
      printf("\n");
   }

   return 0;
}

Amikor karaktert kell beolvasni, a feladattól függően érdemes a scanf()-et scanf("%c", &betu) helyett scanf(" %c", &betu) formában használni, azaz tenni egy szóközt a %c elé. Ennek hatására a scanf() eldobja a kapott szóköz és újsor (enter) karaktereket, és megvárja az első nem szóközt. Erre azért van szükség, mert karakterek beolvasásánál alapértelmezés szerint megkapjuk a felhasználó által leütött entereket is.

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

int main(void) {
    /* a két mező koordinátája */
    char o1, s1, o2, s2;

    /* megkérdezzük a felhasználót. */
    /* a scanf-nél a szóközök elnyelik a whitespace karaktereket. */
    printf("Írd be az első mezőt, pl. d6!\n? ");
    scanf(" %c %c", &o1, &s1);
    printf("Írd be a második mezőt, pl. f8!\n? ");
    scanf(" %c %c", &o2, &s2);

    /* a betűkre karakterként (számként) tekintek.
     * mivel ábécé sorban vannak, a számjegyek pedig növekvő
     * sorrendben, ezért kisebb/nagyobb összehasonlítást
     * végezhetek, és kivonhatom őket egymásból. */
    if (o1<'a' || o1>'h' || s1<'0' || s1>'8'
        || o2<'a' || o2>'h' || s2<'0' || s2>'8') {
        printf("Hibás sor- vagy oszlopmegadás!\n");
    } else {
        /* kivételes eset mindegyik figuránál, ha nem
         * lépett sehova (o1==o2 és s1==s2), hiszen az
         * nem is lépés. itt azért szerepel mindegyik
         * kifejezésben, hogy önmagukban is egészt
         * alkossanak. */
        /* a király egyet léphet valamelyik irányba. ez
         * azt jelenti, hogy a sor- és az oszlopugrás
         * távolságának abszolút értéke maximum egy. */
        if (abs(o1-o2)<=1 && abs(s1-s2)<=1 && !(o1==o2 && s1==s2)) {
           printf("Ez szabályos a király számára.\n");
        }
        /* a bástyánál az oszlop- vagy a sor változatlan.
         * de mindkettő nem lehet ugyanaz. */
        if ((o1==o2 || s1==s2) && !(o1==o2 && s1==s2)) {
            printf("Egy bástya léphet így.\n");
        }
        /* a futónál mindkét irányba ugyanannyit kell
         * mozdulni, úgy jön ki az átlós lépés. */
        if (abs(o1-o2)==abs(s1-s2) && !(o1==o2 && s1==s2)) {
            printf("Egy futó számára ez helyes lépés lehet.\n");
        }
        /* a királynő mint a bástya és a futó együtt. */
        if (((o1==o2 || s1==s2) || abs(o1-o2)==abs(s1-s2))
            && !(o1==o2 && s1==s2)) {
            printf("A vezér léphet ilyet.\n");
        }
        /* a huszár nehéznek tűnik, de nem az. az L alak
         * azt jelenti, hogy a vízszintes elmozdulás 1,
         * a függőleges 2, vagy fordítva. */
        if ((abs(o1-o2)==2 && abs(s1-s2)==1)
            || (abs(o1-o2)==1 && abs(s1-s2)==2)) {
            printf("Huszár számára szabályos.\n");
        }
    }

    return 0;
}

Első és második szám bekérése
Ha első > második
    alsó = második, felső = első
Egyébként
    alsó = első, felső = második
A ciklusváltozó legyen alsó
Amíg a ciklusváltozó kisebb vagy egyenlő a felsővel
    Ha a ciklusváltozó páratlan
       Írd ki a ciklusváltozót
    Növeld a ciklusváltozót eggyel

#include <stdio.h>

int main(void) {
    int elso, masodik;
    printf("Elso = ");       scanf("%d", &elso);
    printf("Masodik = ");    scanf("%d", &masodik);

    int also, felso;
    if (elso > masodik) { also = masodik; felso = elso; }
    else { also = elso; felso = masodik; }

    for (int i = also; i <= felso; i = i + 1)
        if (i % 2 == 1)
            printf("%d ",i);

    return 0;
}

Első és második szám bekérése
Ha első > második
    alsó = második, felső = első
Egyébként
    alsó = első, felső = második
Összeg = 0, ciklusváltozó = alsó
Amíg ciklusváltozó kisebb, mint felső
    Ha ciklusváltozó osztható 10-zel
        Összeget növeld ciklusváltozóval
    növeld ciklusváltozót eggyel
Ciklusváltozó = 0
Amíg ciklusváltozó < összeg
    írj ki egy csillagot
    ciklusváltozót növeld eggyel

#include <stdio.h>

int main(void) {
    int elso, masodik;
    printf("Elso = ");       scanf("%d", &elso);
    printf("Masodik = ");    scanf("%d", &masodik);

    int also, felso;
    if (elso > masodik) { also = masodik; felso = elso; }
    else { also = elso; felso = masodik; }

    int sum = 0;
    for (int i = also; i <= felso; i += 1)
        if (i % 10 == 0)
            sum += i;

    for (int i = 0; i < sum; i += 1)
        printf("*");

    return 0;
}

Első és második szám bekérése
Ha első > második
    alsó = második, felső = első
Egyébként
    alsó = első, felső = második
Darabszám = 0, ciklusváltozó = alsó
Amíg ciklusváltozó kisebb, mint felső
    Ha alsó osztható hárommal, de nem osztható öttel
        Darabszám növelése eggyel
    Alsó növelése eggyel

#include <stdio.h>

int main(void) {
    int elso, masodik;
    printf("Elso = ");       scanf("%d", &elso);
    printf("Masodik = ");    scanf("%d", &masodik);

    int also, felso;
    if (elso > masodik) { also = masodik; felso = elso; }
    else { also = elso; felso = masodik; }

    int darab = 0;
    for (int i = also; i <= felso; i = i + 1)
        if (i%3 == 0 && i%5 != 0)
            darab += 1;

    printf("%d ", darab);

    return 0;
}

#include  <stdio.h>
#include  <stdbool.h>

const int boardSize  = 8;
const int squareSize = 3;
const int layersNum  = 5;
const int shiftX = 5;
const int shiftY = 2;

int minimum(int a, int b)
{
    return a < b ? a : b;
}

int getGuess(int coord, int shift)
{
    if (coord >= shift * (layersNum -1))
        return layersNum - 1;
    else
        return coord / shift;
}

int outerBound(int shift, int guess)
{
    return shift * guess + boardSize * squareSize;
}

int getLayer(int x, int y)
{
    int guess = minimum(getGuess(x, shiftX), getGuess(y, shiftY));
    
    return (x >= outerBound(shiftX, guess) || y >= outerBound(shiftY, guess)) ? -1 : guess;
}

bool getColor(int x, int y, int layer)
{
    x -= layer * shiftX;
    y -= layer * shiftY;
    
    x /= squareSize;
    y /= squareSize;
    
    return (x + y) % 2 == 1;
}

int main(void)
{
    int xSize = boardSize * squareSize + (layersNum - 1) * shiftX;
    int ySize = boardSize * squareSize + (layersNum - 1) * shiftY;

    for (int y = 0; y < ySize; printf("\n"), y++)
    {
        for (int x = 0; x < xSize; x++)
        {
            int layer = getLayer(x, y);
            if (layer == -1)
                printf(" ");
            else
                printf("%c", getColor(x, y, layer) ? 'a' + layer : 'A' + layer);
        }
    }
    
    return 0;
}

Ha használtál if-et, rosszul csinálod – van egyszerűbb megoldás is!

#include <stdio.h>

int main(void) {

    /* első */
    int szam;
    printf("Szam vagy 0? ");
    scanf("%d", &szam);

    int szorzat = 1;
    while (szam != 0) {
        szorzat *= szam;
        /* többi */
        printf("Szam vagy 0? ");
        scanf("%d", &szam);
    }

    printf("Szorzatuk: %d\n", szorzat);

    return 0;
}

Vegyük észre, hogy ehhez nem kell tömb! Továbbá azt is észre kell venni, hogy az első számot némileg speciálisnak kell tekinteni. Fel kell tételezni, hogy az is marad a legkisebb; majd később legfeljebb találunk még kisebbet. De az ilyen int min=100000000-szerű megoldás elvi hibás!

Az osztók összegzéséről egyből eszünkbe juthat az összegzés tétele: ciklus a számokon, akkumulátor változóban összegzés. Az összeghez azonban nem mindegyik számot kell hozzáadni, hanem csak az osztókat, vagyis válogatunk közülük. A kiválogatás tétele hasonlít a számláláshoz: ha egy feltétel teljesül, akkor csinálunk valamit a számmal:

CIKLUS AMÍG van még szám, ADDIG
    szám = következő elem
    HA feltétel(szám), AKKOR
       KIÍR: szám
    FELTÉTEL VÉGE
CIKLUS VÉGE

#include <stdio.h>

int main(void) {
    int szam;
    printf("Szam: ");
    scanf("%d", &szam);

    int osztoosszeg = 0;
    /* oszto>szam/2 mar nincsen (csak sajat maga lenne) */
    for (int oszto = 1; oszto <= szam / 2; oszto += 1)
        if (szam % oszto == 0)
            osztoosszeg += oszto;

    if (osztoosszeg == szam)
        printf("Ez egy tokeletes szam.\n");
    else
        printf("Nem tokeletes szam, %d != %d.\n", szam, osztoosszeg);

    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int n;
    printf("Max = ");
    scanf("%d",&n);

    printf("1\n");
    for (int i = 2; i < n; i += 1) {
        bool prim = true;
        for (int j = 2; j < i; j += 1)
            if (i%j == 0)
                prim = false;
        if (!prim)
            printf("%d\n",i);
    }

    return 0;
}

#include <stdio.h>

int main(void) {
    int n;
    printf("Max=");
    scanf("%d", &n);

    printf("1\n");
    for (int i = 2; i < n; i += 1) {
        int sum = 0;
        for (int j = 1; j < i; j += 1)
            if (i%j == 0)
                sum += j;
        if (sum == i)
            printf("%d\n",i);
    }

    return 0;
}

Tipp: ha ciklusban ciklust alkalmaztál, próbáld meg egyszerűsíteni a megoldásodat. Elég egyetlen egy ciklus!

#include <stdio.h>

int main(void) {
    double e = 0;
    double fact = 1;
    for (int i = 1; i < 20; i = i+1) {
        e += 1/fact;  /* Hozzáadjuk e-hez */
        fact *= i;    /* Faktoriális közben itt keletkezik */
    }

    printf("e = %f",e);  /* Kiírjuk */

    return 0;
}

#include <stdio.h>

int main(void) {
    double pi = 1;
    for (int i = 2; i<10000; i += 2) /* kettesével */
        pi *= i*i / ((i-1)*(i+1));   /* a képlet */
    pi *= 2;                         /* végén *2, mert pi/2 állt elő */

    printf("%f", pi);

    return 0;
}

#include <stdio.h>

int main(void) {
    /* Ciklus ami páronként halad, azaz egy */
    /* lépésben hozzáad és ki is von egy számot */
    double pi = 0;
    int i = 1;
    while (i<100000) {
        pi += 1.0/i;  /* Hozzáadjuk a píhez az aktuális szám reciprokát */
        i += 2;       /* Kettővel megnöveljük az aktuális számot */
        pi -= 1.0/i;  /* Levonjuk a szám reciprokát */
        i += 2;       /* Kettővel megnöveljük a számot */
    }

    pi *= 4;  /* A ciklus a pi/4-et közelítette, ezért 4-el szorozni kell */

    printf("%f", pi);  /* Eredmény kiírása */

    return 0;
}

Darabszám bekérése
Összeg = 0
Ciklusváltozó = 0
Amíg ciklusváltozó kisebb, mint a darabszám
    Kérd be a következő számot
    Ha a ciklusváltozó 0, a maximum legyen egyenlő a számmal
    Egyébkén
        Ha a szám nagyobb a maximumnál
            A maximum legyen egyenlő a számmal
    Az összeghez add hozzá a számot
Írd ki az összeg és a maximum különbségét

#include <stdio.h>

int main(void) {
    int db;
    printf("Hany db szamot adsz ossze? ");
    scanf("%d", &db);

    int sum = 0;
    int max;
    for (int i = 0; i < db; i = i + 1) {
        int akt;
        printf("A kovetkezo szam: ");
        scanf("%d",&akt);

        if (i == 0) max = akt;
        else if (akt > max) max = akt;

        sum += akt;
    }

    /* a trükk: a teljes összegből levonjuk a legnagyobbat. */
    /* így pont olyan lesz, mintha az kimaradt volna az összegből. */
    printf("Osszeg: %d\n", sum - max);

    return 0;
}

A talált prímeket felesleges eltárolni – egy tömb használata súlyos hiba lenne. Visszafelé kell haladni a kereséssel, és az első találat éppen a keresett prím.

#include <stdio.h>
#include <stdbool.h>

int main(void){
    int szam;
    scanf("%d", &szam);
    if (szam > 2) {
        bool prim = false;
        int proba;
        for (proba = szam-1; proba > 1 && !prim; proba -= 1) {
            prim = true;
            for (int i = 2; i < proba && prim; i += 1)
                if (proba % i == 0)
                    prim = false;
        }
        printf("%d\n", proba + 1);
    }
    return 0;
}

Súlyos hiba lenne itt a beírt számokat eltárolni. A szélsőérték kereséséhez felesleges – mindig csak a legutóbbi (legnagyobb) értékre kell emlékeznie a programnak!

#include <stdio.h>
#include <stdbool.h>

int main(void){
    int szam, max = 0;
    while (scanf("%d", &szam)==1 && szam>0){
        if (szam > max){
            bool prim = true;
            for (int i = 2; i < szam; i += 1)
                if (szam % i == 0)
                    prim = false;
            if (prim)
                max = szam;
        }
    }
    if (max>0)
        printf("Max = %d\n",max);
    return 0;
}

Itt is súlyos hiba lenne a szöveget eltárolni. Ahogy jött egy karakter, el lehet dönteni, ki kell-e írni. A kiírás után nem is kell rá emlékezni.

#include <stdio.h>

int main(void) {
    char ch;
    int sorszam = 1;
    while (scanf("%c", &ch)==1 && ch!='.') {
        int i;
        for (i = 2; sorszam%i!=0 && i<sorszam; i += 1)
            /*üres*/;
        if (sorszam == i)
            printf("%c", ch);
        sorszam++;
    }
    return 0;
}

A megtalált osztókat felesleges eltárolni, csak az összegre vagyunk kíváncsiak. Ezért tömböt használni hiba lenne.

#include <stdio.h>

int main(void){
    int szam;
    scanf("%d",&szam);

    /* Osztók sszege */
    int osszeg = 0;
    for (int i = 1; i <= szam; i += 1)
        if (szam % i == 0)
            osszeg += i;

    /* Prím-e */
    int i;
    for (i = 2; i < osszeg && osszeg % i != 0; i += 1)
        ; /* üres */
    if (i == osszeg)
        printf("Osszeg: %d, prim\n", osszeg);
    else
        printf("Osszeg: %d, nem prim\n", osszeg);

    return 0;
}

#include <stdio.h>

int main(void) {
    int tomb[10] = { 25, 69, 54, 8, 77, 6, 29, 10, 3, 98 };

    /* Kiírás */
    printf("A tömb:");
    /* első elem */
    printf(" %d", tomb[0]);
    /* többi elem */
    for (int i = 1; i < 10; ++i)
        printf(", %d", tomb[i]);
    printf(".\n");

    return 0;
}

Melyik programozási tételt kell alkalmazni ennek megoldásához? Másképp feltéve a kérdést, mit kell találni a tömbben ahhoz, hogy tudjuk, nem szigmon növekvő?

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    /* Változók */
    int tomb[10] = {1,3,6,9,13,16,19,21,45,56};

    /* Tegyük fel hogy szig.mon.növ. és csökk. */
    bool nov = true, csokk = true;
    /* Ellenőrzés */
    for (int i = 0; i < 10-1; i += 1){
        if (!(tomb[i] < tomb[i+1]))
            nov = false;   /* Nem teljesül a szig.mon.csökk. */
        if (!(tomb[i] > tomb[i+1]))
            csokk = false; /* Nem teljesül a szig.mon.növ. */
    }

    /* Eredmény */
    if (nov)
        printf("szigmon novekvo");
    else
        if (csokk)
            printf("szigmon csokkeno");
        else
            printf("nem szigmon");

    return 0;
}

Melyik programozási tétel kell itt? A meredekségnek mijét kell meghatározni? Vigyázz, a lejtő és az emelkedő ugyanaz, ha másik irányból nézzük, és vigyázz, ne indexeld túl a tömböt!

A printf()-nél a %% jelenti a % jel kiírását.

#include <stdio.h>
#include <math.h>

int main(void) {
    double folyo[18] = { 0.1, 1, 1.5, 1.7, 2, 2.3, 2.8, 4.5, 9.8,
                         12, 14.1, 13, 11.9, 8.7, 6.1, 3.5, 1, 0.5 };

    /* Keresés */
    int max = 0;
    for (int i = 1; i < 18-1; ++i)  /* i+1 indexelés miatt! */
        if (fabs(folyo[i+1] - folyo[i]) > fabs(folyo[max+1] - folyo[max]))
            max = i;

    /* Kiírás */
    printf("A legmeredekebb: max=%d-%d méter között\n", max*2, (max+1)*2);
    printf("A meredekség: %f %%-os\n", fabs(folyo[max+1]-folyo[max])/2*100);

    return 0;
}

A gondolat, hogy „csinálok egy egymillió elemű tömböt, abba biztos belefér majd az összes szám”, elvi hibás. Gondold végig, hogy a feladat megoldásához hány számot kell mindenképpen eltárolni! Szükség van-e ehhez egyáltalán tömbre? Ha igen, akkor mekkorára? Kell-e ehhez tologatni az elemeket a tömbön belül?

#include <stdio.h>

int main(void) {
   double szamok[5], beolv;

   printf("Szám vagy 0? ");      /* első */
   scanf("%lf", &beolv);
   int i = 0;
   while (beolv != 0) {
      szamok[i] = beolv;
      i = (i+1) % 5;               /* 4 után megint 0 */

      printf("Szám vagy 0? ");     /* következő */
      scanf("%lf", &beolv);
   }

   double szum = 0;
   for (int i = 0; i < 5; i += 1)
      szum += szamok[i];

   printf("Utolsó 5 átlaga: %f\n", szum/5);

   return 0;
}

Nem kell n2, csak n(n-1)/2 összehasonlítás, mivel minden párt elég csak egyszer megvizsgálni (ha a=b, akkor b=a is igaz). Ez látszik a programon is: a külső (i-s) ciklus végigmegy az összes elemen, a belső (j-s) ciklus pedig minden i-nél már csak az „összes többit” nézi, i+1-től indul. A külső ciklus nem is megy el az utolsó elemig, hanem az utolsó előtti elem indexe a legvégső, aminél lefut, mert az utolsó elemnél már nem is lenne „összes többi”. Tehát a 10 elemű, 0…9 indexelő tömbre i 0-tól 8-ig, j pedig i+1-től 9-ig fut.

#include <stdio.h>

int main(void) {
    int szamok[10] = { 4, 6, 8, 9, 4, 5, 6, 7, 3, 8 };
    
    printf("Egyformak:\n");
    for (int i = 0; i < 10-1; i += 1)
        for (int j = i+1; j < 10; j += 1)
            if (szamok[i] == szamok[j])
                printf("szamok[%d] == szamok[%d] == %d\n", i, j, szamok[i]);
    
    return 0;
}

Mit kell találni a tömbben ahhoz, hogy tudjuk, nem minden elem különböző? Lásd az előző feladatot!

Jó megoldás lehet az is, ha rendezzük a tömböt, mert akkor az egyforma elemek egymás mellé kerülnek. De vajon mi ennek a hátránya?

Az, hogy különböző emeleteken laknak, csak egy feltétel a sok közül. Próbáld végig programban az összes lehetőséget! A „különböző emeletek” feltétel ellenőrzését úgy is megoldhatod, hogy beteszed az öt változót egy tömbbe, és megnézed, mind különbözőek-e az elemei. Lásd a Mind különböző című feladatot.

Azt kell észrevenni, hogy ez egy szokásos leválogatós feladat. Csak most nem mondjuk az 1...10 számokat, hanem az 'A'...'Z' betűket kell megszámolni. Más a tömb mérete, és más a leképezés – amúgy a program felépítése változatlan.

A tömb méretét könnyű meghatároznunk: 'Z'-'A'+1, az ábécé elejének és végének távolsága, +1, hogy beleszámoljuk mindkét végét.

#include <stdio.h>

int main(void) {
    int t['Z'-'A'+1];

    for (char i = 'A'; i <= 'Z'; i += 1)       /* nullazas */
        t[i-'A'] = 0;

    /* amig sikerul betut beolvasni */
    char cbe;
    while (scanf("%c", &cbe) == 1) {           /* feldolgozas */
        if (cbe >= 'A' && cbe <= 'Z')
            t[cbe-'A'] += 1;
    }

    for (char i = 'A'; i <= 'Z'; i += 1)       /* kiiras */
        printf("%c: %d\n", i, t[i-'A']);

    return 0;
}

#include <stdio.h>

int main(void) {
   int latogato[7] = {0};
   
   int nap, db;
   scanf("%d %d", &nap, &db);
   while (nap != -1) {
      latogato[nap] += db;
      scanf("%d %d", &nap, &db);
   }

   int max = 0;
   for (int x = 1; x < 7; ++x)
      if (latogato[x]>latogato[max])
         max = x;

   printf("%d\n", max);

   return 0;
}

#include <stdio.h>

int main(void) {
   int latogato[7] = {0};
   
   int nap, db;
   scanf("%d %d", &nap, &db);
   while (nap != 0) {
      latogato[nap-1] += db;
      scanf("%d %d", &nap, &db);
   }

   int min = 0;
   for (int x = 1; x < 7; ++x)
      if (latogato[x] < latogato[min])
         min = x;
   printf("%d\n", min+1);

   return 0;
}

#include <stdio.h>

int main(void) {
   int seb_max[24] = {0};
   int ora, perc, seb;

   scanf("%d %d %d", &ora, &perc, &seb);
   while (seb != 0) {
      if (seb > seb_max[ora])
         seb_max[ora] = seb;
      scanf("%d %d %d", &ora, &perc, &seb);
   }

   for (int i = 0; i < 24; i += 1)
      if (seb_max[i] > 0)
         printf("%2d:00-%02d:59 -> %d km/h\n", i, i, seb_max[i]);

   return 0;
}

#include <stdio.h>

int main(void) {
   int birsag[24] = {0};

   int ora, perc, seb;
   scanf("%d %d %d", &ora, &perc, &seb);
   while (seb != 0) {
      if (seb > 180)
         birsag[ora] += 100000;
      else if (seb>140)
         birsag[ora] += 30000;

      scanf("%d %d %d", &ora, &perc, &seb);
   }

   for (int i = 0; i < 24; i += 1)
      printf("%2d:00-%02d:59, %d Ft\n", i, i, birsag[i]);

   return 0;
}

#include <stdio.h>

int main(void) {
   int blicceles[24*2] = {0};

   int ora, perc;
   scanf("%d %d", &ora, &perc);
   while (ora != -1) {
      int i = ora*2;
      if (perc >= 30)
         i += 1;
      blicceles[i] += 1;
      scanf("%d %d", &ora, &perc);
   }

   for (int i = 0; i < 24; i += 1) {
      printf("%2d:00-%02d:29 kozott %d utas\n", i, i, blicceles[i*2]);
      printf("%2d:30-%02d:59 kozott %d utas\n", i, i, blicceles[i*2+1]);
   }

   return 0;
}

#include <stdio.h>

int main(void) {
   int birsag[24] = {0};

   int ora, perc, osszeg;
   char tipus;
   scanf("%d %d %c %d", &ora, &perc, &tipus, &osszeg);
   while (tipus != 'x') {
      if (tipus == 'c')
         osszeg *= 0.8;
      birsag[ora] += osszeg;
      scanf("%d %d %c %d", &ora, &perc, &tipus, &osszeg);
   }

   for (int i = 0; i < 24; i += 1)
      printf("%2d:00-%02d:59, %d Ft\n", i, i, birsag[i]);

   return 0;
}

#include <stdio.h>

int main(void) {
   int atment[4] = {0};
   char csop;

   int p1, p2, p3;
   scanf("%c %d %d %d", &csop, &p1, &p2, &p3);
   while (csop != 'x') {
      int szum = p1+p2+p3;
      if (p1>=2 && p2>=2 && p3>=2 && szum>=12)
         ++atment[csop-'A'];
      scanf("%c %d %d %d", &csop, &p1, &p2, &p3);
   }

   for (char csop = 'A'; csop <= 'D'; ++csop)
      printf("%c %d\n", csop, atment[csop-'A']);

   return 0;
}

#include <stdio.h>

int main(void) {
   int stat[31] = {0};
   
   int p1, p2, p3;
   scanf("%d %d %d", &p1, &p2, &p3);
   while (p1 != -1) {
      int szum = p1+p2+p3;
      ++stat[szum];
      scanf("%d %d %d", &p1, &p2, &p3);
   }

   for (int x = 0; x <= 30; ++x)
      if (stat[x] != 0)
         printf("%2d pontos: %2d db\n", x, stat[x]);

   return 0;
}

#include <stdio.h>

int main(void) {
    int forint[32] = {0}, osszbevetel = 0;

    int kassza, osszeg;
    scanf("%d %d", &kassza, &osszeg);
    while (kassza!=0) {
        forint[kassza-1] += osszeg;
        osszbevetel += osszeg;
        scanf("%d %d", &kassza, &osszeg);
    }

    for (int i = 0; i < 32; i += 1)
        if (forint[i] != 0)
            printf("%2d. kassza, %6d Ft, %f%%.\n",
                i+1, forint[i], 100.0*forint[i]/osszbevetel);

    return 0;
}

#include <stdio.h>

int main(void) {
    int vasarlok[32] = {0}, osszvasarlok = 0;

    int kassza;
    scanf("%d", &kassza);
    while (kassza != 0) {
        vasarlok[kassza-1] += 1;
        osszvasarlok += 1;
        scanf("%d", &kassza);
    }

    int max = 0;
    for (int i = 1; i < 32; i += 1)
        if (vasarlok[i]>vasarlok[max])
            max = i;

    printf("A kedvenc kassza a(z) %d-edik, "
           "a vasarlok %f%%-a ment oda.\n",
        max+1, 100.0*vasarlok[max]/osszvasarlok);

    return 0;
}

#include <stdio.h>
 
int main(void) {
    int gyakorisag['Z'-'A'+1] = {0};
    int osszes = 0;
    
    char c;
    while (scanf("%c", &c) == 1) {
        if (c >= 'A' && c <= 'Z') {
            gyakorisag[c-'A'] += 1;
            osszes += 1;
        }
    }
 
    for (char c = 'A'; c <= 'Z'; c += 1)
        if (gyakorisag[c-'A'] != 0)
            printf("%c: %d db, %f %%.\n",
                c, gyakorisag[c-'A'], 100.0*gyakorisag[c-'A']/osszes);
 
    return 0;
}

#include <stdio.h>

int main(void) {
    int gyakorisag[10] = {0};

    int osszes = 0;
    char c;
    while (scanf("%c", &c) == 1)
        if (c>='0' && c<='9') {
            gyakorisag[c-'0'] += 1;
            osszes += 1;
        }

    int max = 0;
    for (int i = 1; i < 10; i += 1)
        if (gyakorisag[i]>gyakorisag[max])
            max = i;

    printf("Leggyakoribb: %c, %f %%-kal.\n", '0'+max,
        100.0*gyakorisag[max]/osszes);

    return 0;
}

A rand() minden hívása egy új véletlenszámot ad. A fenti, hibás kódrészletben a rand()-ot kétszer hívjuk meg, tehát tulajdonképpen mintha nem egy, hanem két pénzérmét vizsgálnánk: ha az első fej, kiírjuk hogy fej, ha a második írás, kiírjuk, hogy írás. Így aztán az is lehet, hogy mindkét szó kiíródik, de az is, hogy egyik sem. Javítva:

if (rand() % 2 == 0)
    printf("Fej.\n");
else
    printf("Iras.\n");

A gépnek háromféle választása lehet. Ehhez egy véletlenszámot kell sorsolni, amely a 0, 1 vagy 2 értékeket veheti fel. (A 3-mal osztás maradékát figyelve éppen ilyen szám áll elő.)

A véletlenszám sorsolása után érdemes a 0, 1 és 2 értékeket a programban a k, p, o karakterekre cserélni, hogy egységes legyen azzal, amit a felhasználó beírt. Ez javítja a programkód érthetőségét.

Amikor karaktert kell beolvasni, a feladattól függően érdemes a scanf()-et scanf("%c", &betu) helyett scanf(" %c", &betu) formában használni, azaz tenni egy szóközt a %c elé. Ennek hatására a scanf() eldobja a kapott szóköz és újsor (enter) karaktereket, és megvárja az első nem szóközt. Erre azért van szükség, mert karakterek beolvasásánál alapértelmezés szerint megkapjuk a felhasználó által leütött entereket is.

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

int main(void) {
    int jatekospont, geppont;
    char jatekostipp, geptipp;
    
    /* pontszámok nullázása és üdvözlés*/
    jatekospont = geppont = 0;
    srand(time(0));
    printf("Kő (k), papír (p), olló (o) vagy vége (v)?\n");
    
    /* az első tipp a játékostól */
    printf("\nSzerinted: ");
    scanf(" %c", &jatekostipp);
    
    /* végjeles sorozat - a 'v' karakter jelzi a végét */
    while (jatekostipp != 'v') {
        /* tippel a gép is: 0, 1 vagy 2 véletlenszám. */
        int geptipp_i = rand() % 3;
        /* karakterré alakítjuk: 0->olló, 1->papír, 2->kő. */
        /* hogy melyikből mi lesz, az mindegy. */
        if (geptipp_i == 0)
            geptipp = 'o';
        else if (geptipp_i == 1)
            geptipp = 'p';
        else
            geptipp = 'k';
        printf("Szerintem: %c.\n", geptipp);

        /* összehasonlítás és pontozás */
        if ((jatekostipp == 'k' && geptipp == 'o')        /* kő veri az ollót */
            || (jatekostipp == 'p' && geptipp == 'k')     /* papír veri a követ */
            || (jatekostipp == 'o' && geptipp == 'p')) {  /* olló veri a papírt */
            ++jatekospont;
            printf("%c>%c, ezt te vitted!\n", jatekostipp, geptipp);
        }
        else if ((geptipp == 'k' && jatekostipp == 'o')   /* kő veri az ollót */
            || (geptipp == 'p' && jatekostipp == 'k')     /* papír veri a követ */
            || (geptipp == 'o' && jatekostipp == 'p')) {  /* olló veri a papírt */
            ++geppont;
            printf("%c<%c, ezt én vittem!\n", jatekostipp, geptipp);
        }
        else
            printf("Senki nem kap pontot.\n");

        /* a következő tipp a játékostól */
        printf("\nSzerinted: ");
        /* a karakter beolvasása előtt a scanf() egy szóközt kap.
         * ez azt jelenti, hogy a beolvasott szóközöket és újsor
         * karaktereket dobja el, és várjon tovább betűre. */
        scanf(" %c", &jatekostipp);
    }
    
    /* végeredmény */
    printf("\n");
    if (jatekospont > geppont)
        printf("Te nyertél, %d>%d ponttal.\n", jatekospont, geppont);
    else if (jatekospont < geppont)
        printf("Én nyertem, %d>%d ponttal.\n", geppont, jatekospont);
    else
        printf("A játék döntetlen, mindkettőnknek %d pontja lett.\n", jatekospont);
    
    return 0;
}

Ehhez érdemes előbb a tömböt úgy feltölteni, hogy sorrendben szerepelnek benne a kártyák, és utána összekeverni. Úgy nem kell mindig vizsgálni, hogy minden kártya pontosan kétszer szerepel-e benne. A tömb megkeveréséhez minden elemet cserélj meg egy véletlenedikkel! for(…tömbelemek…) – valahogy így.

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

int main(void) {
    int tomb[6];

    srand(time(0));  /* Véletlengenerátor inicializálása */

    /* 6 szám bekérése a tömbbe */
    for (int i = 0; i < 6; i += 1) {
        printf("%d. szam: ", i + 1);
        scanf("%d", &tomb[i]);
    }

    /* Elemek véletlen rendezése */
    for (int i = 0; i < 6; i += 1) {
        int rnd = rand() % 6; /* Generálunk egy véletlenszámot */
        /* Csere 3 lépésben: i. <-> rnd. elemek */
        int csere = tomb[i];
        tomb[i] = tomb[rnd];
        tomb[rnd] = csere;
    }

    /* Tömb kiírása */
    for (int i = 0; i < 6; i += 1) printf("%4d ", i + 1);
    printf("\n");
    for (int i = 0; i < 6; i += 1) printf("%4d ", tomb[i]);
    printf("\n");

    /* Rendezetség ellenőrzése */
    bool sorban = true; /* Tegyük fel hogy sorba van rendezve */
    /* Ha van két elem ami rossz sorrendben van akkor már nincs rendezve */
    for (i = 0; i < 5; i += 1)
        if (tomb[i] > tomb[i + 1])
            sorban = false;

    /* Ciklus amíg rossz a sorrend */
    while (!sorban) {
        /* Bekérünk két indexet */
        int cs1, cs2;
        printf("1. cserelendo: ");
        scanf("%d", &cs1);
        printf("2. cserelendo: ");
        scanf("%d", &cs2);
        /* Ellenőrizzük a határokat */
        if (cs1 != cs2 && cs1 >= 1 && cs2 >= 1 && cs1 <= 6 && cs2 <= 6) {
            /* 3 lépéses csere */
            /* Az indexekből 1-et ki kell vonni: 1..6 -> 0..5 */
            csere = tomb[cs1 - 1];
            tomb[cs1 - 1] = tomb[cs2 - 1];
            tomb[cs2 - 1] = csere;
        }
        else
            printf("Hibas indexek!\n");

        /* Tömb kiírása */
        for (int i = 0; i < 6; i += 1)
            printf("%4d ", i + 1);
        printf("\n");
        for (int i = 0; i < 6; i += 1)
            printf("%4d ", tomb[i]);
        printf("\n");

        /* Rendezettség ellenőrzése */
        sorban = true;
        for (int i = 0; i < 5; i += 1)
            if (tomb[i] > tomb[i + 1])
                sorban = false;
    }

    /* Ha vége a ciklusnak akkor győzelem */
    printf("Gratulalok, nyertel!");

    return 0;
}

Miután a felhasználó megadta a tippjét, a program használhat olyan algoritmust, amely hatására ez a beírt tipp elfelejtődik. Először a pozíció szerint is stimmelő tüskéket érdemes keresni, és az így megtalált egyezések a tömbből törölhetőek, hogy a második, pozíciót figyelembe már nem vevő keresés ne találja meg azokat újra.

Karakterek beolvasásával kapcsolatban lásd a fentebbi megjegyzéseket (pl. a kő, papír, olló játéknál.)