ESERCIZI QUELLI DI INFORMATICA PER L'ESAME ELEMENTI DI INFORMATICA

Esercizio 1

Siano assegnati in ingresso, da tastiera, un vettore di interi V ed il suo riempimento n.
Si progetti una funzione RICERCA_PARI che riceva in ingresso V e restituisca come valore di ritorno un valore
booleano indicante se esiste nel vettore V almeno un elemento pari.
Nel main bisognerà leggere, con una opportuna funzione, V ed n e bisognerà stampare un opportuno messaggio
per comunicare l'esito della funzione RICERCA_PARI.

Esempio:
INPUT:
n=7
V=1 3 4 5 7 8 9
OUTPUT:
Esiste un elemento pari nel vettore

Esercizio 2
Siano assegnati in ingresso, da tastiera, una parola ed un carattere. Si progetti una funzione CONTA
che riceva in ingresso la parola ed il carattere e restituisca come valore di ritorno il numero di
occorrenze del carattere nella parola.
Nel main bisognerà leggere, con una opportuna funzione, la parola ed il carattere e bisognerà
stampare un opportuno messaggio per comunicare l'esito della funzione CONTA.

Esempio
INPUT:
Parola: supercalifragilissimevolmente
Carattere: e
OUTPUT:
Il carattere compare 4 volte

Esercizio 3
Siano dati in ingresso da tastiera il riempimento n e gli elementi di un vettore di interi V1. Si progetti una funzione
COPIA che riceva in ingesso V1 ed n, e restituisca in un secondo vettore V2 gli elementi di posizione dispari del
vettore V1. Nel main bisognerà leggere, con una opportuna funzione, V1 ed n e bisognerà stampare con una
opportuna funzione il vettore V2.

Esempio:
INPUT:
n=7
V1=1 3 4 5 7 8 9
OUTPUT:
V2=3 5 8

Esercizio 4
Siano assegnati in ingresso, da tastiera, un vettore di interi V ed il suo riempimento r.
Si progetti una funzione CERCA che riceva in ingresso V ed r ed individui valore e posizione del primo elemento
di V il cui valore è maggiore di quello dell'elemento che lo precede. Tale funzione deve anche restituire come
valore di ritorno un valore booleano che indica se esista o meno un elemento di V maggiore di quello che lo
precede.
Nel main bisognerà leggere, con una opportuna funzione, V ed r, e bisognerà stampare con una opportuna
funzione valore e posizione dell'elemento individuato o un opportuno messaggio nel caso in cui tale elemento non
esista.

Esempi:
INPUT:
r = 7
V = 5 3 2 7 9 4 1
OUTPUT:
posizione = 3
valore = 7

INPUT:
r = 7
V = 18 12 8 7 5 4 1
OUTPUT:
Non esiste nessun elemento di V maggiore del precedente.

Esercizio 5
Si progetti un programma per effettuare la conversione di un numero intero in base 10 alla base b. La conversione
viene effettuata applicando l'algoritmo per divisioni successive. Si stabilisca in quali e quante funzioni è opportuno
suddividere il programma (suggerimento: si utilizzi una stringa per rappresentare il risultato della conversione).

Esempi:

Dammi il numero in base 10 da convertire: 328
Dammi la base: 2
Il numero dopo la conversione di base e': 101001000

Dammi il numero in base 10 da convertire: 429
Dammi la base: 3
Il numero dopo la conversione di base e': 120220

Dammi il numero in base 10 da convertire: 239
Dammi la base: 16
Il numero dopo la conversione di base e': EF

Esercizio 6
Si realizzi una "libreria" per effettuare le seguenti operazioni su matrici di numeri interi:
· Lettura e stampa di una matrice
· Calcolo della trasposta di una matrice
· Calcolo della somma di due matrici
· Calcolo del prodotto riga per colonna.
Si stabilisca in quali e quante funzioni è opportuno suddividere il programma e su quanti file organizzare il progetto.

date due liste di interi precedute dai loro riempimenti,creare un sottoprogramma che concatena la seconda alla prima nel seguente modo:
se unl numero nella seconda è uguale a 1 o più numeri della prima ,mettere questo numero alla destra del suo uguale nella lista uno;mentre per gli elementi della lista 2 che non sono uguali a nessun elemento della uno,metterli in coda alla prima.Stampare la prima lista( modificata ). per esempio: lista 1 = 1 2 3 4
lista 2 = 2 3 5 6

la lista 1 diventa: 1 2 2 3 3 4 5 6

void inserisci_doppi(int e1[], int &n, int e2[], int m)
}

'Si strutturi un progetto multifile che acquisisca un array di reali e che copi in altri due vettori distinti V1 e V2 i valori
positivi e i valori negativi presenti nel vettore W fornito in ingresso. Si ordinino i vettori così ottenuti in senso
crescente e si visualizzino.
Es.:

W [-3.1 2.9 -2.2 45 -15.1 23.7]

V1 [ 2.9 23.7 45 ]
V2 [ -15.1 -3.1 -2.2]'

*/Si strutturi un progetto multifile che acquisisca due array V1 e V2 di interi, contenenti, rispettivamente N1 ed N2 valori ordinati in senso crescente. Si scriva un programma che, per ogni valore di V1 non già presente in V2, provveda ad inserirlo in V2 e ad eliminarlo da V1 e che visualizzi, in uscita, i due vettori ordinati a valle delle eventuali modifiche.

/* Dati due vettori ordinati V1 e V2, inserisci in V2 i valori non
 * presenti gia' in V2, rimuovendoli da V1 e mantenendo l'array ordinato.
 */

void trasferisci(int v1[], int &n1, int v2[], int &n2) else if (v1[i] == v2[k]) else
        }

        // Fine del while, tutti i rimanenti elementi di v1 vanno in
        // coda a v2
        while (i<n1)

        // Ridimensiono n1 sul numero di elementi conservati
        n1 = j;
}

E' possibile ottenere una soluzione più semplice ma meno efficiente usando solo gli algoritmi di ricerca in un array, cancellazione di un elemento, inserimento in ordine:

bool cerca(int a[], int n, int x)

void cancella(int a[], int &n, int pos)

void inserisci_in_ordine(int a[], int &n, int x)

void trasferisci(int v1[], int &n1, int v2[], int &n2)
     }
}

Siano assegnati in ingresso da tastiera un vettore di interi V,il suo riempimento r ed un intero k.Si scriva un programma che calcoli il numero(num)di elementi di V il cui valore è maggiore di k e sostituisca con num e sostituisca con num tutti gli elementi di V il cui valore è minore o uguale a k.Si stampino quindi il vettore V modificato ed il valore num.

const int DIM = 100; //da qui si può cambiare se c ripensi

int main ()

  //chiedi il valore di k
  cout << 'nInsert k: '; cin >> k; //fai un programma + bellino andando a capo quando serve

  //le due funzioni 'chiave' sono ok
  for(int i=0; i<n; i++)

  for (int i=0; i<n; i++)

  //mostra il vettore
  cout << 'nK value has been found ' << num << ' times.';
  cout << 'nNew vector is: n';
  for (int i=0; i<n; i++) cout << v[i] << ' ';

  //saluti
  //..
  system ('pause');
  return 0; //o quello ke vuoi

Siano assegnati in ingresso, da tastiera, una parola ed un carattere. Si progetti una funzione CONTA
che riceva in ingresso la parola ed il carattere e restituisca come valore di ritorno il numero di
occorrenze del carattere nella parola.
Nel main bisognerà leggere, con una opportuna funzione, la parola ed il carattere e bisognerà
stampare un opportuno messaggio per comunicare l'esito della funzione CONTA.

#include <iostream>
#include <stdlib.h>
#include <string.h>

using namespace std;

const int MAX_LEN = 100;
void ricevi (char [], char &);
int conta (const char [], const char);

int main ()

void ricevi (char parola[], char &k)
int conta(const char s[], int k)
*/LABORATORIO
Compilazione separata, sottoprogrammi, schemi algoritmici


Specifica esercizio: Punto di sella di una matrice

In una matrice A ad m righe ed n colonne, si definisce punto di sella un elemento aij tale che esso risulti essere contemporaneamente il massimo fra tutti elementi della riga i-esima e il minimo fra tutti gli elementi della colonna j-esima oppure risulti essere contemporaneamente il minimo fra tutti elementi della riga i-esima e il massimo fra tutti gli elementi della colonna j-esima.
Una matrice può avere zero, uno o più punti di sella. Scrivere un programma multifile che, letta da tastiera una matrice di interi di dimensioni massime 50x50, il suo riempimento di riga r ed il suo riempimento di colonna c, stabilisca se esiste almeno un elemento che è punto di sella per la matrice inserita, e se esiste ne stampi le coordinate.

Il programma deve essere sviluppato prevedendo le seguenti funzioni:

- leggi_matrice : consente l'inserimento da tastiera della matrice e dei valori di riempimento;
- cerca_sella : ricerca il primo punto di sella (se esiste) e fornisce le sue coordinate, inoltre
restituisce il valore booleano 'vero' se un punto di sella è stato trovato, o restituisce
'falso' altrimenti
- minel: cerca il minimo elemento sulla riga o sulla colonna specificata
- max: cerca il massimo elemento sulla riga o sulla colonna specificata

//se mode=0 indica ricerca per riga, =1 per colonna; at è l'indice di riga o colonna fisso al momento della chiamata
int minel(matrice m,int r,int c,int at,int mode)
else


int max(matrice m,int r,int c,int at,int mode)
else


bool cerca(matrice m,int r,int c)

return result;


IN PRATICA:

La funzione di ricerca del minimo è multifunzionale: a secondo del valore del parametro mode, effettura la ricerca del minimo sull'at colonna o sull'at riga. La funzione di massimo la stessa cosa.

Infine nella funzione cerca, parte un ciclo per tutti gli elementi e verifica le due possibili condizioni con un OR logico(||).
Se trova un punto, stampa le coordinate e cambia la variabile result in vero, così all'uscita, segnala al main che esistono punti.

Scusa per il ritardo, l'ho provato e mi funziona.

*/Somma diagonale secondaria

int somma(matrice m,int n)

return s;


cioè metti un'altra variabile che funge da variabile colonna, che si decrementa man manofino ad arrivare al primo elemento dell'ultima colonna! Oppure puoi usare la funzione che prevede righe e colonne cioè nr e nc e passargli un numero uguale, poichè la matrice è quadrata.

*/Fusione ordinata matrici

#include <iostream>
#include <stdlib.h>
#define MAX 50

using namespace std;

typedef int matrice[MAX][MAX];

void caricaM(matrice m,int n)



void vediM(matrice m,int nr,int nc)
cout<<endl;



//restituisce l'indice del minimo dell'i-esima riga della matrice m
int minimo(matrice m,int nc,int riga,int inizio)


return im;


void scambia(matrice m,int riga,int a,int b)


//ordina le singole righe
void ordina(matrice m,int nr,int nc)



void fusione(matrice m1,matrice m2,int n)


//passo la matrice alla procedura di ordinamento per righe
ordina(c,n,n*2);
//visualizzo la matrice nuova che è della fusione ORDINATA di m1,m2 con vediM
vediM(c,n,n*2);
//n e n*2 rappresentano il valore delle righe e delle colonne della matrice di fusione 'c'


int main()

Il programma quindi: prende 2 matrici A e B; le fonde in un'unica C e di quest'ultima ordina le singole righe in ordine crescente. Se non rispecchia la tua traccia scusami se ho postato!

*/Si leggano due matrici A[N][N] e B[N][N] da tastiera.
Si costruisca quindi una matrice C[N][2N] costruita nel seguente modo:
Le righe di indice dispari della matrice C devono essere ottenute
ordinando le righe di indici omologhi delle matrici A e B.
Le righe di indice pari della matrice devono essere ottenute accodando
gli elementi delle righe di indice omologo di B a quelli di A
Si utilizzino procedura sia per la lettura delle matrici sia per l'ordinamento.

|-4 3 0 |=A



|9 -1 4|=B



|-4 -1 0 3 4 9|=C

Cmq bando alle ciance, basta che prendi il programma che ho postato a cagnolino e inserisci una condizione sull'ordinamento nella procedura ordina: dici se la riga i-esima che il for.. sta analizzando è dispari, allora ordini altrimenti passa avanti e tienila solo accodata!!!

Lo so che ti scocci di vedere, per questo ti inserisco tutte le funzioni:

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef int matrice[MAX][MAX];

void caricaM(matrice m,int n);
void vediM(matrice m,int nr,int nc);
void fusione(matrice m1,matrice m2,int n);
void scambia(matrice m,int riga,int a,int b);
int minimo(matrice m,int nc,int riga,int inizio);
void ordina(matrice m,int nr,int nc);



void caricaM(matrice m,int n)



void vediM(matrice m,int nr,int nc)
cout<<endl;



//restituisce l'indice del minimo dell'i-esima riga della matrice m
int minimo(matrice m,int nc,int riga,int inizio)


return im;


void scambia(matrice m,int riga,int a,int b)


void ordina(matrice m,int nr,int nc)



void fusione(matrice m1,matrice m2,int n)


//passo la matrice alla procedura di ordinamento per righe
ordina(c,n,n*2);
//visualizzo la matrice nuova che è della fusione ORDINATA di m1,m2 con vediM
vediM(c,n,n*2);
//n e n*2 rappresentano il valore delle righe e delle colonne della matrice di fusione 'c'


int main()

Il tipo di ordinamento che uso io è quello sequenziale o come dicono i prof: per minimi successivi!!!

Già puoi capire il perchè della funzioneCmq la funzione trova il minimo in ogni riga che vuoi ordinare, restituisce il suo indice e la procedura di ordinamento non fa altro che prendere l'elemento di minimo e scambiarlo con quello che sta analizzando. Un esempio ti chiarisce tutto:

La matrice
M=



Ordiniamo la seconda riga che ha indice 1 e quindi è dispari(perchè in c++ si parte da 0).
Allora parte la procedura di ordinaM, vede la prima riga, verifica che ha indice pari e passa alla seconda.
La seconda ha indice dispari: infatti 1%2 restituisce 1. Allora parte un for per le colonne della matrice e si eseguono questi passaggi:

j=0 m[i è fissa][0]=1
im(indice restituito dalla funzione minimo)=1 perchè m[i è fissa][im]=-2 che è proprio il minimo della seconda riga! Allora la procedura scambia, scambia m[i è fissa][0] con m[i è fissa][im] e il risultato è:

M=




dopo continua con j=1, m[ifissa][1]=1 e il minimo corrisponde con esso. Quindi la riga rimarrà così come sta(infatti la seconda riga è gia ordinata). Puoi far arrivare il controllo fino a n-1: è inutile verificare per l'ultimo valore perchè starà lui solo!!!

La terza riga ha indice 2 che è pari e la procedura ordina termina.

*/Assegnata una matrice quadrata si invertano gli elementi della diagonale principale e di quella secondaria.

sicmq:



DIVENTA:

#include <iostream>
#include <stdlib.h>
#define MAX 50
using namespace std;
typedef int matrice[MAX][MAX];
void carica(matrice m,int n);
void vedi(matrice m,int n);
void elimina(matrice m,int n);

int main()


void carica(matrice m,int n)



void vedi(matrice m,int n)


void elimina(matrice m,int n)


IN PRATICA:

Dopo aver acquisito la matrice nxn, quadrata, dalla procedura elimina parte un ciclo dalla prima riga e scambia m[0,0] con m[0,n-1] cioè l'ultimo elemento della riga(ovvero il primo della diagonale secondaria!).
Questo per n volte fino all'ultimo elemento della diag. principale con quello della diag secondaria.
Quindi:




diventa al primo ciclo



poi al secondo ciclo

4 5 6 (rimane sempre 5 al centro perchè coincidono!!!)
3 4 6 e così via..

P.S. La prox volta posta meglio l'esempio così rispondiamo più in fretta

*/eliminare i numeri dispari da un vettore

Ho dovuto cambiare leggermente la struttura, ora dovrebbe funzionare. Il funzionamento è stato scomposto in due parti, la prima prevede di ordinare il vettore inserendo prima i numeri pari e poi quelli dispari (come nell'intenzione della funzione impletata da te all'inzio, almeno per quello che ne avevo tratto!) e poi la seconda calcola la nuova lunghezza del vettore.

Questa funzione però fa perdere l'ordine all'interno del vettore, per non perderlo è necessario realizzare una funzione che 'scali' il vettore ogni volta che sia presente un numero dispari. Ma non ho utilizzato questa implementazione perchè la funzione originaria che avevi postato prevedeva già la perdita delle posizioni originali. oppure

void elimina(int v[],int &n)



se trova un i-esimo valore dispari, parte il ciclo per shiftare gli elementi ed eliminare l'elemento dispari; poi faccio partire il for principale da i(se nel caso l'elemento successivo a quello che abbiamo eliminato è anch'esso dispari!) e infine decremento n!

P.S.: il for può subire incrementi e decrementi dinamici delle variabili di controllo i e n!!!

oppure con il while

void elimina(int vet[], int &dim)

else

i++;

Il modo migliore per risolvere l'esercizio, con un solo ciclo e senza cambiare l'ordine degli elementi

void elimina_dispari(int a[], int &dim)
dim = j;
}

La traccia di esame della prof. Lanna chiedeva di implementare una funzione reverse che confrontasse due parole e che restituisse un valore, 1 se le due parole sono palindromi, 0 altrimenti.

int reverse1 (char a[], char b[])

int i=0, j=k-1;

while(i<k && j>=0)

if (ok)
else



il tuo errore era il ciclo for() innestato che provocava confuzione in quanto confrontavi l'elemento i con tutti quelli j ect.. Utilizzando il ciclo while ottieni quanto desiderato

*/ho un vettore e devo contare il numero delle occorrenze dell'elemento piu frequente per esempio

a b c a a c b a c a a
a è l'elemento piu freuqente
a 6 volte

#include <iostream>
#include <stdlib.h>
#define MAX 50
using namespace std;

void carica(char a[],int &n)


void conta(char a[],int n)
//verifica dell'occorrenza maggiore
if (c>f)


esci:


cout<<'nL'elemento con piu' occorrenze e': '<<a[ifr];
cout<<'nLe occorrenze sono: '<<f<<endl;


int main()


Nota che i valori saranno caratteri da tastiera rispettando il tuo esempio. Ciò non toglie che puoi inserire anche numeri(verificati cmq come caratteri)!

IN PRATICA:

Ometto la spiegazione del caricamento che già conoscerai. Il programma non fa altro che prendere ogni elemento del vettore(con il primo for) e leggere all'interno dello stesso(con il secondo for) quante volte compare. Se il numero di volte che compare è maggiore del massimo in quel momento, allora diventa lui il massimo: semplice come un sì

L'unica novità nell'algoritmo è che: se un valore è stato già verificato, non lo riverifica di nuovo! Ti faccio un esempio:

vettore= a a b c a a
verifica la prima volta a e trova 4 occorrenze, il max=4 e l'indicemax è 0;
verifica per i=1 e trova di nuovo a: ora invece che rifare il conto daccapo, capisce che a è gia stata verificata e salta a a[2]='b'! Come? Con la seguente condizione:

if (a[i]==a[j]&&j<i)
goto esci;



esci:

cioè se a[i] è gia stato verificato perchè è uguale ad altri elementi precedenti, allora salta e il goto lo porta fuori dal ciclo di conteggio e si prosegue per i+1esimo elemento(infatti il continue fa proprio questo!) e così via fino a n-1.

In sintesi:

-Passo il vettore alla procedure conta;
-Si avvia un ciclo for i per ogni elemento del vettore;
-Per ogni elemento si avvia un altro ciclo for j, che conta quante volte a[i](non a[j]!) è presente: se a[i] è già stato verificato allora esce, perchè per un j<i trova a[j]=a[i] e ciò significa che a[i] era già stato controllato prima, quindi già è stato verificato!
-Se la condizione è falsa conteggia le occorrenze e verifica se sono maggiori del massimo di quel momento: se si, a[i] diventa il massimo e si salva il suo indice(ifr) e le sue occorrenze(f).
-Si chiude il for i procedendo così per tutti gli elementi del vettore.

La particolarità che ti ripeto è che: se un elemento compare più volte, non vengono ricontate le sue occorrenze!!! Meno carico per la CPU!!!

*/una stringa di parole kome posso fare per konfrontare parola e parola :
ad es. non sto bene non mi rompere.

ci sono due non

Si lì è più difficile! Dovresti confrontare le parole, trovandole a meno dello spazio, cioè:

'ciao amico ciao'

la prima parola finisce al 5° posto nell'array(indice=4) allora si confronta quella parola con le altre;

Cioè:
devi creare una funzione che conta le n parole della frase;
una funzione che ti estrae una i-esima parola con i<=n;
poi per il confronto ci sono delle funzioni di libreria che puoi usare, oppure confronti carattere per carattere.
Sul resto dovresti basarti sul modello che ti ho postato per i caratteri semplici.

#include <iostream>
#include <stdlib.h>
#define MAX 50
using namespace std;
typedef char stringa[MAX];

void parola(stringa s,stringa t,int n)
if ((s[i]==' ')&&(lett==true))

if ((p==n)&&(lett==true))

else if (p>n) break;

t[j+1]='0';




int conta(stringa s)
if ((s[i]==' ')&&(lett==true))


return p;


void occorrenze(stringa s,int n)
//verifica dell'occorrenza maggiore
if (c>f)


esci:


parola(s,t,ifr);
cout<<'nL'elemento con piu' occorrenze e': '<<t;
cout<<'nLe occorrenze sono: '<<f<<endl;


int main()


occorrenze(s,conta(s));

system('pause');
return(1);

*/questa funzione dovrebbe scambiare gli elementi di due vettori.
es.
vettore a[1, 2, 3]
vettore b[4, 5, 6]

dopo lo scambio

vettore a[4, 5, 6]
vettore b[1, 2, 3]

void scambia (int a[], int b[], int N, int N1)

}

Questa funzione dovrebbe unire gli elementi di due vettori precedentemente acquisiti in un nuovo terzo vettore.
es.
vettore a [1, 2, 3, 4]
vettore b [4, 5, 6]
vettore c [1, 2, 3, 4, 5, 6]

#include <iostream>
#include <stdlib.h>
#define MAX 50
typedef int vettore[MAX];
using namespace std;

void carica(vettore v,int &n)

             }

void vedi(vettore v,int n)


bool nonce(vettore v,int p,int a)

void unisci(vettore A,vettore B,int n1,int n2)

         else d--;
        }
     
     for(i=0; i<n2; i++)
       
         else d--;
        }         

     cout<<endl<<'Il vettore C e':';
     vedi(C,d);
}

int main()

*/palindromi

#include <iostream>
#include <stdlib.h>
const int DIM=10;
typedef char stringa[DIM+1];
using namespace std;
void leggi_stringa (char s[]);
int lun(stringa s);
int reverse (stringa s,stringa t);

int main ()


void leggi_stringa (stringa s)


int lun(stringa s)

int reverse (stringa s,stringa t)

return 1;/*tutto è ok, allora sono palindrome*/}
return 0;//non hanno la stessa lunghezza, quindi non sono palindrome!

//NB: appena c'è un return, si esce immediatamente dalla funzione!


C'è la funzione lun che ti dà la lunghezza di una stringa che tu le passi; Poi la funzione reverse è molto semplice, non cercare di renderla complessa! Vedi se ti funziona!

Inoltre se dichiari un tipo stringa, CHE PASSI A FARE CHAR S[]??? Devi passare stringa s al più! Altrimenti è inutile dichiarare un tipo!

*/Carica un vettore di n elementi, con N<=100.Successivamente,calcola il prodotto delle componenti di posto pari e la somma di quelle di posto dispari.

#include <iostream>
#include <stdlib.h>
#define MAX 50
typedef int vettore[MAX];
using namespace std;

void carica(vettore v,int n)
     }

void calcola(vettore v,int n)
    cout<<'Il prodotto dei pari e': '<<p<<'nLa somma dei dispari e': '<<s<<endl;
}

int main()

Dato un vettore d N componenti,con N<=100,calcola la somma delle componenti positive e quella delle componenti negative.

ho sommato quante volte caun positivo o un negativo, dalla traccia non si capiva bene. nel caso si debba sommare i valori positivi basta modificare
la variabile che si incrementa in n=n + v[i]


main.cpp

prototipi.h

funzioni.cpp

Specchio se metto in input 100 cosa succede?

Errore di run-time sicuramente, in quanto non hai previsto la rilettura della dimensione se è sbagliata, neanche nel sottoprogramma chiamante.

Il codice corretto dovrebbe essere:

Date 3 stringhe S1,S2 ed S3, ogni volta che si trova una sottostringa di S1 che coincide con S2, si sostituisca a tale sottostringa (in S1) S3.

Es:
S1 = ciao mondo crudele S2 = mondo S3 = universo
S1 = ciao universo crudele

#include <iostream>
#include <stdlib.h>
#define MAX 60
typedef char stringa[MAX];
using namespace std;

int lun(stringa s)

int conta(stringa s)

    return c;
}


//funzione che restituisce l'indice nella stringa s1, dove iniza la p-esima parola
int inizio(stringa s,int p)

    return i-1;
}
//funzione che restituisce l'indice nella stringa s1, dove finisce la p-esima parola
int fine(stringa s,int p)

    return i;
}

void estrai(stringa s,stringa t,int p)
    }
    t[j]='0';
     
}

//FUNZIONE FONDAMENTALE
int sostituisci(stringa s1,stringa s2,stringa s3)
       
        //confronto la stringa estrapolata con s2
        //se è uguale opero la sostituzione
        if(strcmp(t,s2)==0)
       
        s++;
        }
        //altrimenti ricopio la parola che c'era nella frase
        else
       
        }
     }
     
     //chiudo la nuova frase!
     n[ir]='0';
     //copio n in s1, per poi restituirla al programma chiamante
     strcpy(s1,n);
     
     //ritorno le sostituzioni
     return s;
}

int main()

   
    cout<<endl<<'La frase modificata con '<<sostituisci(s1,s2,s3)<<' sostituzioni, e':n'<<s1<<endl;   
    system('pause');
    return(1);
}

*/Data una matrice quadrata:
1 trovare la riga con il maggior numero di elementi dispari
2Copiare la riga cosi trovata in un vettore
3stampare il vettore
4stampare la matrice senza la riga con il maggior numero di elementi dispari.

Si deve tener conto che se si inseriscono due righe con eguale valore di numeri dispari, verrà stampata la prima che si incontra.

*/Assegnati due vettori A e B si ordinino in senso crescente i vettori e si determini un nuovo vettore C ottenuto dalla fusione di A e B mantenendo l'ordinamento. Per lo sviluppo del programma si utilizzino ove possibile sottoprogrammi.

#include <iostream>
#include <stdlib.h>

using namespace std;

#define nmax 100

void leggivet(int vet[], int n);
void stampavet(int vet[], int n);
void fusioneOrd(int v1[],int v2[],int v3[],int n,int m);
void bubblesort(int v[], int n);

int main(int argc, char *argv[])
while(n<=0 || n>100 || m>100 ||m<=0);
cout<<'Inserisci gli elenmenti del primo vettore'<<endl;
leggivet(v1,n);
bubblesort(v1,n);
stampavet(v1,n);

cout<<'Inserisci gli elenmenti del secondo vettore'<<endl;
leggivet(v2,m);
bubblesort(v2,m);
stampavet(v2,m);

cout<<'Fusione dei due vettori:'<<endl;
fusioneOrd(v1,v2,v3,n,m);
stampavet(v3,n+m);

system('PAUSE');
return 0;



void leggivet(int vet[], int n)






void stampavet(int vet[], int n)



void fusioneOrd(int v1[],int v2[],int v3[],int n,int m)

while(((v2[j]<=v1[i])||(i==n))&&(j<m))





void bubblesort(int v[], int n)

/* Sviluppare un programma C++ che legge e memorizza una stringa di caratteri(massimo 60) contenente

una serie di parole separate da spazio e stampa a video solo le parole piu' lunghe di 7 caratteri.Il

programma deve essere strutturato come segue:

- Il main legge e memorizza la stringa,utilizza una funzione estraiParola e stampa le parole piu'

lunghe di 7 caratteri.

- La funzione estraiParola data la stringa e l'indice i da cui iniziare la scansione della stringa

restituisce la parola identificata a partire dalla posizione i e la sua lunghezza. */

#include <iostream>
#include <stdlib.h>
#include 'header.h'


int main(int argc, char *argv[])

HEADER

using namespace std;
const int MAX_LEN=60;
void contalettere(char str[MAX_LEN],const int MAX_LEN);
void stampaparola (char str[MAX_LEN],const int iniz,const int i);

FUNZIONI

void contalettere(char str[MAX_LEN],const int MAX_LEN)
else iniz=i+1;
}

}

}

void stampaparola (char str[MAX_LEN],const int iniz,const int i)

MODO ALTERNATIVO

#include <iostream>
#include <stdlib.h>
#define MAX 60
typedef char stringa[MAX];
using namespace std;

void estrai(stringa s,stringa t,int &i,int &l)
           else break;
     }
     t[l]='0';
     i=(j+1);
}

int main()

    }
    if(cont==0) cout<<'Nessuna parola ha dimensione maggiore/uguale di 7!'<<endl;
   
    system('pause');
    return(1);
}

#include <cstdlib>

#include <iostream>

#include <string.h>

#include 'header.h';

using namespace std;

int main(int argc, char *argv[])

}

else

cout<<'ntt ** La parola non supera i 7 caratteri!!

}

cout<<endl;

system('PAUSE');

return EXIT_SUCCESS;

// PROROTIPI FUNZIONI

int estraiParola(char[],int &,int);

const int n=60;

int estraiParola(char s[],int &i,int lung)

return(i);

}

*/palindromi

#include <iostream>
#include <stdlib.h>
#include <string.h>

const int DIM=100;

using namespace std;
bool palindroma(char S[],const int l);
int main(int argc, char *argv[])

bool palindroma(char S[],const int l)else

return trovato;

/* Sviluppare un programma C++ che legge e memorizza una stringa di caratteri (massimo 60), costituita

esclusivamente da lettere dell'alfabeto,ed una lettera L ed elimina dalla stringa tutte le lettere

alfabeticamente maggiori di L, sia maiuscole che minuscole. Il programma deve essere strutturato come segue:

- Il main legge e memorizza la stringa,legge il carattere L,chiama una funzione EliminaLettera e stampa la stringa

modificata.

- La funzione EliminaLettera data la stringa e la lettera L elimina dalla stringa tutte le lettere alfabeticamente

maggiori di L e restituisce inoltre il numero di caratteri eliminati dalla stringa.*/

#include <iostream>
#include <stdlib.h>
//inclusione per la funzione toupper() che restituisce la maiuscola del carattere fornitole.
#include <ctype.h>
#define MAX 60
typedef char stringa[MAX];
using namespace std;

void shifta(stringa s,int p)

int eliminalettera(stringa s,char L)
    else i++;
}         
return c;
}

int main()

modo alternativo:

#include <cstdlib>

#include <iostream>

#include <string.h>

#include 'header.h'

using namespace std;

int main(int argc, char *argv[])

//prototipi e funzioni

int EliminaLettera(char[],char);

const int n=60;

int EliminaLettera(char s[],char L)

cont++;

i--;

i++;

}

return(cont);

*/unione di 2 vettori in un terzo,ma se gli elementi sono comuni ad entrambi nn li scrive

#include <iostream>

#include <stdlib.h>

#define MAX 50

typedef int vettore[MAX];

using namespace std;

void carica(vettore v,int &n)

}

void vedi(vettore v,int n)

bool nonce(vettore v,int p,int a)

void unisci(vettore A,vettore B,int n1,int n2)

else d--;

}

for(i=0; i<n2; i++)

else d--;

cout<<endl<<'Il vettore C e':';

vedi(C,d);

int main()

*/ Dato un vettore di N componenti,con N <=100,e un numero X,costruisci un vettore le cui componenti di indice pari siano uguale a quelle di indice pari del vettore moltiplicate per X e quelle di indice dispari siano uguali a quelle di indice dispari del vettore dato,incrementate di X.

#include <iostream>
#include <stdlib.h>
#define MAX 100
typedef int vettore[MAX];
using namespace std;

void carica(vettore v,int n)
     
}

//OCCHIO: SE INTENDI PER PARI I POSTI 2,4,,2N VA BENE COSI', ALTRIMENTI CAMBIA i%2!=0 CON i%2==0
void costruisci(vettore v1,vettore v2,int n,int x)     
}

void vedi(vettore v,int n)

int main()

*/Dati due vettori d N componenti,con N<=100,costruisci un terzo vettore le cui componenti sn prese alternativamente una dal primo vettore e l'altra dal secondo.Nel caso in cui i due vettori nn dovessero avere la stessa lunghezza copia la parte rimanente del vettore più lungo.

#include <iostream>
#include <stdlib.h>
#define MAX 100
using namespace std;
typedef int vettore[MAX];


void carica(vettore v,int &n)while((n<0)||(n>100)); //controllo lettura fattore di riempimento per n di [0;100]
     for(int i=0; i<n; i++)
     }

void vedi(vettore v,int n)


void costruire(vettore v1,int n1,vettore v2,int n2,vettore v3,int &n3)//assegno ed imposto la lettura di v2
              else//se primo è falso leggo il secondo vettore, v2
             
                          else i--;
                  primo=true;}//imposto la lettura di v1
              }//fine ciclo for di n1
             
     if(n1<n2)}
     //l'else è inutile perchè significa che n1 è il più grande, e l'ho ipotizzato già con il ciclo for!!!
     
     n3=i;//creo n3, cioè il fattore di riempimento, per il vettore v3
}

int main()

Data una matrice quadrata di dimensioni NxN;
scrivere un programma che, facendo uso di opportune procedure e/o funzioni:
1) calcoli la somma della diagonale principale e della diagonale secondaria;
2) esegua la trasposta della matrice;
3) verifichi che la somma delle due diagonali è rimasta invariata dopo la trasposizione,
4) stampi a video le 2 somme prima e dopo la trasposizione.

#include <iostream>
#include <stdlib.h>
#define MAX 50
typedef int matrice[MAX][MAX];
using namespace std;

void carica(matrice m,int n)
     }

void vedi(matrice m,int n)
     }

int diagp(matrice m,int n)
   
int diags(matrice m,int n)

void trasposta(matrice m,matrice t,int n)

void verifica(matrice m,matrice t,int n)

int main()

codice scrivi_mat e trasp

void trasposta (int M[][DIM], int dim)


void scrivi_mat (int M[][DIM], int dim)
cout<<endl;

*/Scrivere un programma ke crei una matrice contenente una tavola pitagorica di ordine N.

#include <iostream>
#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])


//riempimento prima colonna
for(int i=0;i<n;i++)

//calcolo tabella
for(int i=1;i<n;i++)


//stampa
for(int i=0;i<n;i++)
cout<<endl;


system('PAUSE');
return 0;

allora il programma come l'ho fatto io funziona in due parti quella che mi chiedi tu è proprio la prima, cioé riempi la colonna 0 e la riga 0 dei valori da 1 a n che sono gli elementi da cui partire per riempire la matrice

//riempimento prima riga.
for (int i=0;i<n;i++)

quindi ti scrive alla prima riga i valori 1 2 3 . n

//riempimento prima colonna
for(int i=0;i<n;i++)

invece ti scrive gli stessi valori nella colonna 0

//calcolo tabella
for(int i=1;i<n;i++)


infine ti calcola tutti gli altri valori.

Modo alternativo

for(int i=0;i<n;i++)
}

*/cancellazione di una riga da una matrice

#include <iostream>
#include <stdlib.h>
typedef int matrice[50][50];
using namespace std;


void carica(matrice m,int nr,int nc)     
}

//PROCEDURE FONDAMENTALE
void elimina(matrice m,int &nr,int nc,int riga)

void vedi(matrice m,int nr,int nc)
                 }

int main()

*/Dovevi leggere una frase con spazi e segni di punteggiatura;
Trovare le singole parole e stamparle in ordine inverso con la lunghezza.

#include <iostream>
#include <stdlib.h>
#define MAX 100
typedef char stringa[MAX];
typedef char matrice[MAX][MAX];
using namespace std;

void leggi(stringa s)
}

//OCCHIO ALLA PROCEDURE: carica in una matrice per riga le stringhe e le stampa partendo dall'ultima riga
void stampa(stringa s)
            m[i][j+1]='0';i++;}//chiudo la i-esima riga con 0 e procedo per la successiva
            else c++;
    }
    j=0;
    //procedo per la stampa delle righe a partire dall'ultima con valore nr-1!
    int nr=i;
    for(i=nr-1; i>=0; i--)
                        cout<<endl;j=0;}
}

int main()

Raga ho provato a fare un'altra variante del problema all'esame di Lanna, sempre usando due funzioni, e il programma dovrebbe funzionare anche senza punto finale e con spazi messi a casaccio, ciao.

#include <iostream>
#include <stdlib.h>
#define MAX 100
typedef char stringa[MAX];
using namespace std;

void leggi(stringa s)

void stampa(stringa s)
                                //ne stampiamo la dimensione
                                cout<<' di dimensione '<<strlen(t)<<endl;
                                //azzeriamo tutto per passare alla prossima parola
                                t[0]='0';
                                par=false;
                                }
                    //costruisco la parola, che però è l'inversa di quella originaria : oaic -> ciao
                    else if (s[i]!=' ')
                         
                    }
}

int main()

inizio con par=false; significa che per il momento non sto leggendo una parola!

Nel ciclo passando tra i vari caratteri, appena incontro uno diverso dallo spazio, imposto par a true, ciò significa che sto leggendo una parola e la memorizzo carattere per carattere nella stringa temporanea t.
codice

Quando arrivo ad uno spazio(o all'inizio della stringa (i=0!)) e contemporaneamente stavo leggendo una parola(par=true) allora posso stampare la parola che finalmente è finita a predisporre di nuovo alla prossima lettura di parola(par=false)!
codice

Quindi quella variabile par booleana serve per capire se quando ci si trova ad un carattere, stiamo nel frattempo leggendo o meno una parola

Ti spiego il problema se non metto par:
io appena inizio a leggere una parola ed arrivo al primo spazio che incontro scalando la stringa a scendere, devo stampare quella parola(per evitare di usare altre variabili di memorizzazione!). Allora uso par per evitare che vengano prese in considerazione anche parole formate da una serie di spazi

Oppure altrOMODO

prototipi.h

prototipi.cpp

main

Dovrebbe funzionare anche con più spazi messi a casaccio, con punto non vicino all'ultima parola e anche se non si inserisce il punto!

*/Data una matrice Mat quadrata,trova gli indici e il valore della componente più grande e di quella più piccola

#include <cstdlib>
#include <iostream>
#include <string.h>
const int DIM=100;
void leggi(int M[][DIM],int & n);
void scrivi_mat (int M[][DIM], int dim);
int minimo(int M[][DIM],int dim,int & i,int &j);
int massimo(int M[][DIM],int dim,int & i,int &j);
using namespace std;

int main(int argc, char *argv[])

void leggi(int M[][DIM],int & n)


void scrivi_mat (int M[][DIM], int dim)
cout<<endl;

int minimo(int M[][DIM],int dim,int &i,int &j)

return min;

int massimo(int M[][DIM],int dim,int &i,int &j)

return max;

ALTRO MODO

MAIN:
#include <iostream>
#include <cstdlib>
#include 'prototipi.h'

using namespace std;

int main()


FUNZIONI:

#include <iostream>
#include <cstdlib>
#include 'prototipi.h'

using namespace std;

int leggi_dim_righe()

while (e);
return r;


int leggi_dim_colonne()

while (e);
return c;


void leggi_matrix(matrix M,int r,int c)




void stampa(matrix M,int r,int c)





void elimina_riga_colonna(matrix M,int r,int c)


else

break;
case 2:
cout<<endl<<'inserire la colonna da cancellare: ';
cin>>del;
if(del<=c)


else

break;
default:
cout<<endl<<'sparati e chiedi a qualcuno di inserire dati coerenti';

if(del==1 || del==2)



void operazione(matrix M,int r,int c)



void minimo(matrix M,int r,int c)



cout<<endl<<'il minimo e': '<<min<<' alla posizione ['<<p<<']['<<q<<']'<<endl;


void massimo(matrix M,int r,int c)



cout<<endl<<'il massimo e': '<<max<<' alla posizione ['<<p<<']['<<q<<']'<<endl;


HELPER:

#ifndef prototipi
#define prototipi

const int max=100;
typedef int matrix[max][max];

int leggi_dim_righe();

int leggi_dim_colonne();

void leggi_matrix(matrix M,int r,int c);

void stampa(matrix M,int r,int c);

void elimina_riga_colonna(matrix M,int r,int c);

void operazione(matrix M,int r,int c);

void minimo(matrix M,int r,int c);

void massimo(matrix M,int r,int c);

#endif

P.S.
ci ho aggiunto anche l'annullamento di righe e/o colonne

ALTRO MODO

#include <iostream>
#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])


int COMP=0;
int indR, indC;

//componente più grande
for(int i=0;i<n;i++)



int comp=M[0][0];
int indRc,indCc;

//componente più piccola
for(int i=0;i<n;i++)



cout<<'Il valore della componente piu' grande e''<<COMP<<' e i suoi indici sono: '<<indR<<' '<<indC<<endl;

cout<<'Il valore della componente piu' piccola e''<<comp<<' e i suoi indici sono: '<<indRc<<' '<<indCc<<endl;

system('PAUSE');
return 0;

Scrivi un programma ke esamini una matrice quadrata e determini quante sono le righe e le colonne composte da elementi tutti nulli

#include <iostream>
#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])



int h=0;
int k=0;

//controllo riga
for(int i=0;i<n;i++)


//controllo colonna
for (int j=0;j<n;j++)



cout<<'la matrice ha '<<h<<' righe composte da elementi tutti nullin';
cout<<'la matrice ha '<<k<<' colonne composte da elementi tutti nullin';

//stampa
for(int i=0;i<n;i++)
cout<<endl;

system('PAUSE');
return 0;

il programma che fa ti esamina tutti gli elementi della riga

al primo elemento non nullo si stoppa il secondo ciclo for che riprende dal primo elemtno della riga successiva;

se invece completa il ciclo giunge fino all'ultimo elemento quindi j=n-1 allora vuol dire che la riga è tutta composta da elementi nulli e il contatore h viene aumentato di uno.

ALTRO MODO

#include <stdlib.h>

using namespace std;
const int DIM=50;

void scrivi_matrice (int [][DIM],int );
bool esamina_riga (int [][DIM],int ,int );
bool esamina_colonna (int[][DIM],int , int );

int main(int argc, char *argv[])
while(fine);
system('PAUSE');
return 0;
}

void scrivi_matrice (int Matrice [][DIM],int fill)

if (esamina_riga (Matrice,fill,i))
}
for (j=0; j<fill; j++)
}
cout<<'n Il numero di righe nulle e': '<<row<<endl;
cout<<'n Il numero di colonne nulle e': '<<col<<endl;
}

bool esamina_riga (int Matrice[][DIM],int fill,int i)

return trovato;
}

bool esamina_colonna (int Matrice[][DIM],int fill,int j)

return trovato;
}

MODO ALTERNATIVO

void conta_nulle(matrix M,int r,int c)


if(zeri==c)

j++;

cout<<endl<<'nella frase sono presenti '<<nulle<<' righe nulle'<<endl;

Scrivere un programma ke consideri una matrice rettangolare intera con N righe e M colonne,con N e M <50, ke svolga le le seguenti operazioni:

- Determini se gli elementi nulli della matrice sono in percentuale maggiore dell'80% del totale degli elementi.

-se nel passo precedente la risposta è stata affermativa,visualizzi i soli elementi nn nulli della matrice.

#include <iostream>
#include <stdlib.h>
#define MAX 50
typedef int matrice[MAX][MAX];
using namespace std;

void carica(matrice m,int &nr,int &nc)
     }
}

void vedi(matrice m,int nr,int nc)
}

void visualizza(matrice m,int nr,int nc)
}

void verifica(matrice m,int nr,int nc)
     
     int TOT=((nr*nc)*80)/100;
     cout<<endl<<'Sono nulli: '<<nulli<<'su'<<TOT<<'(che e' l'80%)!'<<endl;     
     if(nulli>TOT)
         visualizza(m,nr,nc);
     else
         cout<<endl<<'Non e' stato raggiunto l'80% degli elementi nulli su quelli totali!';
}

int main()

MODO ALTERNATIVO

const int iN = 30;
const int iM = 45;

//
int tabella[iN][iM];

//

int iNumElementi = iN*iM;
int iNumMaxNulli = (iNumElementi / 100) * 80;

int iNumNulli = 0;

for(int i = 0; i < iN; i++)
 for(int k = 0; k < iM; k++)
 

if(iNumNulli > iNumMaxNulli)

}

*/GIOCO DEL TRIS

MAIN:
#include <iostream>
#include <cstdlib>
#include 'prototipi.h'

using namespace std;

int main()


FUNZIONI:

#include <iostream>
#include <cstdlib>
#include 'prototipi.h'

using namespace std;

void assegna(griglia T)




void presentazione(nome n1,nome n2)



void stampa(griglia T)



cout<<endl;


void giocatore1(griglia T)

else



void giocatore2(griglia T)

else



void gioco(griglia T,nome n1,nome n2)

if(i%2==1 && a==0)

i++;



void verifica_tris(griglia M,int &o,nome n1,nome n2)

if((M[1][1]=='X' && M[2][1]=='X' && M[3][1]=='X')||(M[1][2]=='X' && M[2][2]=='X' && M[3][2]=='X')||(M[1][3]=='X' && M[2][3]=='X' && M[3][3]=='X'))

if((M[1][1]=='X' && M[2][2]=='X' && M[3][3]=='X')||(M[1][3]=='X' && M[2][2]=='X' && M[3][1]=='X'))

if((M[1][1]=='O' && M[1][2]=='O' && M[1][3]=='O')||(M[2][1]=='O' && M[2][2]=='O' && M[2][3]=='O')||(M[3][1]=='O' && M[3][2]=='O' && M[3][3]=='O'))

if((M[1][1]=='O' && M[2][1]=='O' && M[3][1]=='O')||(M[1][2]=='O' && M[2][2]=='O' && M[3][2]=='O')||(M[1][3]=='O' && M[2][3]=='O' && M[3][3]=='O'))

if((M[1][1]=='O' && M[2][2]=='O' && M[3][3]=='O')||(M[1][3]=='O' && M[2][2]=='O' && M[3][1]=='O'))



HELPER:

#ifndef prototipi
#define prototipi

typedef char griglia[3][3];
const int max=60;
typedef char nome[max];

void assegna(griglia T);

void stampa(griglia T);

void giocatore1(griglia T);

void giocatore2(griglia T);

void gioco(griglia T,nome n1,nome n2);

void verifica_tris(griglia M,int &o,nome n1,nome n2);

void presentazione(nome n1,nome n2);

#endif

//PROGRAMMI PROF

#include <iostream.h>

#include <stdlib.h>

typedef char Stringa[30];

typedef struct Studente

void leggiStruct(Studente * s);

void stampaStruct(Studente s);

int contenuta(Stringa s1, Stringa S2);

int main()

void leggiStruct(Studente * s)

void stampaStruct(Studente s)

int contenuta(Stringa v1, Stringa v2)

while((v1[i]==v2[j])&(v1[i]!='0')&(v2[j]!='0'));

//sono arrivato alla fine della seconda stringa, quindi è contenuta nella prima

if(v2[j]=='0') cont=1;

else

// stringa non contenuta a partire dalla posizione again-1, provo dalla //posizione again

i=again;

}

else i++;

return cont;

2) #include <iostream.h>

#include <stdlib.h>

#define N 100

int contaP(char v[]);

int main()

int contaP(char v[])

while(v[i]!='0')

return occ;

3) #include <iostream.h>

#include <stdlib.h>

#define N 100

bool contenuta(char v1[], char v2[]);

int main()

else

if(!cont) cout<<'nessuna delle stringhe e' contenuta nell'altran';

system('PAUSE');

return 0;

bool contenuta(char v1[], char v2[])

while((v1[i]==v2[j])&(v1[i]!='0')&(v2[j]!='0'));

//sono arrivato alla fine della seconda stringa, quindi è contenuta nella prima

if(v2[j]=='0') cont=true;

else

// stringa non contenuta a partire dalla posizione again-1, provo dalla posizione again

i=again;

}

else i++;

return cont;

4) #include <iostream.h>

#include <stdlib.h>

#define N 31

using namespace std;

void scambia(char *a, char *b);

int lung(char s[]);

void inverti2(char v[]);

int main()

void scambia(char *a, char *b)

/* Funzione che calcola la lunghezza della stringa */

int lung(char s[])

void inverti2(char v[])

5) #include <iostream.h>

#include <stdlib.h>

#define N 31

int conta(char v[],char x);

int main()

int conta(char v[],char x)

return occ;

6) #include <stdio.h>

#include <stdlib.h>

#include <iostream>

typedef char stringa[30] ;

typedef struct contatto

void ordina(contatto v[], int n);

void stampaStruct(contatto s);

void inserisciRecord(contatto v[], int *n);

void main()

break;

case 4: stop=1;

break;

default: cout<<'Opzione non valida n';

}

}

while(stop==0);

void inserisciRecord(contatto v [ ], int * n)

*n=i;

void ordina(contatto v [ ], int n)

void stampaStruct(contatto s)

7) #include <iostream.h>

#include <stdlib.h>

void leggid(int &giorno, int &mese);

void legginascita(int &giorno_n, int &mese_n);

void verifica( int giorno, int mese, int giorno_n, int mese_n, bool auguri);

int main()

8) #include <iostream>

#include <stdlib.h>

using namespace std;

// calcola la media di 3 elementi inseriti da tastiera

int main()

9) #include <iostream>

#include <stdlib.h>

using namespace std;

// dati tre valori, cerca il minimo ed il massimo

int main()

10) // scrivere un programma che legga due vettori di dimensioni dim1 e dim2 e che

// permetta di verificare se i due vettori sono uguali;

// scrivere due versioni del programma, la prima che fa utilizzo del costrutto FOR e la seconda che fa uso del costrutto WHILE

#include <iostream>

#include <stdlib.h>

using namespace std;

#define nmax 100

int main()

while(dim1<=0 || dim1>100);

cout<<'Inserisci gli elenmenti del primo vettore'<<endl;

for(i=0;i<dim1;i++)

dowhile(dim2<=0 || dim2>100);

cout<<'Inserisci gli elenmenti del secondo vettore'<<endl;

for(i=0;i<dim2;i++)

//questo pezzo di codice verifica se i due vettori sono uguali ed utilizza l'istruzione FOR

cout<<'Comincia la sezione di controllo con il for'<<endl;

ris=0;

if(dim1==dim2)

} //chiusura del for

if(ris==dim1)

else

} //chiusura del primo if

else cout<<'i due vettori hanno dimensioni diverse'<<endl;

//questo pezzo di codice verifica se i due vettori sono uguali ed utilizza l'istruzione WHILE

cout<<'Comincia la sezione di controllo con il while'<<endl;

if(dim1==dim2) //chiusura del while

if(i==dim1)

else

} //chiusura del primo if

else cout<<'i due vettori hanno dimensioni diverse'<<endl;

// /* versione alternativa con i cili while:

cout<<'Comincia la sezione 2 di controllo con il while'<<endl;

if(dim1==dim2)

i++;

} //chiusura del while

if(uguali)

else

} //chiusura del primo if

else cout<<'i due vettori hanno dimensioni diverse'<<endl;

// */

system('PAUSE');

return 0;

11) #include <iostream>

#include <stdlib.h>

using namespace std;

//Inverte gli elementi di un vettore inserito da tastiera

int main()

//Inverti

for (i=0; i<(n/2); i++)

//Stampa il risultato

cout<<'Il vettore invertito e':'<<endl;

for (i=0; i<n; i++)

system('PAUSE');

12) // ricerca del massimo e del minimo in una matrice

#include<iostream.h>

#include<stdlib.h>

void main()

//stampa elementi della matrice

for(i=0;i<r;i++)

max=mat[0][0];

min=mat[0][0];

for(i=0;i<r;i++)

for(j=0;j<c;j++)

cout<<'n il max='<<max<<' il min='<<min<<endl;

system('PAUSE');

13) // scrivere un programma che permetta di leggere un vettore di

// elementi di tipo intero di lunghezza massima pari a 100 e

// permetta di ricercare se un elemento inserito da testiera è contenuto nel vettore

#include <iostream>

#include <stdlib.h>

using namespace std;

#define nmax 100

int main()

while(n<=0 || n>100);

cout<<'Inserisci gli elementi del vettore'<<endl;

for(i=0;i<n;i++)

cout<<'Inserisci l'elemento da cercare'<<endl;

cin>>x;

i=0;

while((i<n)&&(trovato==false))

if(trovato)

cout<<'L'elemento e' presente nell'array con indice'<<i<<endl;

else

cout<<'L'elemento non e' presente nell'array'<<endl;

system('PAUSE');                                                                

return 0;

Scrivere un programma che dati due vettori di dimensione dim1 e dim2, con dim1>dim2,

verifica che un vettore sia contenuto in un altro.

#include <iostream>

#include <stdlib.h>

using namespace std;

#define nmax 100

int main()

while(dim1<=0 || dim1>100);

cout<<'Inserisci gli elenmenti del primo vettore'<<endl;

for(i=0;i<dim1;i++)

dowhile(dim2<=0 || dim2>100 || dim2>dim1);

cout<<'Inserisci gli elenmenti del secondo vettore'<<endl;

for(i=0;i<dim2;i++)

int contenuto=0, again=0;;

i=0;j=0;

while((contenuto==0) && (i<dim1-dim2+1))

if(j==dim2)

contenuto=1;

else

i=again;

else i++;

}

if(contenuto==1)

else

cout<<'il vettore 1 non e' contenuto nell'altro'<<endl;

system('PAUSE');                                                                

return 0;

15) // scrivere una funzione che calcoli la media di una quantità variabile di numeri e la stampi nel main

// usare una funzione per leggere i valori da tastiera;

#include <iostream.h>

#include <stdlib.h>

int ValueRead(int i);

float media(int n);

int main()

float media(int n)

med=somma/n;

return med;

int ValueRead(int i)

16) // scrivere una funzione che legga un valore da tastiera e lo stampi nel main

#include <iostream.h>

#include <stdlib.h>

int ValueRead(void);

int main()

int ValueRead(void)

17) // scrivere una procedura che scambia due valori inseriti da tastiera

#include <iostream.h>

#include <stdlib.h>

void scambio(int *A, int *B);

int main()

void scambio(int *A, int *B)

18) //scrivere una procedura ed una funzione per eseguire la somma di due variabili

#include <iostream.h>

#include <stdlib.h>

void somma(int a, int b, int *s);

int som(int a, int b);

int main()

void somma(int a, int b, int *s)

int som(int a, int b)

19) // scrivere una procedura che legga un valore da tastiera e lo stampi nel main

#include <iostream.h>

#include <stdlib.h>

void ValueRead(int *val);

int main()

void ValueRead(int *val)

20) #include <stdlib.h>

#include <iostream>

typedef char Stringa[30];

typedef struct Studente

int main()

cout<<'Stampa degli studenti ';

for (i=0;i<n;i++)

system('PAUSE');

return 0;

21) #include <stdio.h>

#include <stdlib.h>

#include <iostream>

typedef char Stringa[30];

typedef struct Studente

void leggiStruct(Studente * s);

void stampaStruct(Studente s);

int main()

void leggiStruct(Studente * s)

void stampaStruct(Studente s)

22) #include <stdio.h>

#include <stdlib.h>

#include <iostream>

typedef char Stringa[30];

typedef struct Studente

void leggiStruct(Studente v[],int n);

void stampaStruct(Studente v[], int n);

int main()

void leggiStruct(Studente v[],int n)

/*

printf('Inserisci nome n');

gets(s->nome);

printf('Inserisci cognome n');

gets(s->cognome);

printf('Inserisci anni n');

scanf('%d',&(s->anni));

fflush(stdin);

*/

void stampaStruct(Studente v[],int n)

23) // ricerca della riga di somma massima in una matrice

#include<iostream.h>

#include<stdlib.h>

void leggimat(int M[100][100],int *r, int *c);

void stampamat(int M[100][100],int r, int c);

void riga_max(int M[100][100],int r, int c, int *pos_riga, int *sommamax);

void main()

void leggimat(int M[][100],int *r, int *c)

}

void stampamat(int M[100][100],int r, int c)

}

void riga_max(int M[100][100],int r, int c, int *pos_riga, int *sommamax)

}

//Iniziliazzazione della variabile max e della posizione

*sommamax=vet[0];

*pos_riga=0;

//Ricerca massimo

for (i=1; i<r; i++)

}

}

24) // scrivere una procedura che calcola la somma degli elementi di posto pari di un vettore

#include <iostream.h>

#include <stdlib.h>

void VectRead(int V[],int *dim);

void VectWrite(int V[],int dim);

void SommaPari(int V[],int dim, int *sommapari);

int main()

void VectRead(int V[],int *dim)

void VectWrite(int V[],int dim)

void SommaPari(int V[],int dim, int *sommapari)

25) // scrivere una funzione che restituisce il valore massimo contenuto in un vettore

#include <iostream.h>

#include <stdlib.h>

void VectRead(int V[],int dim);

void VectWrite(int V[],int dim);

int Max(int V[],int dim);

int main()

void VectRead(int V[],int dim)

void VectWrite(int V[],int dim)

int Max(int V[],int dim)

return max;

26) // scrivere una funzione che restituisce la posizione di un elemento contenuto in un vettore

#include <iostream.h>

#include <stdlib.h>

void VectRead(int V[],int dim);

void VectWrite(int V[],int dim);

int Search(int V[],int dim,int value);

int main()

void VectRead(int V[],int dim)

void VectWrite(int V[],int dim)

int Search(int V[],int dim,int Value)

i++;

}

if (i==dim) else

return pos;

27) // scrivere due procedure per leggere e stampare un vettore

#include <iostream.h>

#include <stdlib.h>

void VectRead(int V[],int dim);

void VectWrite(int V[],int dim);

int main()

void VectRead(int V[],int dim)

void VectWrite(int V[],int dim)

TESTI ESERCIZI

Esercizi per l'esame di

Elementi di Informatica

Di seguito sono proposti alcuni esercizi da presentare per la prova orale di Elementi di Informatica. Gli esercizi devono essere svolti in C. Per ogni esercizio va fornita una breve descrizione della traccia e della soluzione utilizzata e due casi di prova utilizzati per verificare la correttezza dell'esercizio svolto.

Sviluppare tre sottoprogramma per: leggere, scrivere e ordinare un vettore. Sviluppare, inoltre, un programma principale che utilizzi i tre sottoprogrammi.

Assegnati due vettori A e B si ordinino in senso crescente i vettori e si determini un nuovo vettore C ottenuto dalla fusione di A e B mantenendo l'ordinamento. Per lo sviluppo del programma si utilizzino ove possibile sottoprogrammi.

Assegnata una matrice si sviluppi un programma per eseguire la trasposta

Sviluppare un sottoprogramma per la risoluzione delle equazioni di secondo grado.

Assegnata una matrice si determini la riga che contiene il massimo numero di elementi con valore pari a 0.

Si leggano due stringhe S e T e si determini il numero delle volte e le posizioni in cui S e contenuta in T. Si sviluppi il programma in due diverse modalità: utilizzando sottoprogrammi specificamente sviluppati o utilizzando le funzioni standard del C.

Si determini un vettore di record formato di tra campi: nome cognome matricola e si sviluppi un programma che consenta la ricerca su uno solo dei campi o su una combinazione dei tre campi.

Assegnata una matrice quadrata si invertano gli elementi della diagonale principale e di quella secondaria.

Assegnata una stringa che contiene uno o più spazi bianchi tra le parole si determini una nuova stinga che contiene solo uno spazio bianco tra le parole.

Assegnata una matrice si determini la riga in cui la somma degli elementi è massima e la si inverta con quella in cui la somma degli elementi è minima. Se due righe hanno la stessa somma minima o massima si esegua l'operazione tra le righe che hanno valore si indice minore.

Data una matrice, scrivere una procedura che consenta di ordinare in ordine crescente gli elementi delle righe, stampare la matrice ordinata, ad esempio

A = B=

8 4 6 5 4 5 6 8

1 2 3 5

Data una matrice, scrivere una procedura che sostituisca gli elementi di indice di colonna dispari con i pari precedenti. Ad esempio:

A =                             B=

8 4 6 5 4 8 5 6

2 3 5 1

Data una matrice, scrivere una procedura che consenta di scambiare le righe di posto dispari con le righe di indice pari precedenti (lavorare per coppie di righe). Ad esempio:

A =                             B=

8 4 6 5 3 2 1 5

8 4 6 5

2 3 5 1

2 3 5 1 4 8 5 6

Data una matrice quadrata, scrivere una procedura che consenta di scambiare le due diagonali.

Esercizio 1:

Data una matrice quadrata di dimensioni NxN;

scrivere un programma che, facendo uso di opportune procedure e/o funzioni:

calcoli la somma della diagonale principale e della diagonale secondaria;

esegua la trasposta della matrice;

verifichi che la somma delle due diagonali è rimasta invariata dopo la trasposizione,

stampi a video le 2 somme prima e dopo la trasposizione.

Esercizio 2:

Si leggano due matrici A[N][N] e B[N][N] da tastiera. Si costruisca quindi una matrice C[N][2N] costruita nel seguente modo:

Le righe di indice dispari della matrice C devono essere ottenute ordinando le righe di indici omologhi delle matrici A e B. Le righe di indice pari della matrice devono essere ottenute accodando gli elementi delle righe di indice omologo di B a quelli di A

Si utilizzino procedura sia per la lettura delle matrici sia per l'ordinamento.

ES:

1 6 2 - 2 4 0 1 6 2 -2 4 0

A = -4 3 0 B= 9 -1 4 C= -4 -1 0 3 4 9

9 1 3 1 4 7 9 1 3 1 4 7

Esercizio 3:

Date 3 stringhe S1,S2 ed S3, ogni volta che si trova una sottostringa di S1 che coincide con S2, si sostituisca a tale sottostringa (in S1) S3.

Es:

S1 = ciao mondo crudele S2 = mondo S3 = universo

S1 = ciao universo crudele

28) #include <iostream.h>

#include <stdlib.h>

#include 'matrici.h'

int main()

const int MAX_DIM=10;

typedef int vettore[MAX_DIM];

typedef vettore matrice[MAX_DIM];

void leggi(matrice,int &);

void leggi(matrice,int &,int &);

void stampa(const matrice,const int,const int);

void trasposta(matrice,const int);

void rigacolonna(matrice,matrice,matrice,const int,const int);

#include 'matrici.h'

#include <iostream.h>

void leggi(matrice mat, int &riga, int &col)

void leggi(matrice mat, int &riemp)

void scambia (matrice mat, const int i, const int j)

void trasposta(matrice mat, const int riemp)

void stampa (const matrice mat,const int riga,const int col)

void rigacolonna(matrice mat1, matrice mat2, matrice mat3, const int riga, const int col)

29) #include <iostream>

#include <stdlib.h>

using namespace std;

// Programma per il calcolo del fattoriale.

// Provare il programma con valori di n pari

// a 0, 4 e 20.

int main () while (n < 0);

// Calcolo del fattoriale

i = 1;

fattoriale = 1;

while ( i <= n )

// Stampa del risultato

cout << 'nIl fattoriale di ' << n << ' e': ';

cout << fattoriale<<'nn';

system('PAUSE');

return 0;

30) #include <iostream>

#include <stdlib.h>

using namespace std;

int main() while (n>DIM);

// Lettura dei valori di V1

for (i=0;i<n;i++)

// Copia di V1 in V2

for (i=0;i<n;i++)

// Stampa di V2

cout<<'nEcco gli elementi di V2:n';

for (i=0;i<n;i++)

cout<< V2[i] << ' ';

cout<<'nn';

system('PAUSE');

return 0;

31) #include <iostream>

#include <stdlib.h>

using namespace std;

//DICHIARAZIONI

const int MAX=50;

typedef int vett[MAX];

//PROTOTIPI

void leggi(int &,vett);

bool cerca(int,const vett,int &,int &);

void stampa(bool,int,int);

int main()

//FUNZIONE DI LETTURA

void leggi (int &riemp,vett v)

//FUNZIONE DI RICERCA

bool cerca (int riemp,const vett v,int &val,int &ind)

else i++;

return trovato;

//FUNZIONE DI STAMPA

void stampa (bool trovato,int val,int ind)

else cout<<'nNon esiste nessun elemento di V avente valore negativo.nn';

32) /* E S E R C I Z I O

Siano date in ingresso da tastiera due stringhe di eguale lunghezza.

Si scriva un programma che conti il numero di caratteri in posizione

omologa che sono diversi e stampi il valore calcolato insieme al

contenuto delle due stringhe.

#include <iostream.h>

#include <stdlib.h>

#include <string.h>

// dichiarazioni

const int MAX_ELEM=30;

typedef char stringa[MAX_ELEM+1];

//prototipi

void leggi(stringa, stringa);

int calcola(const stringa, const stringa);

void stampa(int, const stringa, const stringa);

// definizione delle funzioni

void leggi(stringa s1, stringa s2)

int calcola(const stringa s1, const stringa s2)

void stampa(int n, const stringa s1, const stringa s2)

// main

int main()

33) /* E S E R C I Z I O

Siano dati in ingresso da tastiera il riempimento e gli elementi di un

vettore di interi V1. Si scriva un programma che copi in un secondo vettore

V2 gli elementi di valore pari del vettore V1, e stampi il vettore V2

cosi' ottenuto.

#include <iostream.h>

#include <stdlib.h>

// dichiarazioni

const int MAX_ELEM=30;

typedef int vett[MAX_ELEM];

//prototipi

void leggi(int &, vett);

void copia(int, const vett, int &, vett);

void stampa(int, const vett);

// definizione delle funzioni

void leggi(int &n, vett v)

void copia(int n1, const vett v1, int & n2, vett v2)

n2=j;

void stampa(int n, const vett v)

// main

int main()

Esercitazione del 13.12.2002

Siano assegnati da tastiera una stringa S e due caratteri c1 e c2.

Si progetti una funzione SOSTITUISCI che riceve in ingresso S, c1 e c2 e che sostituisce tutte le occorrenze del carattere c1

con il carattere c2. Tale funzione deve anche restituire come valore di ritorno il numero di sostituzioni effettuate.

Nel main bisognerà leggere, con una opportuna funzione, S, c1 e c2, e bisognerà stampare con una opportuna funzione la

stringa S dopo le sostituzioni ed il valore restituito dalla funzione SOSTITUISCI.

Esempi

INPUT:

S = astanti

c1 = a

c2 = i

OUTPUT:

S = istinti

num = 2

INPUT:

S = astanti

c1 = p

c2 = i

UTPUT:

S = astanti

num = 0

#include <iostream.h>

#include <stdlib.h>

#include <string.h>

const int MAX=50;

typedef char stringa[MAX+1];

// Prototipi

void leggi(stringa, char&, char&);

int sostituisci(stringa, char, char);

void stampa(const stringa, int);

int main()

void leggi(stringa s, char &c1, char &c2)

int sostituisci(stringa s, char c1, char c2)

return num;

void stampa(const stringa s, int num)

35) #include <fstream.h>

#include <stdlib.h>

const int MAX=50;

typedef int lista[MAX];

int main()

input.close();

n=i-1;

output.open('output.txt');

for (i=0;i<n;i++)

output << l[i] << ' ';

output.close();

return 0;

36)#include <iostream.h>

#include <stdlib.h>

#include <string.h>

const int LEN=30;

typedef char stringa[LEN];

void inserisci_in_ordine_stringa (stringa lista[LEN], int &n, stringa str)

else /* str >= lista[i] */

trovato = true;

strcpy(lista[i+1],str);

n++;

37) // =================== Scambia =================================

void scambia(int a[], const int i, const int j)

// =================== SelectSort =================================

void SelectSort(int a[], const int n)

// =================== BubbleSort =================================

void BubbleSort0 (int a[],const int n)

void BubbleSort (int a[], const int n)

i++;

}

38) #include <iostream.h>

#include <stdlib.h>

// dichiarazioni

const int MAX_ELEM=30;

typedef int vett[MAX_ELEM];

//prototipi

void leggi(int &, vett, int &);

bool ricerca(int, const vett, int);

void stampa(bool, int);

// definizione delle funzioni

void leggi(int &n, vett v, int &x)

cout<<'nInserire l'elemento da cercare: ';

cin>>x;

bool ricerca(int n, const vett v, int x)while (i<=j && v[k]!=x);

if (v[k]==x)

return true;

else return false;

void stampa(bool t, int x)

// main

int main()

39) #include <iostream.h>

#include <stdlib.h>

// dichiarazioni

const int MAX_ELEM=30;

typedef int vett[MAX_ELEM];

//prototipi

void leggi(int &, vett);

bool ricerca(int, const vett);

void stampa(int, const vett, bool);

// definizione delle funzioni

void leggi(int &n, vett v)

bool ricerca(int n, const vett v)

void stampa(int r, const vett a, bool t)

// main

int main()

40) #include <iostream.h>

#include <stdlib.h>

//Dichiarazioni

const int MAX=20;

typedef int vett[MAX];

//Prototipi

void leggi(int&, vett);

void ricerca_pd(int, const vett, int&, int&);

void stampa(int, int);

// main

int main()

//Definizioni funzioni

void leggi(int&n,vett v)

void ricerca_pd(int n,const vett v,int& pari,int& dispari)

void stampa(int pari,int dispari)

41) #include <string.h>

#include <iostream.h>

#include <stdlib.h>

//Dichiarazioni

int const MAX=20;

typedef char stringa[MAX+1];

//Prototipi

void leggi (stringa, char&);

int conta (const stringa, char c);

void stampa (int);

//Definizioni

void leggi (stringa s, char& c)

int conta(const stringa s, char c)

void stampa(int n_volte)

// main                

int main()

ESERCIZIO: si scriva un programma che legge da tastiera due stringhe s1 ed s2 e

costruisce un vettore V di interi avente tanti elementi quanti sono i caratteri

della prima stringa. L'i-esimo elemento di V deve contenere il numero di volte

che l'i-esimo carattere di s1 compare in s2.

es:

s1= pippo

s2= topolino

V = 1 1 1 1 3

#include <iostream.h>

#include <stdlib.h>

#include <string.h>

//Dichiarazioni

const int MAX=30;

typedef char stringa[MAX+1];

typedef int vett[MAX];

//Prototipi

void leggi (stringa,stringa);

void compara (stringa,const stringa,vett,int &);

void stampa (const stringa,const vett,const int);

//Definizioni

void leggi (stringa a,stringa b)

void compara (stringa a,const stringa b,vett v,int &n)

void stampa(const stringa a,const vett v,const int n)

//Main

int main()

43) #include <iostream>

#include <stdlib.h>

using namespace std;

int main()

cout<<'nnSECONDO MODO DI RISOLVERE IL PROBLEMA';

cout<<'nLa somma dei primi n numeri e': ' <<somma;

cout<<'nn';

system('PAUSE');

return 0;

44) #include <iostream>

#include <stdlib.h>

using namespace std;

int main() while (a+b<=c || a+c<=b || b+c<=a);

if (a==b && b==c)

cout<< 'Triangolo equilatero';

else if (a==b || a==c || b==c)

cout<< 'Triangolo isoscele';

else cout<< 'Triangolo scaleno';

system('PAUSE');

return 0;

45) #include <iostream>

#include <stdlib.h>

using namespace std;

int main()

46) // Prototipi

int strlen(const char s[]);

int strcmp(const char s[], const char t[]);

void strcpy(char s[], const char t[]);

void strrev(char s[]);

void scambia(char s[],const int i,const int j);

// Funzioni

int strlen(const char s[])

int strcmp(const char s[], const char t[])

return s[i]-t[i];

void strcpy(char s[], const char t[])

s[i]='0';

void strrev(char s[])

void scambia(char s[], const int i, const int j)

47) #include <iostream>

#include <string.h>

#include <stdlib.h>

using namespace std;

const int MAX_DIM=16;

typedef char stringa[MAX_DIM];

void leggi(int &numero,int &base)

void converti(int numero,const int base, stringa str)

str[i++]=ch[numero];

str[i]='0';

strrev(str);

void stampa (const stringa str)

int main ()

48) /* E S E R C I Z I O

Siano date in ingresso da tastiera due stringhe (s1 ed s2) di eguale lunghezza.

Si scriva un programma che costruisca una terza stringa s3 costituita dai caratteri

in posizione omologa di s1 ed s2 che sono uguali. Si stampi quindi la stringa s3 o

un opportuno messaggio nel caso in cui la stringa s3 sia vuota.

#include <iostream>

#include <stdlib.h>

#include <string.h>

using namespace std;

// dichiarazioni

const int MAX_ELEM=30;

typedef char stringa[MAX_ELEM+1];

// prototipi

void leggi(stringa);

void copia(const stringa, const stringa, stringa);

void stampa(const stringa);

//main

int main()

// definizione delle funzioni

void leggi(stringa s)

void copia(const stringa s1, const stringa s2, stringa s3)

s3[j]='0';

void stampa(const stringa s)

else cout << 'nNelle due stringhe inserite non esistono caratteri in posizione omologa che siano uguali.nn';

49) /* E S E R C I Z I O

Siano date in ingresso da tastiera due stringhe di eguale lunghezza.

Si scriva un programma che conti il numero di caratteri in posizione

omologa che sono uguali e costruisca una nuova stringa costituita da

tali caratteri. Si stampi il valore calcolato insieme al

contenuto delle due stringhe ed alla stringa contenente i soli caratteri uguali.

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

using namespace std;

// dichiarazioni

const int MAX_ELEM=30;

typedef char stringa[MAX_ELEM+1]; //sommo 1 per tener conto del terminatore

//prototipi (si noti che sono stati indicati solo i tipi dei parametri)

void leggi(stringa, stringa); //funzione di input

int calcola(const stringa, const stringa, stringa); //funzione che effettua il conteggio e crea la nuova stringa

void stampa(int, const stringa, const stringa, const stringa); //funzione di output

// main

int main() while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!='N'));

} while ((risp=='s')||(risp=='S'));

return 0;

// definizione delle funzioni

void leggi(stringa s1, stringa s2)else

}

}while((l1!=l2)||(l1==0)||(l1>MAX_ELEM));

int calcola(const stringa s1, const stringa s2, stringa s3)

i++;

};

s3[num]='0'; //poiché la stringa è stata gestita come array di caratteri, il terminatore non verrà inserito automaticamente, ma siamo noi a doverlo inserire.

return num;

void stampa(int n, const stringa s1, const stringa s2, const stringa s3)

50) /*funzioni*/

#include <iostream>

#include <stdlib.h>

using namespace std;

float input();

float calcola_quadrato(float numero);

void output(float numero,float quadrato);

int main()

while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!='N'));

}while ((risp=='s')||(risp=='S'));

system('pause');

return 0;

float input()

float calcola_quadrato(float numero)

void output(float numero,float quadrato)

51) /*funzioni con array*/

#include <iostream>

#include <stdlib.h>

using namespace std;

const int MAX_ELEM=101;

void input(int &riemp, float v[]);

void calcola_quadrato(int riemp,float v[],float q[]);

void output(int riemp,float v[],float q[]);

int main()

while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!='N'));

}while ((risp=='s')||(risp=='S'));

system('pause');

return 0;

void input(int &riemp, float v[])while((riemp>MAX_ELEM-1)||(riemp<1));

for(i=0;i<riemp;i++)

void calcola_quadrato(int riemp,float v[],float q[])

void output(int riemp,float v[],float q[])

52) // INDOVINA IL NUMERO

// prima versione (semplificata)

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

if (risposta=='b')

}while(risposta!='u'); //se il carattere inserito dall'utente è diverso da 'u', le istruzioni presenti nel blocco do..while vengono eseguite nuovamente

cout<<'Ho indovinato in '<<contatore<<' tentativi.'<<endl; //messaggio finale

system('PAUSE'); //il programma chiede all'utente di premere un tasto per continuare

return 0; //uscita dal programma con codice d'errore 0 (nessun errore)

53) /*inserimento di stringhe in ordine*/

#include <iostream>

#include <stdlib.h>

#include <string.h>

using namespace std;

const int MAX_LEN=100;

const int LEN=50;

const int ITERAZIONI=5;

typedef char stringa[MAX_LEN];

void inserisci_in_ordine_stringa ( stringa [], int &, stringa);

int main()

cout<<endl;

cout<<'LISTA ORDINATA:'<<endl;

for (j=0;j<ITERAZIONI;j++)

system('pause');

void inserisci_in_ordine_stringa (stringa lista[], int &r, stringa str)

strcpy(lista[i+1],str);

r++;

54) /* E S E R C I Z I O

Sia data in ingresso da tastiera una matrice di interi.

Si realizzi un programma che conta quanti elementi di valore pari sono

presenti nella matrice. Si stampi la matrice inserita ed il valore del

conteggio.

#include <iostream>

#include <stdlib.h>

using namespace std;

// dichiarazioni

const int MAX_ELEM=30;

//prototipi (si noti che sono stati indicati solo i tipi dei parametri)

void leggi(int [][MAX_ELEM],int &,int &); //funzione di input

int calcola(const int [][MAX_ELEM],int, int); //funzione che effettua il conteggio e crea la nuova stringa

void stampa(const int [][MAX_ELEM],int, int,int); //funzione di output

// main

int main() while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!='N'));

} while ((risp=='s')||(risp=='S'));

return 0;

// definizione delle funzioni

void leggi(int M[][MAX_ELEM],int &r1,int &r2)while((r1<1)||(r1>MAX_ELEM));

dowhile((r2<1)||(r2>MAX_ELEM));

for(i=0;i<r1;i++)

}

int calcola(const int M[][MAX_ELEM],int r1, int r2)

}

}

return num;

void stampa(const int M[][MAX_ELEM],int r1, int r2,int n)

cout<<endl;

}

cout<<endl;

cout<<'Ci sono '<<n<<' elementi pari.'<<endl<<endl;

55) #include <iostream>

#include <stdlib.h>

using namespace std;

int main()

if (n3>max)

cout<<'massimo: '<<max<<endl;

system('PAUSE');

return 0;

56) /* Programma che calcola la media degli elementi di valore pari e di quelli di valore

dispari di un array V. */

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

while ((riemp>100)||(riemp<1)); //il ciclo termina quando l'utente inserisce un valore del riempimento compreso tra 1 e 100

for (i=0;i<riemp;i++)

numpari=0; //inizializzazione dei contatori

numdispari=0;

sommapari=0; //inizializzazione degli accumulatori

sommadispari=0;

//calcolo della media

for(i=0;i<riemp;i++)else

}

if (numpari>0)else

if (numdispari>0)else

//stampa dei risultati

cout<<'Media dei numeri pari: '<< mediapari<<endl;

cout<<'Media dei numeri dispari: '<< mediadispari<<endl;

system('PAUSE');

return 0;

57) //N.B.: Questo algoritmo di ricerca presuppone che l'array sia ordinato

#include <iostream>

#include <stdlib.h>

using namespace std;

// dichiarazioni

const int MAX_ELEM=30;

typedef int vett[MAX_ELEM];

//prototipi

void leggi(int &, vett, int &);

bool ricerca(int, const vett, int);

void stampa(bool, int);

// definizione delle funzioni

void leggi(int &n, vett v, int &x)

cout<<'nInserire l'elemento da cercare: ';

cin>>x;

bool ricerca(int n, const vett v, int x)while (i<=j && v[k]!=x);

if (v[k]==x)

return true;

else return false;

void stampa(bool t, int x)

// main

int main()

58) // RACCOLTA DI FUNZIONI PER LA GESTIONE DEGLI ARRAY

#include <iostream>

#include <stdlib.h>

#include <string.h>

using namespace std;

//Costanti

const int MAX_ELEM=100; //Massima lunghezza degli array

const int LUNG_STR=150; //Massima lunghezza delle stringhe

//Definizioni di tipo

typedef char stringa[LUNG_STR+1];

//Prototipi

void input_array(int &, int []);                            //Input di un array

void output_array(int, const int [], const stringa);        //Output di un array

void ins_elem(int &, int [], int, int);                     //Inserimento di un nuovo elemento in un array

void elim_elem(int &, int [], int);                         //Eliminazione di un elemento da un array

bool elim_elem_magg(int &, int [], int);                    //Eliminazione da un array di tutti gli elementi il cui valore è maggiore di un valore indicato dall'utente

bool elim_elem_min(int &, int [], int);                     //Eliminazione da un array di tutti gli elementi il cui valore è minore di un intero indicato dall'utente

int input_intero(const stringa);                            //Input di un valore intero

void scambia(int [], int, int);                             //Funzione di swap

void SelectSort(int [], int);                               //Ordinamento degli elementi di un array di interi mediante l'algoritmo del select sort

void BubbleSort1 (int [],int);                              //Ordinamento degli elementi di un array di interi mediante l'algoritmo del bubble sort (prima versione)

void BubbleSort2 (int [],int);                              //Ordinamento degli elementi di un array di interi mediante l'algoritmo del bubble sort (seconda versione)

bool ricerca_lineare1(int, const int [], int);              //Ricerca di un valore in un array di interi mediante l'algoritmo della ricerca lineare (prima versione)

bool ricerca_lineare2(int, const int [], int, int &); //Ricerca di un valore in un array di interi mediante l'algoritmo della ricerca lineare (seconda versione)

bool ricerca_binaria(int, const int [], int); //Ricerca di un valore in un array di interi mediante l'algoritmo della ricerca binaria

int max(int, const int []);                                 //Ricerca del massimo in un array di interi

int min(int, const int []);                     //Ricerca del minimo in un array di interi

void copia_maggiori(const int [],int [], int , int &, int); //Copia in un secondo array, inizialmente vuoto, di tutti gli elementi di un array il cui valore è maggiore di un intero indicato dall'utente

void copia_minori(const int [],int [], int, int &, int); //Copia in un secondo array, inizialmente vuoto, di tutti gli elementi di un array il cui valore è minore di un intero indicato dall'utente

int main() while((ind>=r1)||(ind<0)); //la richiesta di inserimento dell'indice viene ripetuta fino a che non si immette un valore valido

ins_elem(r1, V1, val, ind); //chiamata alla funzione di inserimento del nuovo elemento

output_array(r1,V1,'N.1'); //stampa dell'array modificato

cout<<'Operazione effettuata.n';

system('PAUSE');

break; //fine del gruppo di istruzioni associate ad 'a' ed 'A'

//Eliminazione di un elemento per valore:

case 'b' :

case 'B' :

val=input_intero('Inserisci il valore dell'elemento da eliminare: ');

if(ricerca_lineare2(r1, V1, val,ind))else //se nessun elemento dell'array ha valore pari a quello fornito dall'utente .

cout<<'Il valore non e' stato trovato.nNon e' stato eliminato alcun elemento.n'; // viene mostrato un opportuno messaggio

output_array(r1,V1,'N.1'); //stampa dell'array modificato

system('PAUSE');

break;

//Eliminazione elemento per indice:

case 'c' :

case 'C' :

dowhile((ind>=r1)||(ind<0));

elim_elem(r1, V1, ind);

output_array(r1,V1,'N.1');

cout<<'Operazione effettuata.n';

system('PAUSE');

break;

//Eliminazione di tutti gli elememti maggiori di 'val':

case 'd' :

case 'D' :

val=input_intero('Inserisci il valore: ');

if(elim_elem_magg(r1, V1, val))else

cout<<'Il valore non e' stato trovato.nNon e' stato eliminato alcun elemento.n';

output_array(r1,V1,'N.1');

system('PAUSE');

break;

//Eliminazione di tutti gli elememti minori di 'val':

case 'e' :

case 'E' :

val=input_intero('Inserisci il valore: ');

if(elim_elem_min(r1, V1, val))else

cout<<'Il valore non e' stato trovato.nNon e' stato eliminato alcun elemento.n';

output_array(r1,V1,'N.1');

system('PAUSE');

break;

//Input di un array:

case 'f' :

case 'F' :

input_array(r1, V1);

break;

//Ricerca lineare:

case 'g' :

case 'G' :

val=input_intero('digita il valore da cercare: ');

if (ricerca_lineare1(r1, V1, val))

cout<<'Il valore e' stato trovato.n';

else

cout<<'Il valore non e' stato trovato.n';

system('PAUSE');

break;

//Ricerca binaria:

case 'h' :

case 'H' :

val=input_intero('digita il valore da cercare: ');

BubbleSort1(V1, r1); //Prima di effettuare la ricerca binaria occorre ordinare l'array

if (ricerca_binaria(r1, V1, val))

cout<<'Il valore e' stato trovaton';

else

cout<<'Il valore non e' stato trovaton';

cout<<'Per effettuare la ricerca binaria ho dovuto ordinare l'array.n';

system('PAUSE');

break;

//Ricerca del massimo:

case 'i' :

case 'I' :

if (r1>0) //se il riempimento è maggiore di zero

cout<<'Il massimo e': '<<max(r1,V1)<<endl; //si calcola il massimo usando la funzione max

else // altrimenti

cout<<'Impossibile calcolare il massimo.nL'array e' vuoto.n'; //si stampa un messaggio e non si usa la funzione max (che produce risultati corretti solo nell'ipotesi di riempimento>0)

system('PAUSE');

break;

//Ricerca del minimo:

case 'l' :

case 'L' :

if (r1>0)

cout<<'Il minimo e': '<<min(r1,V1)<<endl;

else

cout<<'Impossibile calcolare il minimo.nL'array e' vuoto.n';

system('PAUSE');

break;

//Ordinamento dell'array mediante l'algoritmo di Select Sort

case 'm' :

case 'M' :

SelectSort(V1, r1);

output_array(r1,V1,'N.1');

cout<<'Operazione effettuata.n';

system('PAUSE');

break;

//Ordinamento dell'array mediante l'algoritmo di Bubble Sort (prima versione)

case 'n' :

case 'N' :

BubbleSort1(V1, r1);

output_array(r1,V1,'N.1');

cout<<'Operazione effettuata.n';

system('PAUSE');

break;

//Ordinamento dell'array mediante l'algoritmo di Bubble Sort (seconda versione)

case 'o' :

case 'O' :

BubbleSort2(V1, r1);

output_array(r1,V1,'N.1');

cout<<'Operazione effettuata.n';

system('PAUSE');

break;

//Copia in 'V2' di tutti gli elementi di 'V1' il cui valore è maggiore di 'val'

case 'p' :

case 'P' :

val=input_intero('Inserisci il valore: ');

copia_maggiori(V1, V2, r1, r2, val);

output_array(r1,V1,'N.1'); //vengono stampati sia gli elementi dell'array sorgente

output_array(r2,V2,'N.2'); // che quelli dell'array destinazione

system('PAUSE');

break;

//Copia in 'V2' di tutti gli elementi di 'V1' il cui valore è minore di 'val'

case 'q' :

case 'Q' :

val=input_intero('Inserisci il valore: ');

copia_minori(V1, V2, r1, r2, val);

output_array(r1,V1,'N.1');

output_array(r2,V2,'N.2');

system('PAUSE');

break;

//Uscita

case 'x' :

case 'X' :

break;

default : //Se il carattere inserito dall'utente non è presente tra quelli indicati nei vari 'case', vengono eseguite le seguenti linee di codice:

cout<<'Selezione non valida.n';

system('PAUSE');

break;

}

} while ((risp!='x')&&(risp!='X')); //il ciclo che prevede: la stampa dell'array, la stampa del menu, la scelta dell'utente e l'esecuzione delle linee di codice corrispondenti all'opzione scelta, si ripete fino a quando l'utente non seleziona l'opzione d'uscita ('x' o 'X').

return 0;

void ins_elem(int &r, int v[], int valore, int indice)

r++; //il riempimento viene incrementato di un'unità perchè è stato aggiunto un elemento all'array

v[indice]=valore;

void elim_elem(int &r, int v[], int indice)

r--; //il riempimento viene decrementato di un'unità perchè è stato eliminato un elemento dall'array

bool elim_elem_magg(int &r, int v[], int valore)else //se l'elemento considerato non è maggiore di 'valore', non deve essere eliminato

v[i-k]=v[i]; //l'elemento considerato (v[i]) viene spostato verso l'alto di k posizioni

}

r-=k; //il riempimento finale è pari a quello iniziale meno il numero di elementi eliminati (k)

return eliminato;

bool elim_elem_min(int &r, int v[], int valore)else

v[i-k]=v[i];

}

r-=k;

return eliminato;

int input_intero(const stringa stringa_messaggio)

void input_array(int &n, int v[])while((n<0)||(n>MAX_ELEM));

for (i=0;i<n;i++)

void output_array(int n, const int v[], const stringa nome_array)

cout<<endl;

int max(int n, const int v[])

return m;

int min(int n, const int v[])

return m;

void scambia(int a[], int i, int j)

void SelectSort(int a[], int n)

void BubbleSort1 (int a[], int n)

void BubbleSort2 (int a[], int n)

i++;

}

bool ricerca_lineare1(int n, const int v[], int x)else

}

return trovato;

bool ricerca_lineare2(int n, const int v[], int x, int &indice)else

}

return trovato;

bool ricerca_binaria(int n, const int v[], int x)while (i<=j && v[k]!=x);

if (v[k]==x)

trovato=true;

else

trovato=false;

return trovato;

void copia_maggiori (const int v1[],int v2[], int r1, int &r2, int x)

void copia_minori (const int v1[],int v2[], int r1, int &r2, int x)

59) // RACCOLTA DI FUNZIONI PER LA GESTIONE DELLE STRINGHE

#include <iostream>

#include <stdlib.h>

#include <string.h>

using namespace std;

//Costanti

const int MAX_ELEM=100;

const int LUNG_STR=150;

//Definizioni di tipo

typedef char stringa[LUNG_STR+1];

//Prototipi

void input_stringa(stringa, const stringa);              //Input di una stringa

int lung_stringa(const stringa); //Calcolo della lunghezza di una stringa

void output_stringa(const stringa, const stringa);                               //Stampa di una stringa

int confronta_stringhe(const stringa s, const stringa t); //Confronto di una stringa

void copia_stringa(stringa , const stringa );  //Copia di una stringa

void concatena_stringhe(stringa, const stringa );                                //Concatenazione di due stringhe

void leggi_lista_stringhe (stringa [], int & );                                  //Input di un array di stringhe

void stampa_lista_stringhe (const stringa [], int ); //Stampa di un array di stringhe

void cerca_lista_stringhe (const stringa [], int, const stringa, bool &, int & );//Ricerca di una stringa in un array di stringhe

void inserisci_in_ordine_stringa (stringa [],int &,const stringa); //Inserimento di una stringa nella posizione appropriata in un array ordinato di stringhe

void leggi_e_ordina_lista_stringhe (stringa [], int &);                          //Input di un array di stringhe ed ordinamento degli elementi

int main() else

}else

cout<<'L'array di stringhe e' vuoto.n';

system('PAUSE');

break;

case 'o' : //inserimento ed ordinamento

case 'O' :

leggi_e_ordina_lista_stringhe (lista, r);

stampa_lista_stringhe(lista, r);

system('PAUSE');

break;

case 'x' : //uscita

case 'X' :

break;

default :

cout<<'Selezione non valida.n';

system('PAUSE');

break;

}

} while ((risp!='x')&&(risp!='X'));

return 0;

void input_stringa(stringa s, const stringa nome_stringa)

int lung_stringa(const stringa s)

void output_stringa(const stringa s, const stringa nome_stringa)

int confronta_stringhe(const stringa s, const stringa t)

return s[i]-t[i];

void copia_stringa(stringa s, const stringa t)

s[i]='0';

void concatena_stringhe(stringa s, const stringa t)

while (t[j]!='0')

s[i]='0';

void leggi_lista_stringhe (stringa lista[], int &n ) while((n<0)||(n>MAX_ELEM));

for (i=0;i<n;i++)

void stampa_lista_stringhe (const stringa lista[], int n )

void cerca_lista_stringhe (const stringa lista[], int n, const stringa str, bool &trovato, int &i )

void inserisci_in_ordine_stringa (stringa lista[],int &n,const stringa str)

strcpy(lista[i+1],str);

n++;

void leggi_e_ordina_lista_stringhe (stringa lista[], int &n)while((n<0)||(n>MAX_ELEM));

for (i=0;i<n;i++)

60) // =================== Scambia =================================

void scambia(int a[], const int i, const int j)

// =================== SelectSort =================================

void SelectSort(int a[], const int n)

// =================== BubbleSort =================================

void BubbleSort0 (int a[],const int n)

void BubbleSort (int a[], const int n)

i++;

}

Siano assegnati da tastiera una stringa S e due caratteri c1 e c2.

Si progetti una funzione SOSTITUISCI che riceve in ingresso S, c1 e c2 e che sostituisce tutte le occorrenze del carattere c1

con il carattere c2. Tale funzione deve anche restituire come valore di ritorno il numero di sostituzioni effettuate.

Nel main bisognerà leggere, con una opportuna funzione, S, c1 e c2, e bisognerà stampare con una opportuna funzione la

stringa S dopo le sostituzioni ed il valore restituito dalla funzione SOSTITUISCI.

Esempi

INPUT:

S = astanti

c1 = a

c2 = i

OUTPUT:

S = istinti

num = 2

INPUT:

S = astanti

c1 = p

c2 = i

UTPUT:

S = astanti

num = 0

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

using namespace std;

const int MAX=50;

typedef char stringa[MAX+1];

// Prototipi

void leggi(stringa, char&, char&);

int sostituisci(stringa, char, char);

void stampa(const stringa, int);

int main()

void leggi(stringa s, char &c1, char &c2)

int sostituisci(stringa s, char c1, char c2)

return num;

void stampa(const stringa s, int num)

62) /* Programma che individua l'indice del primo elemento di un array V il cui valore è maggiore di 10.

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

while ((riemp>100)||(riemp<0)); //il ciclo termina quando l'utente inserisce un valore del riempimento compreso tra 0 e 100

for (i=0;i<riemp;i++)

//corpo del programma

i=0; //inizializzazione del contatore

trovato=false; //inizializzazione della variabile trovato. Inizialmente la pongo uguale a FALSO

//uso il while perchè, se il riempimento è zero, il blocco non deve essere eseguito mai

//eseguo il ciclo fino a quando esistono elementi da analizzare e non è stato trovato un elemento>10

while((i<riemp)&&(!trovato))else

}

//stampa dei risultati

cout<<endl; //stampo una riga vuota per distanziare l'output dall'input

if (trovato)else

system('PAUSE');

return 0;

63) #include <iostream>

#include <cstdlib>

using namespace std;

const int Max=10;

void caricamat(int a[Max][Max], int &n);

void stampamat(int const a[Max][Max], const int n);

int somma_DM_mat(int const a[Max][Max], int n);

int somma_Dm_mat(int const a[Max][Max], int n);

int main()

void caricamat(int a[Max][Max], int &n)

}

}

void stampamat(int const a[Max][Max], const int n)

}

}

int somma_DM_mat(int const a[Max][Max], int n)

return somma;

}

int somma_Dm_mat(int const a[Max][Max], int n)

return somma;

}

63) #include<iostream>

#include<stdlib.h>

using namespace std;

void leggivett (int v[], int &riemp);

void stampavett (int const v[], int const riemp);

double med(int const v[], int const riemp);

void nuovovett(double const m, int const v[], int const riemp, int Vs[], int &Rs);

int const MAX=100;

int main()

void leggivett(int v[], int &riemp)

void stampavett(int const v[], int const riemp)

double med(int const v[], int const riemp)

void nuovovett(double const m, int const v[], int const riemp, int Vs[], int &Rs)

64) #include <iostream>

#include <cstdlib>

using namespace std;

// Prototipi

// Funzione che calcola l'area di un triangolo

double calcolaArea(double altezza,double base);

int main()

double calcolaArea(double altezza,double base)

ESERCIZI VARI

TUTTI ESERCIZI C++

*/Termina la lista se si inserisce un numero negativo

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

}

if(primo==1)

cout<<'Il numero non e' primo';

else

cout<<'Il numero è primo';

}

}while (x<=0);

system('PAUSE');

return 0;

*/stampa un triangolo di caratteri

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

cout<<'n';

}

system('PAUSE');

return 0;

*/elimina da un vettore i numeri dispari

#include <iostream>

#include <stdlib.h>

const int DIM=100;

void stampa_vetint(char V[DIM],const int n);

void leggi_vetint(char V[DIM],int &n);

int elimina_dispari(char V[DIM], int &n);

using namespace std;

int main(int argc, char *argv[])

void leggi_vetint(char V[DIM],int &n)

int elimina_dispari(char V[DIM], int &n)

conta++;

n--;

i--;

}

cout<<'Il valore attuale di n e''<<n;

cout<<'Il numero di inserimenti effettuati e''<<conta;

void stampa_vetint(char V[DIM],const int n)

*/data una matrice crea un vettore in cui mette i minimi di ogni riga

#include <iostream>

#include <stdlib.h>

using namespace std;

const int K=50;

const int R=50;

typedef int Matrice_int[R][K];

void stampa_matrice(Matrice_int,const int numR,const int numC);

void inserisci_matrice(Matrice_int M,int& numR,int & numC);

void crea_vet(Matrice_int M,int vet[R],const int numR,const int numC);

int cerca_min(Matrice_int M,const int numR,const int numC,int i);

void stampa_vet(int vet[R],const int numR);

int main(int argc, char *argv[])

void inserisci_matrice(Matrice_int M,int& numR,int & numC)

}

void stampa_matrice(Matrice_int M,const int numR,const int numC)

}

void crea_vet(Matrice_int M,int vet[R],const int numR,const int numC)

int cerca_min(Matrice_int M,const int numR,const int numC,int i)

}

return min;

void stampa_vet(int vet[R],const int numR)

}

*/vede se un numero è 0 oppure no

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/convertitore euro-lire

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/copia di un vettore

#include <iostream>

#include <stdlib.h>

const int DIM=100;

typedef int tipo;

typedef tipo vettore[DIM];

void leggi(vettore V1,int & dimensione);

void copia(vettore V1,vettore V2,int & dimensione);

void stampa(vettore V2,int dimensione);

using namespace std;

int main(int argc, char *argv[])

void leggi(vettore V1,int & dimensione)

void copia(vettore V1,vettore V2,int & dimensione)

void stampa(vettore V2,int dimensione)

*/potenza

#include <iostream.h>

main()

*/somma della diagonale secondaria

#include <iostream>

#include <stdlib.h>

const int righe=100;

const int colonne=100;

using namespace std;

int M[righe][colonne];

int main(int argc, char *argv[])

cout<<'n Somma della diagonale secondaria';

int i,j,somma=0;

for(i=0;i<riga-1;i++)

for(j=i+1;j<riga;j++)

somma=somma+M[i][j];

cout<<'n La somma e' : '<<somma;

system('PAUSE');

return 0;

*/somma degli elementi di un vettore

#include <iostream>

#include <stdlib.h>

const int DIM=100;

using namespace std;

typedef int vettore[DIM];

int somma(vettore V,int n);

int main(int argc, char *argv[])

ris=somma(V,n);

cout<<'n La somma e' : '<<ris;

system('PAUSE');

return 0;

int somma(vettore V,int n)

*/menu

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

cout<<'n';

}elseelse

}else

}while(scelta!=4);

system('PAUSE');

return 0;

*/prova di fine corso di gennaio 2005

// Prova pratica di fine corso del 12.01.05

// Vengono usati gli schemi algoritmici presentati

// durante il corso (lezione 12).

// In particolare si fa riferimento:

// - allo schema per lo 'scompattamento' di un array ('inserisci')

// - allo schema -modificato- di ricerca di una proprietà in una lista

// (per la ricerca dei punti di inserimento in 'inserisci')

// - agli schemi di acquisizione e scansione di una lista con fattore

// di riempimento ('leggi' e 'stampa')

#include <iostream>

#include <stdlib.h>

using namespace std;

const int MAX=20;

typedef char tipo;

typedef tipo Vettore[MAX];

void leggi(Vettore, int &);

void stampa(const Vettore, const int);

int inserisci(Vettore, int &, const tipo, const tipo);

int main(int argc, char *argv[])

void leggi(Vettore V, int & n)

void stampa(const Vettore V, const int n)

int inserisci(Vettore V, int & n, const tipo prec, const tipo succ)

}

return cont;

*/menu convertitore euro lira

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

else

else

}

}

}while(scelta!=3);

system('PAUSE');

return 0;

*/prova dell'8 giugno 2005

#include <iostream>

#include <stdlib.h>

const int max_righe=100;

const int max_colonne=100;

typedef int tipo;

typedef tipo matrice[max_righe][max_colonne];

void leggi(matrice M,int & riga,int & colonna);

void appendi_righe(matrice M1,matrice M2,matrice M3,const int riga,int & colonna);

void fondi_righe(matrice M1,matrice M2,matrice M4,int riga,int colonna);

void fondi_righe(matrice A,matrice B,int & riga,int & colonna,matrice D);

using namespace std;

int main(int argc, char *argv[])

}

system('PAUSE');

return 0;

void leggi(matrice M,int& riga,int & colonna)

}

void appendi_righe(matrice M1,matrice M2,matrice M3,const int riga,int & colonna)

}

for(int i=0;i<riga;i++)

for(int i=0;i<riga;i++)

void fondi_righe(matrice A,matrice B,int & riga,int & colonna,matrice D)else

}

while(colA<colonna)

while(colB<colonna)

}

*/esercizio punto sella

#include <iostream>

#include <stdlib.h>

using namespace std;

const int max_riga=10;

const int max_colonna=10;

typedef int tipo;

typedef tipo matrice[max_riga][max_colonna];

void leggi_matrice(matrice M,int & n,int & m);

void cerca_sella(matrice M,const int n,const int m,bool & trovato);

void minelriga(matrice M,const int n,const int m,int i,int & indice_colonna_min,int & minriga);

void maxelcolonna(matrice M,const int n,const int m, int indice_colonna_min,int & maxcolonna);

void maxelriga(matrice M,const int n,const int m,int i,int & indice_colonna_max,int & maxriga);

void minelcolonna(matrice M,const int n,const int m, int indice_colonna_max,int & mincolonna);

int main(int argc, char *argv[])

void leggi_matrice(matrice M,int & n,int & m)

}

cout<<'Fine inserimento'<<endl;

void cerca_sella(matrice M,const int n,const int m,bool & trovato)

for(int k=indice_colonna_min;k<m;k++)

}

}

trovato=false;

maxelriga(M,n,m,i,indice_colonna_max,maxriga);

minelcolonna(M,n,m,indice_colonna_max,mincolonna);

if(mincolonna==maxriga)

for(int k=indice_colonna_max;k<m;k++)

}

}

}

}

void minelriga(matrice M,const int n,const int m,int i,int & indice_colonna_min,int & minriga)

}

}

void maxelcolonna(matrice M,const int n,const int m, int indice_colonna_min,int & maxcolonna)

}

}

void maxelriga(matrice M,const int n,const int m,int i,int & indice_colonna_max,int & maxriga)

}

}

void minelcolonna(matrice M,const int n,const int m, int indice_colonna_max,int & mincolonna)

}

}

*/ vede se un numero è positivo o negativo

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/punto sella in maniera piu complicata

#include <iostream>

#include <stdlib.h>

using namespace std;

const int max_riga=50;

const int max_colonna=50;

typedef int tipo;

typedef tipo matrice[max_riga][max_colonna];

void leggi_matrice(matrice M,int & n,int & m);

void cerca_sella(matrice M,const int n,const int m,int & k,int & j,bool & trovato);

void minel(matrice M,const int n,const int m,const int i,int & pos_elemento_piu_piccolo_del_vettore_di_indice_i,int & min);

void max(matrice M,const int n,const int m,const int k,int &pos_elemento_piu_grande_di_indice_k,int & mas);

int main(int argc, char *argv[])

system('PAUSE');

return 0;

void leggi_matrice(matrice M,int & n,int & m)

}

void cerca_sella(matrice M,const int n,const int m,int & k,int & j,bool & trovato)

}

void minel(matrice M,const int n,const int m,const int i,int & pos_elemento_piu_piccolo_del_vettore_di_indice_i,int & min)

}

}

void max(matrice M,const int n,const int m,const int k,int & pos_elemento_piu_grande_di_indice_k,int & mas)

}

}

*/semplice menu

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

else

else

}

}while(scelta!=3);

system('PAUSE');

return 0;

*/prova 20 dicembre 2005

#include <iostream>

#include <stdlib.h>

const int DIM=100;

void stampa_vetint(int V[DIM],const int n);

void leggi_vetint(int V[DIM],int &n);

int elimina_dispari(int V[DIM], int &n);

using namespace std;

int main(int argc, char *argv[])

void leggi_vetint(int V[DIM],int &n)

int elimina_dispari(int V[DIM], int &n)

conta++;

n--;

i--;

}

cout<<'Il valore attuale di n e''<<n;

cout<<'Il numero di inserimenti effettuatu e''<<conta;

void stampa_vetint(int V[DIM],const int n)

*/fa la somma della riga e della colonna e le mette nella diagonale principale

#include <iostream>

#include <stdlib.h>

using namespace std;

const int max_righe=100;

const int max_colonne=100;

typedef int tipo;

typedef tipo matrice[max_righe][max_colonne];

void leggi(matrice M,int & riga,int & colonna);

void crea_matrice(matrice M,int & riga,int & colonna);

void crea_matrice(matrice M,int & riga,int & colonna);

int somma_vettori(matrice M,const int riga,const int colonna,const int j);

int main(int argc, char *argv[])

}

system('PAUSE');

return 0;

void crea_matrice(matrice M,int & riga,int & colonna)

}

int somma_vettori(matrice M,const int riga,const int colonna,const int j)

return sommariga+sommacolonna-M[j][j];

void leggi(matrice M,int& riga,int & colonna)

}

}

*/media aritmetica

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/confronto fra 2 numeri

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/contatore pari e dispari

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

else

}while(x>=0);

cout << ' n Il numero di numeri pari e' : ' <<contatore ;

cout << ' n Il numero di numeri dispari e' : ' <<cont ;

cout <<'n ';

system('PAUSE');

return 0;

*/ puntatori

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

*/stringa

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

system('PAUSE');

return 0;

/*Esercizio

Siano assegnati in ingresso, da tastiera, un vettore di interi V, il suo riempimento r ed un intero k.

Si scriva un programma che calcoli il numero (num) di elementi di V il cui valore è maggiore di k e

sostituisca con num tutti gli elementi di V il cui valore è minore o uguale a k. Si stampino quindi il

vettore V modificato ed il valore num.

int main(int argc, char *argv[])

num=0;

for(int i=0;i<r;i++)

for(int i=0;i<r;i++)

for(int i=0;i<r;i++)

cout<<V[i];

system('PAUSE');

return 0;

*/secondo gruppo di esercizi di autovalutazione

Esercizi autovalutazione 2

/primo esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

cout << ' n La somma e': ' << somma ;

cout << ' n ' ;

system('PAUSE');

return 0;

/secondo esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

}

cout << ' n Il minimo e' : ' << minimo ;

cout << ' n ' ;

system('PAUSE');

return 0;

/terzo esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

else

}

cout << ' n Il numero di numeri pari e' : ' <<contatore ;

cout << ' n Il numero di numeri dispari e' : ' <<cont ;        

cout << ' n ' ;

system('PAUSE');

return 0;

/quarto esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

while(x>=0);

cout<<' n I numeri pari inseriti sono '<<pari<<endl;

cout<<' n I numeri dispari inseriti sono '<<dispari<<endl<<endl;

system('PAUSE');

return 0;

/quinto esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

if (nprimo)

cout<<' n Il numero inserito non e' primo'<<endl;

else

cout<<'n Il numero inserito e' primo'<<endl;

}

}while (x<=0);

system('PAUSE');

return 0;

/sesto esercizio/

#include <iostream>

#include <stdlib.h>

using namespace std;

int main()

system('PAUSE');

return 0;

*/20 dicembre 2005 (fatti dalla prof)

//Programma multifile che dato in ingresso un vettore di numeri naturali

//elimina dal vettore tutti gli elementi dispari. Il programma stampa a video

// il vettore risultante ed il numero di elementi cancellati.

// La soluzione deve essere implementata senza l'ausilio di vettori di

// appoggio

#include <iostream>

#include <stdlib.h>

void leggi_vetint(int[], int &);

int elimina_dispari(int[], int &);

void stampa_vetint(const int[], const int);

const int DIM=100;

using namespace std;

int main(int argc, char *argv[])

cout << 'n Un altro giro? (Y=1/N=0)';

cin >> esci;

system('cls');

} while(esci==1);

cout << 'n';

system('PAUSE');

return 0;

void leggi_vetint(int V[], int & n)

cout << 'n Inserimento terminato.';

}

int elimina_dispari(int V[], int & n)

return cont;

void stampa_vetint(const int V [], const int n)

else cout << 'n Il vettore e' vuoto!';

*/20 dicembre 2005 2 prova(fatta dalla prof)

#include <iostream>

#include <stdlib.h>

int elimina_carattere(char[], const char);

const int DIM=100;

using namespace std;

int main(int argc, char *argv[])

cout << 'n Un altro giro? (Y=1/N=0)';

cin >> esci;

system('cls');

} while(esci);

cout << 'n';

system('PAUSE');

return 0;

int elimina_carattere(char S[], const char X)

cont++;

i--;

}

i++;

}

return cont;

} */es vittoriani 18/01/06

#include <stdlib.h>

#include <iostream>

const int maxcol=10;

const int maxrow=10;

void leggi_matrice(int [][maxcol], int &, int &);

bool verifica_righe_uguali(const int M[][maxcol], const int n, const int m,

const int pos1, int & pos2);

bool uguali(const int M[][maxcol], const int n, const int m,

const int index1, int & index2);

using namespace std;

int main(int argc, char *argv[])

else cout << 'n Non sono state trovate righe uguali!';

}

cout << 'n ancora una prova? (Y=0,N=1)';

cin >> esci;

cout << 'n ';

system('PAUSE');

return 0;

bool verifica_righe_uguali(const int M[][maxcol], const int n, const int m, const int pos1, int & pos2)

bool uguali(const int M[][maxcol], const int n, const int m,

const int index1, int & index2)

void leggi_matrice(int M [][maxcol], int & n, int & m)