# Funzioni II
:warning: ==I testi degli esercizi vanno intesi come abbiamo visto a lezione. Se il testo dice che una funzione deve restituire un array $\to$ bisogna passare come ulteriore argomento un array destinazione da modificare (etc...)== :warning:

# Conta Occorrenze

Scrivere un programma che legge un array di interi e un numero e stampa il numero di volte che il numero appare all’interno dell’array.

Scrivere le funzioni:

- leggiInt(): che legge e restituisce un intero
- leggiIntN(): che legge e restituisce un intero minore di N e positivo
- leggiArrayInt(): che legge e restituisce un array di interi di una certa dimensione
- contaOccorrenze(): che prende in input un array e un numero e restituisce il numero di volte che il numero appare all’interno dell’array

// Librerie
#include <stdio.h>

// Costanti
#define N 100

// Prototipi
int leggiInt();
int leggiIntN();
void leggiArrayInt(int [], int);
int contaOccorrenze(int [], int, int);

// Main
int main(){
    int n, v[N], x, count;

    n = leggiIntN();

    leggiArrayInt(v, n);

    x = leggiInt();

    count = contaOccorrenze(v, n, x);

    printf("Ci sono %d ripetizioni di %d.\n", count, x);

    return 0;
}

// Funzioni
int leggiInt(){
    int a;
    printf("Inserisci un numero: ");
    scanf("%d", &a);
    return a;
}

int leggiIntN(){
    int a;
    do {
        printf("Inserisci un numero: ");
        scanf("%d", &a);
    } while(a > N || a <= 0);
    return a;
}

void leggiArrayInt(int v[], int dim){
    int i; 
    for(i=0; i<dim; i++){
        printf("Posizione %d\n", i);
        v[i] = leggiInt();
    }
    return;
}

int contaOccorrenze(int v[], int dim, int x){
    int i, count = 0;
    for(i=0; i<dim; i++){
        if(v[i] == x) count++;
    }
    return count;
}

---
# Rimuovi Carattere da Stringa

Scrivere un programma che legge una stringa senza spazi e un carattere e stampa la stringa inserita senza il carattere inserito.

Scrivere le funzioni (da mappare con quanto possibile fare in C):

- leggiCarattere(): che legge e restituisce un carattere
- leggiStringa(): che legge e restituisce una stringa
- rimuoviCarattere(): che prende in input una stringa e un carattere e restituisce la stringa senza il carattere inserito

// Librerie
#include <stdio.h>
#include <string.h>

// Costanti 
#define LEN 100

// Prototipi
char leggiCarattere();
void leggiStringa(char []);
void rimuoviCarattere(char [], char [], char);

// Main
int main(){
    // Variabili
    char src[LEN], dest[LEN], da_rimuovere;

    // Leggi stringa
    leggiStringa(src);

    // Leggi Carattere
    da_rimuovere = leggiCarattere();

    // Rimuovi il carattere dalla stringa
    rimuoviCarattere(src, dest, da_rimuovere);

    // Stampa la stringa dst
    printf("%s senza %c = %s\n", src, da_rimuovere, dest);

    return 0;
}

// Funzioni
char leggiCarattere(){
    char c;
    printf("Inserisci carattere: ");
    scanf("%c", &c);
    scanf("%*c");
    return c;
}

void leggiStringa(char stringa[]){
    printf("Inserisci stringa: ");
    scanf("%s", stringa);
    fflush(stdin);
    return;
}

void rimuoviCarattere(char src[], char dest[], char da_rimuovere){
    // Variabili
    int len_src, i, len_dest;

    // Inizializzo Lunghezze
    len_src = strlen(src);
    len_dest = 0;

    // Scorro src per copiare senza buchi in dest
    for(i=0; i<len_src; i++){
        if(src[i] != da_rimuovere){
            dest[len_dest] = src[i];
            len_dest++;
        }
    }

    // Aggiungo carattere di terminazione
    dest[len_dest] = '\0';

    return;
}

---
# Lunghezza della Massima Sottosequenza Ascendente

Scrivere un programma che prende in input nella funzione main una stringa. Il programma stampa la lunghezza della più lunga sottosequenza di caratteri ordinati in ordine ascendente nella stringa.

Scrivere la funzione:

- `lunghezzaMassimaSottosequenzaAscendente()`: che prende in input un puntatore che punta alla stessa area di memoria della stringa e la lunghezza della stringa. La funzione restituisce un intero pari alla più lunga sottosequenza di caratteri ordinati in ordine ascendente nella stringa.

// Librerie
#include <stdio.h>
#include <string.h>

// Costanti
#define LEN 100

// Prototipi
void leggiStringa(char []);
int lunghezzaMassimaSottosequenzaAscendente(char []);

// Main
int main(){
    char s[LEN];
    int max_len;
    
    leggiStringa(s);
    
    max_len = lunghezzaMassimaSottosequenzaAscendente(s);
    printf("Lunghezza massima sottosequenza ascendente: %d\n", max_len);

    return 0;
}

// Funzioni
void leggiStringa(char stringa[]){
    printf("Inserisci Stringa: ");
    scanf("%s", stringa);
    return;
}

int lunghezzaMassimaSottosequenzaAscendente(char s[]){
    int len = 1, max_len = 1, i, str_len;
    str_len = strlen(s);
    
    for(i = 1; i < str_len; i++){
        if(s[i] >= s[i-1]) {
            len++;
            if(max_len < len) max_len = len;
        } else {
            len = 1;
        }
    }

    return max_len;
}

---
# Elevare al Quadrato un porzione dell’Array

Scrivere un programma che legge un array di lunghezza definita dall’utente (al massimo una dimensione predeterminata) e che modifica l’array elevando al quadrato una porzione di esso a partire da una posizione decisa dall’utente fino a quando l’array non termina o fino a quando non si incontra uno 0.

Scrivere le funzioni:

- leggiInt(): che legge e restituisce un intero
- leggiIntN(): che legge e restituisce un intero in [1,N]
- leggiArrayInt(): che legge e restituisce un array di interi di una certa dimensione
- foo(): che eleva al quadrato gli elementi dell’array da una certa posizione in poi fino ad arrivare alla fine dell’array o fino a quando l’array non termina. Tale funzione fa uso della funzione ausiliaria subpow()
- subpow(): che prende l’inizio di una porzione dell’array e la dimensione di tale sotto-array e lo eleva al quadrato
- stampaArray(): che stampa un array passato in input

// Librerie
#include <stdio.h>

// Costanti
#define N 100

// Prototipi
int leggiInt();
int leggiIntN();
void leggiArrayInt(int [], int);
void stampaArray(int [], int);
void foo(int [], int, int);
void subpow(int [], int);

// Main
int main(){
    int n, v[N], x;

    // leggi dimensione array in [1, N]
    n = leggiIntN();

    // leggi array
    leggiArrayInt(v, n);

    // leggi posizione
    x = leggiInt();

    // eoleva al quadrato sottoporzione
    foo(v, n, x);

    // stampa array
    stampaArray(v, n);

    return 0;
}

// Funzioni
int leggiInt(){
    int a;
    printf("Inserisci un numero: ");
    scanf("%d", &a);
    return a;
}

int leggiIntN(){
    int a;
    do {
        printf("Inserisci un numero: ");
        scanf("%d", &a);
    } while(a > N || a <= 0);
    return a;
}

void leggiArrayInt(int v[], int dim){
    int i; 
    for(i=0; i<dim; i++){
        printf("Posizione %d\n", i);
        v[i] = leggiInt();
    }
    return;
}

void stampaArray(int v[], int dim){
    int i;
    printf("[");
    for(i=0; i<dim; i++){
        printf("%d, ", v[i]);
    }
    printf("]\n");
    return;
}

void foo(int v[], int len, int pos){
    int i, sublen = 0;

    // verifico che la posizione sia ok
    if(pos < 0 || pos >= len) return;
    
    // calcolo la dimensione della sotto-porzione dell'array
    for(i=pos; i<len; i++){
        if(v[i] != 0) sublen++;
    }

    // elevo al quadrato la sotto-porzione dell'array
    subpow(&v[pos], sublen);

    return;
}

void subpow(int v[], int len){
    int i;
    for(i=0; i<len; i++) v[i] *= v[i];
    return;
}

---
# Elimina sottostringa da stringa

Scrivere un programma che prende in input una stringa e una seconda stringa. Il programma rimuove dalla prima stringa tutte le sequenze di caratteri uguali alla seconda stringa.

Scrivere le funzioni:

- leggiStringa()
- rimuoviStringa()

// Librerie
#include <stdio.h>
#include <string.h>

// Costanti
#define LEN 100

// Prototipi
void leggiStringa(char []);
void rimuoviStringa(char [], char [], char []);

// Main
int main(){
    char s[LEN], rm[LEN], dest[LEN];

    printf("Stringa originale\n");
    leggiStringa(s);

    printf("Stringa da rimuovere\n");
    leggiStringa(rm);

    rimuoviStringa(s, rm, dest);

    printf("\n%s senza %s = %s\n", s, rm , dest);

    return 0;
}

// Funzioni
void leggiStringa(char s[]){
    printf("Inserisci stringa: ");
    scanf("%s", s);
    fflush(stdin);
    printf("\n");
    return;
}

void rimuoviStringa(char s[], char rm[], char dest[]){
    int len_s, len_rm, len_dest=0, i, j, k;

    len_s = strlen(s);
    len_rm = strlen(rm);
    
    i = 0;
    while(i < len_s){
        k = 0;
        for(j=0; j<len_rm && i + j < len_s; j++){
            if(s[i+j] == rm[j]) k++;
            else break;
        }

        if(k == len_rm) i += len_rm;
        else{
            dest[len_dest] = s[i];
            len_dest++;
            i++;
        }
    }
    dest[len_dest] = '\0';

    return;
}

---
# Shift Matrice per Righe

Scrivere un programma che legge una matrice 3x4 ed effettua uno shift per righe verso il basso e stampa il risultato. L’ultima riga prende la posizione della prima riga.

Scrivere le funzioni:

- leggiArray()
- leggiMatrice()
- stampaArray()
- stampaMatrice()
- copiaArray()
- shiftMatrice()

// Librerie
#include <stdio.h>

// Costanti
#define R 3
#define C 4

// Prototipi
void leggiArray(int []);
void leggiMatrice(int [][C]);
void stampaArray(int []);
void stampaMatrice(int [][C]);
void copiaArray(int [], int []);
void shiftMatrice(int [][C], int [][C]);

// Main
int main(){
    int src[R][C], dest[R][C];

    leggiMatrice(src);
    shiftMatrice(dest, src);

    printf("\nMatrice originale\n");
    stampaMatrice(src);

    printf("\nMatrice con shift\n");
    stampaMatrice(dest);

    return 0;
}

// Funzioni
void leggiArray(int v[]){
    int i;
    for(i=0; i<C; i++){
        printf("Inserisci elemento in posizione %d: ", i);
        scanf("%d", &v[i]);
    }
    return;
}

void leggiMatrice(int m[][C]){
    int i;
    for(i=0; i<R; i++){
        printf("Inserisci riga %d\n", i);
        leggiArray(m[i]);
        printf("\n");
    }
    return;
}

void stampaArray(int v[]){
    int i;

    printf("[");
    for(i=0; i<C; i++){
        printf("%d, ", v[i]);
    }
    printf("]\n");

    return;
}

void stampaMatrice(int m[][C]){
    int i;
    for(i=0; i<R; i++){
        stampaArray(m[i]);
    }
    return;
}

void copiaArray(int dest[], int src[]){
    int i;
    for(i=0; i<C; i++){
        dest[i] = src[i];
    }
    return;
}

void shiftMatrice(int dest[][C], int src[][C]){
    int i, tmp[C];

    for(i=1; i<R; i++){
        copiaArray(dest[i], src[i-1]);
    }

    copiaArray(dest[0], src[R-1]);
    return;
}