Možná řešení

Faktoriál n ≡ n!

unsigned int fakt(unsigned int nn)
{
    if (nn == 0) return 1;
    return nn * fakt(nn - 1);    
}

Největší společný dělitel Eukleídovým algoritmem

unsigned int nsd(unsigned int a, unsigned int b)
{
    if (b % a == 0) return a;
    return nsd(b % a, a);
}

Fibbonaciho posloupnost

unsigned int f(unsigned int k)
{
    if (k < 2) return k;
    return f(k-1) + f(k-2);
}

/**
 *
 * Binarni vyhledavani 
 *
 * @file binarySearch.c
 *
 * @author   A.  Zlamal
 *
 */

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

#define DELKA_POLE 26      // muzeme kdykoli delku pole menit jen na tomto miste

#define I_F_P "%d"         // FORMATOVACI_PARAMETR pro scanf - musime menit jen na tomto miste podle myType
#define O_F_P "%2d "       // FORMATOVACI_PARAMETR pro printf - musime menit jen na tomto miste podle myType

typedef int myType;        // muzeme potom typ menit jen na tomto miste
typedef myType pole[DELKA_POLE]; // analogicky: lze typ pole pohodlne pouzivat

/**
 * Binarne vyhledava zadanou ciselnou hodnotu - vrati jeji index v poli; nenajde-li ji vrati -1 
 *
 * @param aa  usporadane pole, v nemz se hleda
 * @param ch  hledana ciselna hodnota
 * @param d dolni mez podpole, v nemz se hleda
 * @param h horni mez podpole, v nemz se hleda
 * @return  index v poli, najde-li zadanou hodnotu; nenajde-li -1 
 */
nt binarySearch(pole aa, myType ch, int d, int h);

int main()
{
    pole a;
    int i;
    myType v;

    srand(time(NULL)); 
    a[0] = rand() % (4 + (rand() & 1));    
    for (i = 1; i < DELKA_POLE; ++i) {
        a[i] = a[i-1] + 1 + rand() % (4 + (rand() % 4));    
    }
    for (i = 0; i < DELKA_POLE; ++i) {
        printf("%2d ", i);    
    }
    printf("\n");    
    for (i = 0; i < DELKA_POLE; ++i) {
        printf(O_F_P, a[i]);
    }
    printf("\n");
    printf("Zadejte hodnotu, jez se ma nalezt: ");
    scanf(I_F_P, &v);
    if ((i = binarySearch(a, v, 0, DELKA_POLE)) != -1) {
        printf(O_F_P"je v poli na posici %d.\n", v, i);
    } else {
        printf(O_F_P"v poli neni.\n", v);
    }
    return EXIT_SUCCESS;
}


int binarySearch(pole aa, myType ch, int d, int h) 
{
    int s;
    myType c;
    
    if (d > h) return -1;
    if ((c = aa[(s = (d + h) / 2)]) == ch) return s;
    if (c > ch) return binarySearch(aa, ch, d, s - 1);
    return binarySearch(aa, ch, s + 1, h);
}

Kombinační čísla

unsigned int c(unsigned int nn, unsigned int kk)
{
    if (kk == 0) return 1;
    if (2*kk > nn) return c(nn, nn - kk);
    return nn * c(nn - 1, kk - 1) / kk;
    
}

nebo

unsigned int c(unsigned int nn, unsigned int kk)
{
    if (kk == 0) return 1;
    if (2*kk > nn) return c(nn, nn - kk);
    return c(nn - 1, kk - 1) + c(nn - 1, kk);
}

/**
 * Vypise zadane cislo v pravidelne posicni soustave se zadanym zakladem 
 *
 * @param c  ciselna hodnota, ktera se ma vypsat
 * @param b  hodnota zakladu posicniho vyjadreni zadaneho cisla
 */
void printNumber(unsigned int c, unsigned int b);

void printNumber(unsigned int c, unsigned int b)
{
    if (c == 0) return;
    printNumber(c / b, b);
    printf("%u", c % b);
}

/**
 * Pocita odmocninu metodou pripisovanou Isaacu Newtonu
 *
 * @param x  ciselna hodnota, jejiz druha odmocnina se pocita
 * @param a  pocatecni aproximace pocitane druhe odmocniny
 * @param t  tolerance, s niz se druha odmocnina pocita
 */
double squaRoot(double x, double a, double t);

int main()
{
    double xx, tt;
    printf("Zadejte toleranci vypoctu odmocniny: ");
    scanf(" %lf", &tt);
    while (1) {
        printf("Zadejte cislo k vypocteni odmocniny z nej (0 program ukoncuje): ");
        scanf(" %lf", &xx);
        if (xx == 0.0) return EXIT_SUCCESS;
        printf("Odmocnina ze zadaneho cisla %f s presnosti %f je %f.\n", xx, tt, squaRoot(xx, 0.5 * xx, tt));
    }       
}


double squaRoot(double x, double a, double t)
{
    if ((a - t)*(a - t) < x && x < (a + t)*(a + t)) return a;
    return squaRoot(x, (a + x/a) * 0.5, t);
}

Dvojposloupnost z Gaussova–Legendreova algoritmu výpočtu hodnoty π

double limitaDvojposlounosti(double a, double b);

double limitaDvojposlounosti(double a, double b)
{
    if (a - b < 0.0000000000000000005) return (a + b) * 0.5;
    return limitaDvojposlounosti((a + b) * 0.5, sqrt(a * b));
}

Spolecna limita dvojposloupnosti je 0.847213084793979165.

Obsah kruhové úseče je

\pi =\lim _{n\to \infty }{\frac {e^{2n}n!^{2}}{2n^{2n+1}}}.

a má být

\pi =\lim _{n\to \infty }{\frac {e^{2n}n!^{2}}{2n^{2n+1}}}.

. Úhly jsou v radiánech.
(Kruh je jednotkový.)

/**
 * Jednoucelova rekursivni funkce pro vypocet usece s tretinovym obsahem 
 *
 * @param  a levy konec intervalu, v nemz se pohybuje vysledek
 * @param  b pravy konec intervalu, v nemz se pohybuje vysledek
 * @return  vysledek
 */
double tretinaKruhu(double a, double b);

⋮

    x = tretinaKruhu(0.0, 1.0);
    printf(" %lf %lf %lf\n", x, acos(x) - x * sqrt(1.0 - x*x), TRETINA_KRUHU);

⋮

double tretinaKruhu(double a, double b) 
{
    double xx, m;
    m = (a + b) * 0.5; 
    xx = acos(m) - m * sqrt(1.0 - m*m);
    if (xx - 0.0000005 < TRETINA_KRUHU && TRETINA_KRUHU < xx + 0.0000005) return m;
    if (xx > TRETINA_KRUHU) return tretinaKruhu(m, b);
    return tretinaKruhu(a, m);
}

V terminálovém oknu:
0.264932 1.047197 1.0471

/**
 * Mene jednoucelova rekursivni funkce pro vypocet usece se zadanym podilem obsahu 
 *
 * @param  a   levy konec intervalu, v nemz se pohybuje vysledek
 * @param  b   pravy konec intervalu, v nemz se pohybuje vysledek
 * @param  y   pozadovany podil z kruhu, pro nejz se hleda vzdalenost stredu kruhu od tetivy
 * @param  eps   zadana tolerance 
 * @return  vysledek ≡ vzdalenost stredu kruhu od tetivy vymezujici kruhovou usec
 */
double kolikatinaKruhu(double a, double b, double y, double eps);

⋮

    x = x = kolikatinaKruhu(0.0, 1.0, 1.0 / 3.0, 0.0000005);
    printf(" %lf %lf %lf\n", x, acos(x) - x * sqrt(1.0 - x*x), TRETINA_KRUHU);

⋮

double kolikatinaKruhu(double a, double b, double yy, double eps) 
{
    double xx, m, y;
    y = yy * M_PI;
    m = (a + b) * 0.5; 
    xx = acos(m) - m * sqrt(1.0 - m*m);
    if (xx - eps < y && y < xx + eps) return m;
    if (xx > y) return kolikatinaKruhu(m, b, yy, eps);
    return kolikatinaKruhu(a, m, yy, eps);
}

V terminálovém oknu:
0.264932 1.047197 1.0471

double f(double x); 
double g(double x); // druha mocnina ≡ ctverec

/**
 * Universalni rekursivni funkce pro vypocet zadane hodnoty ve funkci inversni k zadane 
 *   Inversni funkci k zadane nelze spocitat a zadana funkce musi mit v zadanem intervalu monotonni prubeh
 *
 * @param  f   double f(double x), ve fukci k ni inversni se pocita hodnota funkce v zadanem bode
 * @param  a   levy konec intervalu, v nemz se pohybuje vysledek
 * @param  b   pravy konec intervalu, v nemz se pohybuje vysledek
 * @param  r   kladna hodnota - nejlepe 1.0 - pro vzestupnou funkci a pro sestupnou zaporna - nejlepe -1.0 
 * @param  y   pozadovana hodnota argumentu inversni funkce
 * @param  eps   zadana tolerance 
 * @return  vysledna hodnota
 */
double interpolace(double (*h)(double), double a, double b, double r, double y, double eps);

⋮

    x = interpolace(f, 0.0, 1.0, f(1.0) - f(0.0), M_PI * 1.0 / 3.0, 0.0000005);
    printf(" %lf %lf %lf\n", x, f(x), TRETINA_KRUHU);
    x = interpolace(g, 1.0, 2.0, 1.0, 2, 0.0000005);
    printf(" \\|%lf = %lf\n", g(x), x);

⋮

double f(double x) 
{
    return acos(x) - x * sqrt(1.0 - x*x);
}

double g(double x) 
{
    return x*x;
}
    
double interpolace(double (*h)(double), double a, double b, double r, double y, double eps)
{
    double xx, m;
    m = (a + b) * 0.5; 
    xx = h(m);
    if (xx - eps < y && y < xx + eps) return m;
    if (r*xx < r*y) return interpolace(h, m, b, r, y, eps);
    return interpolace(h, a, m, r, y, eps);
}

V terminálovém oknu:

 0.264932 1.047197 1.0471

                \|2.000000 = 1.414214

Úpravy:

unsigned int isPrime(unsigned int x, unsigned int d)
{
    if (x < 2) return 0;
    if (x < 4) return 1;
    if (d == 0) return isPrime(x, isqrt(x));
    if (d == 1) return d;
    if (x % d == 0) return 0;
    return isPrime(x, d - 1);
}

void bubbleSort(int* c, int k){
    if (bublani(c, k)) return;
    bubbleSort(c, k - 1);
}

int bublani(int* d, int kk)
{
    int pom, r = 1;
    for (int i = 0; i < kk; ++i) {
        if (d[i] > d[i+1]) {
            pom = d[i]; 
            d[i] = d[i+1];
            d[i+1] = pom;
            r = 0;
        }
    }
    return r;
}

int iMax(int* c, int k)
{
    int im;
    
    im = 0;
    for (int i = 1; i <= k; ++i) {
        if (c[im] < c[i]) {
            im = i;        
        }
    }
    return im;
}

void selectSort(int* c, int k)
{
    int m, pom;

    if (k == 0) return;
    m = iMax(c,k);
    if(
        m != k 
    ){
        pom = c[m];
        c[m] = c[k];
        c[k] = pom;
    }
    selectSort(c, k-1);
}

/**
 * Zatridi posledni mezi predchozi 
 *
 * @param b  pole, v kterem se ciselne hodnoty - posloupnost - tridi (vzestupne)
 * @param i  index prvku, ktery se zatrizuje mezi prvky, jez ho predchazi
 */
void insert(int* b, int i);

/**
 * Vzestupne setridi algoritmem Select sort 
 *
 * Vola se selectSort(pole, index prvniho, index posledniho);
 *
 * @param c  pole, v kterem se ciselne hodnoty - posloupnost - tridi (vzestupne)
 * @param i  index prvku, ktery se zatrizuje
 * @param k  index posledniho prvku v poli
 */
void insertSort(int* c, int i, int k);


void insert(int* b, int i)
{
    int j; 
    int t;
    
    t = b[i];
    j = i - 1; 
    while ((j >= 0) && (b[j] > t)) {
        b[j+1] = b[j]; 
        --j;
    }
    b[++j] = t;
}

void insertSort(int* c, int i, int k)
{
    if (i == k) return;
    if (c[i-1] > c[i]) {
        insert(c, i);
    }
    insertSort(c, i + 1, k);
}

Řešení prémiového přizadání:/**
 *
 * Kodovani pomoci Fibonacciovy posloupnpsti
 *
 * @file kodoFibo.c
 *
 * @author   A.  Zlamal
 *
 */

#include <stdlib.h>
#include <stdio.h>
#define D_C 12
/**
 * Zakoduje zadane cislo do souctu clenu Fibbonaciovy posloupnosti od 1 vyse
 *
 *
 *
 * @param x  cislo, jez se ma zakodovat
 * @param d  (dolu) pro 0 jde po Fibbonaciovy posloupnosti od 1 nahoru az po nejmensi Fk ≥ x; dolu pro odecty 1 
 * @param f2  clen Fibbonaciovy posloupnosti na druhem miste pred pocitanym
 * @param f1  clen Fibbonaciovy posloupnosti na prvnim miste pred pocitanym
 */
void sf(unsigned int x, unsigned int d, unsigned int f2, unsigned int f1);

int main()
{
    char *endp;
    unsigned int k;
    char s[D_C];
    
    printf("Zadejte: ");
    while (fgets(s, D_C, stdin) != NULL && *s != '\n') {
        k = (unsigned int)strtoul(s, &endp, 10);
        printf("Cislo %u je zakodovano: ", k);
        sf(k, 0, 0, 1);
        printf("\nZadejte: ");
    }
    return 0;
}

void sf(unsigned int x, unsigned int d, unsigned int f2, unsigned int f1)
{
    if (d) {
        if (f1 == 1) return;
        if (x >= f2) {
            sf(x - f2, d, f1 - f2, f2);
            printf("1");
        } else {
            sf(x, d, f1 - f2, f2);
            printf("0");
        }   
    } else {
        if (f1 > x) {
            sf(x, 1, f2, f1);
            return;            
        }
        sf(x, d, f1, f1 + f2);
    }
}