1. Haladási napló, nagy házi feladat

A szokásos módon frissítsd a haladási naplódat az admin portálon!

Ezen a laboron lehetőséged van úgy dolgozni a nagy házi feladatodon, hogy a laborvezetőtől bármikor segítséget tudsz kérni. Foglalkozhatsz magával a programmal, vagy a hozzá tartozó dokumentációkkal is. Ha ezt választod, akkor egész órára ez a feladatod. Ha nem, akkor lentebb gyakorlófeladatokat találsz.

2. Legalább kettő előfordulás

Írj függvényt, amely paraméterként vesz át egy egészekből álló tömböt, és visszaadja az első olyan tömbelem címét, amelyből legalább kettő található a tömbben! Ha nincs ilyen tömbelem, adjon vissza NULL pointert!

Megoldás

int *dupla(int *tomb, int n) {
    for (int i = 0; i < n - 1; i++)
        for (int j = i + 1; j < n; j++)
            if (tomb[i] == tomb[j])
                return tomb + i;
    return NULL;
}

3. Legkisebb és legnagyobb

Írj függvényt, amely paraméterként vesz át egy egészekből álló tömböt! A függvény adja vissza címükkel átvett változókban a tömb legkisebb és legnagyobb elemének indexét! Ha több egyforma érték a legkisebb/legnagyobb, akkor ezek közül bármelyik indexét visszaadhatja.

Megoldás

A minimum- és maximumkeresésben használt indexhez illik lokális változót használni, és csak a függvény végén betenni az eredményt a cím szerint átvett változókba. Ennek okai:

  • Egyszerűbb a kód, nincs tele *pmin és *pmax kifejezésekkel.
  • Áttekinthetőbb is.
  • Gyorsabb is, mivel a keresős ciklus lokális változókkal dolgozik, nem pedig indirekten elér változókkal.
void minmax(int *tomb, int n, int *pmin, int *pmax) {
    int min = 0, max = 0;
    for (int i = 1; i < n; i++) {
        if (tomb[i] < tomb[min]) min = i;
        if (tomb[i] > tomb[max]) max = i;
    }
    *pmin = min;
    *pmax = max;
}

4. Squeeze

Írj olyan "squeeze" függvényt, amely az első paraméterben megadott sztringből az összes olyan karaktert törli, amelyik szerepel a második paraméterben megadott sztringben. Például "megadott sztring", "gt" paraméterekkel meghívva a függvényt az első paraméter így módosul: "meado szrin".

5. Sztringek szétválasztása

Írj egy függvényt, amely paraméterként vesz át egy bemeneti sztringet és egy elválasztó karaktert! Legyen még két további paramétere, amelyekbe az eredményt írja. Vágja ketté a függvény a sztringet az első elválasztó karakternél: az eleje menjen az egyik eredmény sztringbe, másik pedig a másikba!

Írj főprogramot, amelyben egy példával bemutatod a függvény használatát! A beépített sztringkezelő függvények nem használhatóak.

Példa paraméterek: „alma;körte” és „;”
Példa eredmény: „alma” és „körte”

Megoldás

#include <stdio.h>

void szeletel(char *be, char elvalaszto, char *egyik, char *masik) {
    int x = 0;
    int pos = 0;
    while (be[x] != elvalaszto)
        egyik[pos++] = be[x++];
    egyik[pos] = '\0';
 
    x++;
    pos = 0;
    while (be[x] != '\0')
        masik[pos++] = be[x++];
    masik[pos] = 0;
}

int main(void) {
    char bal[20], jobb[20];

    szeletel("alma;korte", ';', bal, jobb);
    printf("[%s] es [%s]\n", bal, jobb);

    return 0;
}

6. Legnagyobb elem, rekurzívan

A maximumkeresés algoritmusa az előadáson is szerepelt, iteratív változatban.

Írd ezt most meg rekurzívan! Ehhez az alábbiakra kell gondolnod:

  • Egy elemű tömb maximuma az egyetlen egy elem, ami van benne: ez a báziskritérium.
  • Egy tömböt átvevő függvényt meghívható rövidebb tömbrészletre is: eleje + 1 pointerrel rámutatva a második elemre, db - 1 elemszámot mutatva neki.
  • A tömb legnagyobb eleme lehet az első elem, vagy az összes többi elem közül a legnagyobb.

Megoldás

#include <stdio.h>

double maxkeres(double *t, int db) {
    /* egy elemű tömb maximuma az egyetlen eleme */
    if (db == 1)
        return t[0];
    
    double elso = t[0];
    double tobbi = maxkeres(t + 1, db - 1);
    return elso > tobbi ? elso : tobbi;
}


int main(void) {
    double tomb[] = {6, 9, 3, 7, 8, 5, 5.76};

    printf("%g", maxkeres(tomb, 7));

    return 0;
}

7. Rendezés közvetlen kiválasztással, rekurzívan

Egy tömb rendezve: a legelejére rakjuk a legkisebb elemet, utána rendezzük a tömb fennmaradó részét. Minden iteráció átírható rekurzióvá: írd meg a közvetlen kiválasztásos rendezőt rekurzívan! Vagyis a függvényben tedd előre a tömb legkisebb elemét, utána hívd meg a függvényt rekurzívan a tömb fennmaradó részére.

Ötletekhez lásd az előző feladatot.

Megoldás

#include <stdio.h>

void kozvetlen(double *t, int db) {
    /* ha a tömbben nincs két elem, akkor csak rendezett lehet */
    if (db < 2)
        return;

    int minindex = 0;          /* minimum keresése */
    for (int j = 1; j < db; ++j)
        if (t[j] < t[minindex])
            minindex = j;
    if (minindex != 0) {         /* csere? */
        double temp = t[minindex];
        t[minindex] = t[0];    /* csere. */
        t[0] = temp;
    }

    /* a tömb fennmaradó részének rendezése */
    kozvetlen(t + 1, db - 1);
}


int main(void) {
    double tomb[] = {6, 9, 3, 7, 8, 5, 5.76};

    kozvetlen(tomb, 7);
    for (int i = 0; i < 7; ++i)
        printf("%g ", tomb[i]);

    return 0;
}