Na voljo imamo n kosov ograje dolžine po 1m. Iz teh kosov želimo postaviti pravokotno ogrado, ki bo ograjevala zemljišče z največjo možno površino. Napiši program, ki določi dolžino stranic takšne ograde. Predpostavi, da imaš na voljo vsaj 4 kose ograje in da je število kosov sodo.
Dodatek: preveri rezultat z analitičnim matematičnim izračunom.

#include <stdio.h>

int main() {
    int a, n, p, a_maks;
    int p_maks = 0;
    printf("Vnesi število kosov: ");
    scanf("%d", &n);
    for(a = 1; a <= n / 2; a++) {
        p = a * (n / 2 - a);
        if(p > p_maks) {
            p_maks = p;
            a_maks = a;
        }
    }
    printf("Postavi ograjo %d x %d\n", a_maks, n / 2 - a_maks);
    return 0;
}

Izračunaj določeni integral funkcije 2x²-5x v mejah od x0 do xn. Rezultat preveri z analitičnim izračunom.
Dodatek: izračunaj vrednost integrala še po trapezni formuli in primerjaj natančnost rezultatov. Pojasni ugotovitve.

#include <stdio.h>

int main() {
    int i;
    float x0, xn, x, dx;
    float integral = 0;
    printf("Spodnja meja: ");
    scanf("%f", &x0);
    printf("Zgornja meja: ");
    scanf("%f", &xn);
    dx = (xn - x0) / 1000;
    for(i = 0; i < 1000; i++) {
        x = x0 + i * dx;
        integral += dx * (2 * x * x - 5 * x);
    }
    printf("Int: %f\n", integral);
    integral += dx * (2 * xn * xn - 5 * xn - (2 * x0 * x0 - 5 * x0)) / 2;
    printf("Int (trapez): %f\n", integral);
    return 0;
}

Za plačat imamo tak in tak znesek. Kakšno je najmanjše možno število kovancev in bankovcev, s katerimi lahko to storimo.

#include <stdio.h>

int main() {
    int evri, centi, stevilo;
    printf("Znesek: ");
    scanf("%d.%d", &evri, &centi);
    centi = centi + 100 * evri;
    stevilo = centi / 50000;
    centi = centi % 50000;
    stevilo = stevilo + centi / 20000;
    centi = centi % 20000;
    stevilo = stevilo + centi / 10000;
    centi = centi % 10000;
    stevilo = stevilo + centi / 5000;
    centi = centi % 5000;
    stevilo = stevilo + centi / 2000;
    centi = centi % 2000;
    stevilo = stevilo + centi / 1000;
    centi = centi % 1000;
    stevilo = stevilo + centi / 500;
    centi = centi % 500;
    stevilo = stevilo + centi / 200;
    centi = centi % 200;
    stevilo = stevilo + centi / 100;
    centi = centi % 100;
    stevilo = stevilo + centi / 50;
    centi = centi % 50;
    stevilo = stevilo + centi / 20;
    centi = centi % 20;
    stevilo = stevilo + centi / 10;
    centi = centi % 10;
    stevilo = stevilo + centi / 5;
    centi = centi % 5;
    stevilo = stevilo + centi / 2;
    centi = centi % 2;
    stevilo = stevilo + centi;
    printf("Najmanjše število bankovcev in kovancev je %d.\n", stevilo);
    return 0;
}

Napiši program, ki izračuna največje število, za katerega še lahko izračunamo faktorielo s tipoma long in unsigned long.

#include <stdio.h>

int main() {
    long int n = 1, fak = 1, pfak = 1;
    unsigned long int un = 1, ufak = 1, upfak = 1;
    while(fak / n == pfak) {
        pfak = fak;
        n = n + 1;
        fak = fak * n;
    }
    printf("long faktoriela max = %ld\n", n - 1);
    while(ufak / un == upfak) {
        upfak = ufak;
        un = un + 1;
        ufak = ufak * un;
    }
    printf("unsigned long faktoriela max = %lu\n", un - 1);
    return 0;
}

Napiši program, ki z natančnostima tipov float in double modelira delež oziroma rasti populacije po Verhulstovi logistični enačbi.

#include <stdio.h>

int main() {
    int i;
    double pn_1, pn = 0.01, mipn_1, mipn = 0.01; /* mi ... matematično identično */
    float fpn_1, fpn = 0.01, mifpn_1, mifpn = 0.01;
    float r = 3; /* sistem za majhne r-je ni kaotičen */
    printf("\tdouble\t\tmi double\tfloat\t\tmi float\n");
    for(i = 0; i <= 60; i++) {
        if(i % 5 == 0) printf("%2d:\t%.6f\t%.6f\t%.6f\t%.6f\n", i, pn, mipn, fpn, mifpn);
        pn_1 = pn + r * pn * (1 - pn);
        pn = pn_1;
        mipn_1 = r * mipn;
        mipn_1 -= r * mipn * mipn;
        mipn_1 += mipn;
        mipn = mipn_1;
        fpn_1 = fpn + r * fpn * (1 - fpn);
        fpn = fpn_1;
        mifpn_1 = r * mifpn;
        mifpn_1 -= r * mifpn * mifpn;
        mifpn_1 += mifpn;
        mifpn = mifpn_1;
    }
    return 0;
}

Programerji velikokrat omejujejo območje vrednosti, ki jih vrača rand() z uporabo operatorja ostanka deljenja (rand() % (maks + 1)). Zakaj to ni v redu? Napiši in preizkusi funkcijo mojRand(int maks), ki vrne vrednosti med 0 in maks (vključno), vse z enako verjetnostjo.

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

int mojRand(int maks) {
    int r, zg_meja = RAND_MAX / (maks + 1) * (maks + 1) - 1;
    while((r = rand()) > zg_meja);
    return r % (maks + 1);
}

int main() {
    while(1) {
        int i, vsota_sp = 0, vsota_zg = 0, mojaVsota_sp = 0, mojaVsota_zg = 0;
        for(i = 0; i < 10000000; i++) {
            /* 10 milijonov naključnih števil na intervalu [0, 1499999999], RAND_MAX = 2147483647 */
            if(rand() % 1500000000 < 750000000) vsota_sp++;
            else vsota_zg++;
            if(mojRand(1499999999)) < 750000000) mojaVsota_sp++;
            else mojaVsota_zg++;
        }
        printf("od         0 do  750000000: %d  %d\n", vsota_sp, mojaVsota_sp);
        printf("od 750000000 do 1500000000: %d  %d\n", vsota_zg, mojaVsota_zg);
    }
    return 0;
}

Napiši funkcijo, ki sešteje dve razdalji, podani v čevljih in palcih (čevelj je 12 palcev).

#include <stdio.h>

struct razdalja {
    int cevlji;
    float palci;
};

struct razdalja sestej(struct razdalja a, struct razdalja b) {
    struct razdalja s;
    s.cevlji = a.cevlji + b.cevlji;
    s.palci = a.palci + b.palci;
    if(s.palci >= 12) {
        s.palci -= 12;
        s.cevlji++;
    }
    return s;
}

int main() {
    struct razdalja d1, d2, vsota;
    printf("Prva razdalja (čevlji palci): ");
    scanf("%d %f", &d1.cevlji, &d1.palci);
    printf("Druga razdalja (čevlji palci): ");
    scanf("%d %f", &d2.cevlji, &d2.palci);
    vsota = sestej(d1, d2);
    printf("\nVsota razdalj je %d\'%.1f\"\n", vsota.cevlji, vsota.palci);
    return 0;
}

Napiši program, ki sortira zbirko učencev. Primerjaj metodi urejanja z mehurčki (bubble sort) in s stresanjem (shaker sort) glede na število potrebnih primerjav.

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

#define DIM 500

struct ucenec {
    int visina;
    int starost;
    float teza;
    char spol;
    char ime[100];
    char priimek[100];
};

struct ucenec zbirka[DIM];

int main() {
    int i, urejeno, steviloPrimerjav = 0;
    struct ucenec tmp;
    /* nastavi začetno populacijo: */
    srand(0);
    for(i = 0; i < DIM; i++) zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
    do { /* bubble */
        urejeno = 1;
        for(i = 1; i < DIM; i++) {
            steviloPrimerjav++;
            if(zbirka[i - 1].visina > zbirka[i].visina) {
                tmp = zbirka[i - 1];
                zbirka[i - 1] = zbirka[i];
                zbirka[i] = tmp;
                urejeno = 0;
            }
        }
    } while(!urejeno);
    printf("bubble: %d\n", steviloPrimerjav);
    steviloPrimerjav = 0;
    /* ponastavi identično populacijo za primerjavo: */
    srand(0);
    for(i = 0; i < DIM; i++) zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
    do { /* shaker */
        urejeno = 1;
        for(i = 1; i < DIM; i++) { /* go there */
            steviloPrimerjav++;
            if(zbirka[i - 1].visina > zbirka[i].visina) {
                tmp = zbirka[i - 1];
                zbirka[i - 1] = zbirka[i];
                zbirka[i] = tmp;
                urejeno = 0;
            }
        }
        if(!urejeno) {
            urejeno = 1;
            for(i = DIM - 1; i > 0; i--) { /* go back */
                steviloPrimerjav++;
                if(zbirka[i - 1].visina > zbirka[i].visina) {
                    tmp = zbirka[i - 1];
                    zbirka[i - 1] = zbirka[i];
                    zbirka[i] = tmp;
                    urejeno = 0;
                }
            }
        }
    } while(!urejeno);
    printf("shaker: %d\n", steviloPrimerjav);
    return 0;
}

Izmeri čas, ki ga porabi algoritem urejanja z mehurčki, oziroma algoritem s stresanjem. Izvedi isti algoritem z uporabo kazalcev in ponovno izmeri čas izvajanja. Kaj lahko poveš o hitrosti in porabi pomnilnika? Kdaj je uporaba kazalcev bolj in kdaj manj smiselna?

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

#define DIM 20000

struct ucenec {
    int visina;
    int starost;
    float teza;
    char spol;
    char ime[100];
    char priimek[100];
};

struct ucenec zbirka[DIM], *pZbirka[DIM];
clock_t start;

int main() {
    int i, urejeno, steviloPrimerjav = 0;
    struct ucenec tmp, *pTmp;

    /* nastavi začetno populacijo: */
    srand(0);
    for(i = 0; i < DIM; i++) zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
    start = clock();
    do { /* bubble */
        urejeno = 1;
        for(i = 1; i < DIM; i++) {
            steviloPrimerjav++;
            if(zbirka[i - 1].visina > zbirka[i].visina) {
                tmp = zbirka[i - 1];
                zbirka[i - 1] = zbirka[i];
                zbirka[i] = tmp;
                urejeno = 0;
            }
        }
    } while(!urejeno);
    printf("bubble: %d primerjav %.2fs\n", steviloPrimerjav, (double)(clock() - start) / CLOCKS_PER_SEC);
    steviloPrimerjav = 0;
    /* ponastavi identično populacijo za primerjavo: */
    srand(0);
    for(i = 0; i < DIM; i++) zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
    start = clock();
    do { /* shaker */
        urejeno = 1;
        for(i = 1; i < DIM; i++) { /* go there */
            steviloPrimerjav++;
            if(zbirka[i - 1].visina > zbirka[i].visina) {
                tmp = zbirka[i - 1];
                zbirka[i - 1] = zbirka[i];
                zbirka[i] = tmp;
                urejeno = 0;
            }
        }
        if(!urejeno) {
            urejeno = 1;
            for(i = DIM - 1; i > 0; i--) { /* go back */
                steviloPrimerjav++;
                if(zbirka[i - 1].visina > zbirka[i].visina) {
                    tmp = zbirka[i - 1];
                    zbirka[i - 1] = zbirka[i];
                    zbirka[i] = tmp;
                    urejeno = 0;
                }
            }
        }
    } while(!urejeno);
    printf("shaker: %d primerjav %.2fs\n", steviloPrimerjav, (double)(clock() - start) / CLOCKS_PER_SEC);

    steviloPrimerjav = 0;
    /* nastavi začetno populacijo: */
    srand(0);
    for(i = 0; i < DIM; i++) {
        zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
        pZbirka[i] = &zbirka[i];
    }
    start = clock();
    do { /* bubble */
        urejeno = 1;
        for(i = 1; i < DIM; i++) {
            steviloPrimerjav++;
            if(pZbirka[i - 1]->visina > pZbirka[i]->visina) {
                pTmp = pZbirka[i - 1];
                pZbirka[i - 1] = pZbirka[i];
                pZbirka[i] = pTmp;
                urejeno = 0;
            }
        }
    } while(!urejeno);
    printf("bubble (s kazalci): %d primerjav %.2fs\n", steviloPrimerjav, (double)(clock() - start) / CLOCKS_PER_SEC);
    steviloPrimerjav = 0;
    /* ponastavi identično populacijo za primerjavo: */
    srand(0);
    for(i = 0; i < DIM; i++) {
        zbirka[i].visina = rand() % 21 + 110; /* višine so med 110 in 130 */
        pZbirka[i] = &zbirka[i];
    }
    start = clock();
    do { /* shaker */
        urejeno = 1;
        for(i = 1; i < DIM; i++) { /* go there */
            steviloPrimerjav++;
            if(pZbirka[i - 1]->visina > pZbirka[i]->visina) {
                pTmp = pZbirka[i - 1];
                pZbirka[i - 1] = pZbirka[i];
                pZbirka[i] = pTmp;
                urejeno = 0;
            }
        }
        if(!urejeno) {
            urejeno = 1;
            for(i = DIM - 1; i > 0; i--) { /* go back */
                steviloPrimerjav++;
                if(pZbirka[i - 1]->visina > pZbirka[i]->visina) {
                    pTmp = pZbirka[i - 1];
                    pZbirka[i - 1] = pZbirka[i];
                    pZbirka[i] = pTmp;
                    urejeno = 0;
                }
            }
        }
    } while(!urejeno);
    printf("shaker (s kazalci): %d primerjav %.2fs\n", steviloPrimerjav, (double)(clock() - start) / CLOCKS_PER_SEC);

    return 0;
}

Napiši funkcijo, ki obrne vrstni red elementov celoštevilske zbirke, podane kot parameter. Kaj moramo poleg zbirke funkciji še podati?

#include <stdio.h>

void reverse(int *zb, int n) {
    int i, tmp;
    for(i = 0; i < n / 2; i++) {
        tmp = zb[i];
        zb[i] = zb[n - 1 - i];
        zb[n - 1 - i] = tmp;
    }
}

int main() {
    int i, zbirka[10];
    for(i = 0; i < 10; i++) zbirka[i] = i;
    printf("pred obračanjem: ");
    for(i = 0; i < 10; i++) printf("%d ", zbirka[i]);
    reverse(zbirka, 10);
    printf("\npo obračanju:    ");
    for(i = 0; i < 10; i++) printf("%d ", zbirka[i]);
    return 0;
}

Napiši program, ki prebere nekaj celih števil in jih shrani v datoteko.

#include <stdio.h>

int main() {
    FILE *fp;
    int i, n;
    fp = fopen("test.txt", "wt");
    if(fp == NULL) {
        printf("Napaka: ne morem ustvariti datoteke.\n");
        return 0;
    }
    for(i = 0; i < 5; i++) {
        scanf("%d", &n);
        fprintf(fp, "%d ", n);
    }
    fclose(fp);
    return 0;
}

Napiši program, ki iz datoteke bere besedilo in preverja, če so oklepaji v parih (dovoljeno je gnezdenje oklepajev). Program naj izpiše sporočila o napakah: "Manjka zaklepaj" ali "Nepričakovan zaklepaj v xx. vrstici".

#include <stdio.h>

int main() {
    FILE *fp;
    char ch;
    int vrstica = 1, oklepaji = 0;
    fp = fopen("test.txt", "rt");
    if(fp == NULL) {
        printf("Napaka: ne najdem datoteke.\n");
        return 0;
    }
    while((ch = fgetc(fp)) != EOF) {
        if(ch == '\n') vrstica++;
        else if(ch == '(') oklepaji++;
        else if(ch == ')') oklepaji--;
        if(oklepaji < 0) {
            printf("Napaka: nepričakovan zaklepaj v %d. vrstici.\n", vrstica);
            break;
        }
    }
    if(oklepaji > 0) printf("Napaka: manjka zaklepaj.\n");
    fclose(fp);
    return 0;
}

Napiši program, ki krmili sedem segmentni prikazovalnik, ki je vezan tako, kot kaže slika:

Program naj omogoča prikazovanje desetiških cifer od 0 do 9.

void setup() {
    int i;
    for(i = 2; i < 10; i++) pinMode(i, OUTPUT);
    Serial.begin(9600);
}

void loop() {
    char cifre[][9] = {"11101101", "01100000", "11001110", "11101010", "01100011", "10101011", "10101111", "11100000", "11101111", "11101011"};
    int i, c = Serial.read();
    if(c == -1) return;
    c = c - '0';
    for(i = 0; i < 8; i++)
        if(cifre[c][i] == '0') digitalWrite(i + 2, LOW);
        else digitalWrite(i + 2, HIGH);
}

Napiši funkcijo, ki sprejme nepredznačeno celoštevilsko vrednost in vrne string, v katerem je podana vrednost v dvojiškem zapisu. Napiši tudi funkcijo, ki sprejme string enk in ničel in vrne nepredznačeno celoštevilsko vrednost. Razmisli, kako bi omenjeni funkciji napisal za predznačena števila. Napiši podobni funkciji še za realna števila s fiksno vejico.

#define SIZE 16

void unsigned_to_string(char *str, unsigned short int x) {
    short int i;
    str[SIZE] = 0;
    for(i = SIZE - 1; i >= 0; i--) {
        str[i] = x % 2 + '0';
        x /= 2;
    }
}

unsigned short int string_to_unsigned(char *str) {
    short int i;
    unsigned short int fac = 1, x = 0;
    for(i = SIZE - 1; i >= 0; i--) {
        if(str[i] == '1') x += fac;
        fac *= 2;
    }
    return x;
}

void signed_to_string(char *str, short int x) {
    if(x >= 0) str[0] = '+';
    else {
        str[0] = '-';
        x = ~x + 1;
    }
    unsigned_to_string(str + 1, x);
}

short int string_to_signed(char *str) {
    short int x = string_to_unsigned(str + 1);
    if(str[0] == '-') x = -x;
    return x;

}

void fixed_to_string(char *str, short int integ, unsigned short int frac) {
    short int i;
    double f = frac;
    signed_to_string(str, integ);
    str[SIZE + 1] = '.';
    str[2 * SIZE + 2] = 0;
    while(f >= 1.0) f /= 10;
    for(i = SIZE + 2; i < 2 * SIZE + 2; i++) {
        f *= 2;
        if(f < 1.0) str[i] = '0';
        else {
            str[i] = '1';
            f -= 1.0;
        }
    }
}

void string_to_fixed(short int *integ, unsigned short int *frac, char *str) {
    short int i;
    double f = 0.0, exp = 0.5;
    *integ = string_to_signed(str);
    for(i = SIZE + 2; i < 2 * SIZE + 2; i++) {
        if(str[i] == '1') f += exp;
        exp /= 2;
    }
    *frac = (unsigned short int)(f * 1e4);
}

int main() {
    unsigned short int x;
    short int y;
    char str[2 * SIZE + 3];
    x = 3;
    unsigned_to_string(str, x);
    x = 0;
    x = string_to_unsigned(str);
    y = -5;
    signed_to_string(str, y);
    y = 0;
    y = string_to_signed(str);
    y = -5, x = 3;
    fixed_to_string(str, y, x);
    y = 0, x = 0;
    string_to_fixed(&y, &x, str);
    return 0;
}

Količina goriva v rezervoarju se meri posredno prek merjenja višine gladine (npr. s pomočjo plovca s trajnim magnetom in Hallovo sondo). Za nek rezervoar smo umerili merilnik količine goriva in dobili naslednje vrednosti:

void setup() {
    int i;
    for(i = 0; i < 5; i++) pinMode(i, OUTPUT);
}

void loop() {
    int i, m[] = {399, 799, 899, 949}, val = analogRead(A0);
    for(i = 0; i < 5; i++) digitalWrite(i, LOW);
    if(val < m[0] + 1) digitalWrite(0, HIGH);
    else {
        digitalWrite(1, HIGH);
        if(val > m[1]) digitalWrite(2, HIGH);
        if(val > m[2]) digitalWrite(3, HIGH);
        if(val > m[3]) digitalWrite(4, HIGH);
    }
    delay(1000);
}

Izdelaj oddajnik sporočil v morsejevem zapisu (https://en.wikipedia.org/wiki/Morse_code).
Sporočilo naj bo zakodirano (hard-coded) v programu.
Oddajanje realizirajte prek piskača, ki je priklopljen na PWM izhod na pinu 10.
Večina morsejevih znakov ima manj kot 8 pik in črtic. Če se omejimo na črke in cifre, ni nobena daljša od 5 pik in črtic. Tako je možno kodirati vsak morsejev znak z osmimi biti, kjer prva enica predstavlja start bit, preostali biti pa kodirajo znak (enka je črtica, nula je pika). Npr.:

int dot = 100;
char morse[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  B1101011, B1010010, 0, B10001001, 0, B101000, B1011110, B110110, B1101101, 0, B101010, B1110011, B1100001, B1010101, B110010,
  B111111, B101111, B100111, B100011, B100001, B100000, B110000, B111000, B111100, B111110,
  B1111000, B1101010, 0, B110001, 0, B1001100, B1011010,
  B101, B11000, B11010, B1100, B10, B10010, B1110, B10000, B100, B10111, B1101, B10100, B111, B110, B1111, B10110, B11101, B1010, B1000, B11, B1001, B10001, B1011, B11001, B11011, B11100,
  B110110, 0, B1101101, 0, B1001101, 0,
  B101, B11000, B11010, B1100, B10, B10010, B1110, B10000, B100, B10111, B1101, B10100, B111, B110, B1111, B10110, B11101, B1010, B1000, B11, B1001, B10001, B1011, B11001, B11011, B11100,
  B110110, 0, B1101101, 0, 0
};
char sporocilo[] = "SOS";

void play(char ch) {
  int bit = 7;
  while((ch & B10000000) == 0) {
    bit--;
    ch = ch << 1;
  }
  ch = ch << 1;
  for(; bit > 0; bit--) {
    int l = 1;
    if(ch & B10000000) l = 3;
    analogWrite(10, 127); 
    delay(l * dot);
    analogWrite(10, 0);
    delay(dot);
    ch = ch << 1;
  }
  delay(2 * dot);
}

void setup() {
}

void loop() {
  int i;
  for(i = 0; sporocilo[i]; i++) if(sporocilo[i] == ' ') delay(7 * dot);
    else play(morse[sporocilo[i]]);
  delay(5000);
}

Napiši funkcijo, ki sprejme dva celoštevilska parametra, katerih vrednosti sta med 0 in 15. Funkcija naj obe vrednosti zapakira v osembitno spremenljivko (unsigned char) in ju tako zapakirani vrne (uporabi bitne operacije in tehnike maskiranja). Napiši tudi funkcijo, ki odpakira eno od obeh vrednosti. Npr:

unsigned char x = zapakiraj(10, 4);
int a = odpakiraj(x, 1); /* 1. podatek, a postane 10 */
int b = odpakiraj(x, 2); /* 2. podatek, b postane 4 */

#include <stdio.h>

unsigned char zapakiraj(unsigned char high, unsigned char low) {
    return((high << 4) + low);
}

int odpakiraj(unsigned char data, unsigned char part) {
    if (part == 1) return(data >> 4);
    return(data & 0x0f);
}

int main() {
    unsigned char x = zapakiraj(10, 4);
    int a = odpakiraj(x, 1);
    int b = odpakiraj(x, 2);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}