Zadanie 1

Kod z treści zadania:

enum kolory { czerwony, bialy, niebieski };

void Poustawiaj (int n, lczerw, lbial, lnieb);
{
    int i, j, k

    for (i = j = 0, k = n; i < k; ) {
        switch (Kolor(i))
            case czerwony:
                Przestaw (i, j), j++, i++;
            case bialy:
                i++;
            case niebieski:
                k--, Przestaw(i, k);
    }
    lczerw = j;
    lbial = k - j;
    lnieb = n - k;
} /* Poustawiaj;

Rozwiązanie:

enum kolory { czerwony, bialy, niebieski };

void Poustawiaj(int n, int *lczerw, int *lbial, int *lnieb) { // dodać int * oraz usunąć średnik
    int i, j, k; // dodać średnik
    for (i = j = 0, k = n; i < k;) {
        switch (Kolor(i)) { // dodać nawiasy
            case czerwony:
                Przestaw(i, j), j++, i++;
                break; // dodać breaki
            case bialy:
                i++;
                break;
            case niebieski:
                k--, Przestaw(i, k);
        }
    }
    *lczerw = j; // dodać gwiazdki
    *lbial = k - j;
    *lnieb = n - k;
} /* Poustawiaj */ // zamknięcie komentarza zamiast średnika

Zadanie 2

/*
 * W tablicach mamy:
 * - t[0] - szerokość
 * - t[1] - wysokość
 * - t[2] - współrzędną x lewego dolnego narożnika
 * - t[3] - współrzędną y lewego dolnego narożnika
 */
int f(double prostokat1[], double prostokat2[], double otoczka[], double przeciecie[]) {
    // najpierw zajmijmy się otoczką

    // wyznaczamy lewy bok otoczki - współrzędna x lewego dolnego narożnika otoczki, to po prostu
    // minimum ze współrzędnych x lewych dolnych narożników prostokątów wejściowych
    if (prostokat1[2] < prostokat2[2]) {
        otoczka[2] = prostokat1[2];
    } else {
        otoczka[2] = prostokat2[2];
    }

    // wyznaczamy dolny bok otoczki - analogicznie jest to minimum z narożników prostokątów wejściowych
    if (prostokat1[3] < prostokat2[3]) {
        otoczka[3] = prostokat1[3];
    } else {
        otoczka[3] = prostokat2[3];
    }

    // wyznaczamy prawy bok otoczki - szukamy boku najbardziej wysuniętego na prawo
    // współrzędna x prawego boku danego prostokąta to po prostu szerokość plus współrzędna x lewego wierzchołka
    if (prostokat1[0] + prostokat1[2] > prostokat2[0] + prostokat2[2]) {
        // od wyniku odejmujemy `otoczka[2]`, żeby otrzymać szerokość a nie współrzędną x prawego boku
        otoczka[0] = prostokat1[0] + prostokat1[2] - otoczka[2];
    } else {
        otoczka[0] = prostokat2[0] + prostokat2[2] - otoczka[2];
    }

    // wyznaczamy górny bok otoczki - szukamy boku najbardziej wysuniętego do góry
    if (prostokat1[1] + prostokat1[3] > prostokat2[1] + prostokat2[3]) {
        // od wyniku odejmujemy `otoczka[3]`, żeby otrzymać wysokość a nie współrzędną y górnego boku
        otoczka[1] = prostokat1[1] + prostokat1[3] - otoczka[3];
    } else {
        otoczka[1] = prostokat2[1] + prostokat2[3] - otoczka[3];
    }

    // teraz zajmijmy się przecięciem
    // w tym celu użyjemy analogicznego rozwiązania jak do liczenia otoczki


    if (prostokat1[2] > prostokat2[2]) { // tutaj zmieniamy znak nierówności
        przeciecie[2] = prostokat1[2];
    } else {
        przeciecie[2] = prostokat2[2];
    }

    if (prostokat1[3] > prostokat2[3]) { // tutaj też zmieniamy znak nierówności
        przeciecie[3] = prostokat1[3];
    } else {
        przeciecie[3] = prostokat2[3];
    }

    if (prostokat1[0] + prostokat1[2] < prostokat2[0] + prostokat2[2]) { // tutaj też zmieniamy znak nierówności
        przeciecie[0] = prostokat1[0] + prostokat1[2] - przeciecie[2];
    } else {
        przeciecie[0] = prostokat2[0] + prostokat2[2] - przeciecie[2];
    }

    if (prostokat1[1] + prostokat1[3] < prostokat2[1] + prostokat2[3]) { // tutaj też zmieniamy znak nierówności
        przeciecie[1] = prostokat1[1] + prostokat1[3] - przeciecie[3];
    } else {
        przeciecie[1] = prostokat2[1] + prostokat2[3] - przeciecie[3];
    }

    // jeśli przecięcie istnieje, to jego szerokość i wysokość są nieujemne
    // w zrozumieniu, dlaczego tak jest, bardzo pomaga rysunek
    if (przeciecie[0] >= 0.0 && przeciecie[1] >= 0.0) {
        return 1;
    } else {
        return 0;
    }
}



// Alternatywnie, można to napisać znacznie krócej z użyciem dodatkowych funkcji `min` i `max`

double min(double x, double y) {
    if (x < y) return x;
    else return y;
}

double max(double x, double y) {
    if (x > y) return x;
    else return y;
}

int g(double prostokat1[], double prostokat2[], double otoczka[], double przeciecie[]) {
    otoczka[2] = min(prostokat1[2], prostokat2[2]);
    otoczka[3] = min(prostokat1[3], prostokat2[3]);
    otoczka[0] = max(prostokat1[0] + prostokat1[2], prostokat2[0] + prostokat2[2]) - otoczka[2];
    otoczka[1] = max(prostokat1[1] + prostokat1[3], prostokat2[1] + prostokat2[3]) - otoczka[3];

    przeciecie[2] = max(prostokat1[2], prostokat2[2]);
    przeciecie[3] = max(prostokat1[3], prostokat2[3]);
    przeciecie[0] = min(prostokat1[0] + prostokat1[2], prostokat2[0] + prostokat2[2]) - otoczka[2];
    przeciecie[1] = min(prostokat1[1] + prostokat1[3], prostokat2[1] + prostokat2[3]) - otoczka[3];

    if (przeciecie[0] >= 0.0 && przeciecie[1] >= 0.0) {
        return 1;
    } else {
        return 0;
    }
}

Zadanie 3

a_n = suma od i=1 do n ciągu (n * (n + 2 - i)) = (1/2) * (n^3 + 3n^2)

Można rozpisać częściowo wyraz a_(n+1) powyższej sumy i wyciągnąć z niego a_n. Dzięki temu otrzymamy wzór rekurencyjny, który można rozwiązać za pomocą metody równań różnicowych.

Zadanie 4

double f(int t[], int size) {
    int count = 0;
    int sum = 0;
    for (int i = 0; i < size; i++) {
        if (t[i] > 0) {
            count++;
            sum += t[i];
        }
    }
    if (count == 0) {
        return 0.0;
    }
    return (double) sum / count;
}