Esercizi sulla ricorsione - Gianluca Mancusi

/*
Esercizi sulla ricorsione:
Esercizio 1:
Calcolare la somma dei primi N numeri positivi
Esercizio 2:
Calcolare l’N-esimo numero di Fibonacci
Esercizio 3:
Calcolare il minimo di una sequenza di elementi
Esercizio 4:
Calcolare il prodotto di due numeri (utilizzando solo la somma)
Esercizio 5:
Calcolare il fattoriale di un numero N
Esercizio 6:
Calcolare la divisione di due numeri (utilizzando solo la sottrazione)
Esercizio 7:
Scrivere un programma che determini se una matrice quadrata N × N sia o meno simmetrica rispetto alla
diagonale principale, restituendo un valore booleano di conferma.
Esercizio 8:
Dato un vettore di n numeri interi, scrivere una funzione ricorsiva C che ne scambi gli elementi fino a
metterli in ordine inverso rispetto alla posizione iniziale (senza dichiarare vettori aggiuntivi).
Esercizio 9:
Data una stringa S di caratteri e un carattere c, scrivere una funzione ricorsiva C che calcoli le occorrenze di
c in S.
*/

int sommannumeri(int n)
{
    if (n < 1) return 0;
    else return n + sommannumeri(n - 1);
}

int fibonacci(int n)
{
    if (n < 0) return 0;
    if (n == 1 || n == 0) return n;
    else return fibonacci(n - 1) + fibonacci(n - 2);
}

int min(int a[], int i)
{
    if (i == 1) return a[i - 1];
    int m = min(a, i - 1);
    if (m < a[i - 1])
        return m;
    return a[i - 1];
}

int ProdottoRicorsivo(int a, int b)
{
    if (b == 0){
        return 0;
    }
    else{
        if (a > 0){
            if (b > 0){
                return a + ProdottoRicorsivo(a, b - 1);
            }
            else{
                return -a + ProdottoRicorsivo(a, b + 1);
            }
        }
        else{
            if (b > 0){
                return a + ProdottoRicorsivo(a, b - 1);
            }
            else{
                return -a + ProdottoRicorsivo(a, b + 1);
            }
        }
    }
}

int fattoriale(int n)
{
    if (n <= 1) return 1;
    else return n*fattoriale(n - 1);
}

int divisione(int a, int b)
{
    if (abs(a) < abs(b)){
        return 0;
    }
    else{
        if (a > 0){
            if (b > 0){
                return 1 + divisione(a - b, b);
            }
            else{
                return -1 + divisione(a + b, b);
            }
        }
        else
        {
            if (b > 0){
                return -1 + divisione(a + b, b);
            }
            else{
                return 1 + divisione(a - b, b);
            }
        }
    }
}

bool simmetrica(int *matr[], int r, int c)
{
    if (r == 0 && c == 0) return true;
    if (r == c) return simmetrica(matr, r, c - 1);
    if (c == -1) return simmetrica(matr, r - 1, r - 1);
    else return matr[r][c] == matr[c][r] && simmetrica(matr, r, c - 1);
}

void inverti(int *arr, int i, int j)
{
    if (i == j || i > j) return;
    else {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
        return inverti(arr, i + 1, j - 1);
    }
}

int occorrenze(char str[], char c, int i)
{
    if (str[i] == 0) return 0;
    return (str[i] == c) + occorrenze(str, c, i + 1);
}

int main()
{
    int npos = sommannumeri(3);
    int nneg = sommannumeri(-3);
    int f = fibonacci(5);
    int a[5] = { 24, 33, 15, 63, 0 };
    int minimo = min(a, 5);
    int prod = ProdottoRicorsivo(2, -3);
    int fatt = fattoriale(5);
    int div = divisione(18, 6);
    int div2 = divisione(-18, 6);
    int div3 = divisione(18, -6);
    int div4 = divisione(-18, -6);
    int** matr = malloc(4 * sizeof(int*));
    for (int i = 0; i < 4; i++)
    {
        matr[i] = malloc(4 * sizeof(int));
    }
    matr[0][0] = 0; matr[0][1] = 1; matr[0][2] = 2; matr[0][3] = 3;
    matr[1][0] = 1; matr[1][1] = 1; matr[1][2] = 2; matr[1][3] = 3;
    matr[2][0] = 2; matr[2][1] = 2; matr[2][2] = 2; matr[2][3] = 3;
    matr[3][0] = 3; matr[3][1] = 3; matr[3][2] = 3; matr[3][3] = 3;
    bool ris = simmetrica(matr, 3, 3);
    int arr[4] = { 1,2,3,4 };
    inverti(arr, 0, 3);
    char str[] = "Provo la funzione"; //3 occorrenze con 'o'
    int ris2 = occorrenze(str, 'o', 0);
    return 1;
}