Sei sulla pagina 1di 198

ESERCIZI QUELLI DI INFORMATICA PER LESAME 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) {
int i, j, k;
// Ripeto per ogni elemento del secondo elenco
for(i=0; i<m; i++) {
// Trovo la posizione di inserimento
for(j=0; j<n && e1[j]!=e2[i]; j++)
;
// Inserisco e2[i] in posizione j
for(k=n-1; k>=j; k--)
e1[k+1] = e1[k];
e1[j] = e2[i];
n++;
}
}
*/ "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) {
int i, j; // Indici per scorrere v1
int k, l; // Indici per scorrere v2
i = 0;
j = 0;
k = 0;
// Per gestire la cancellazione degli elementi da v1, uso
// j per copiare sempre in v1 gli elementi non cancellati,
// occupando via via le posizioni libere.
while (i <
//
//
if

n1 && k < n2) {


Confronta l'elemento di testa di v1 e v2;
se quello di v1 e' minore, bisogna inserirlo
(v1[i] < v2[k]) {
// Sposta gli elementi di v2
for(l=n2; l>k; l--)
v2[l] = v2[l-1];
v2[k] = v1[i];
n2++;
i++;
k++;
} else if (v1[i] == v2[k]) {
// In questo caso, bisogna conservare

v1[i]
// (spostandolo indietro per occupare
// il posto di elementi cancellati prima)
// e lasciar stare v2[k] dov'e'.
v1[j] = v1[i];
i++;
j++;
k++;
} else {
// In questo caso bisogna

scavalcare v[k]

k++;
}
}
// Fine del while, tutti i rimanenti elementi di v1 vanno
in

// coda a v2
while (i<n1) {
v2[k] = v1[i];
i++;
k++;
n2++;
}
// 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) {
for(int i=0; i<n; i++)
if (a[i] == x)
return true;
return false;
}
void cancella(int a[], int &n, int pos) {
for(int i=pos+1; i<n; i++)
a[i-1] = a[i];
n--;
}
void inserisci_in_ordine(int a[], int &n, int x) {
int i;
for(i=0; i<n && a[i]<x; i++)
;
for(int j=n; j>i; j--)
a[j] = a[j-1];
a[i] = x;
n++;
}
void trasferisci(int v1[], int &n1, int v2[], int &n2) {
int i;
i = 0;
while (i<n1) {
if (cerca(v2, n2, v1[i]))
i++;
else {
inserisci_in_ordine(v2, n2, v1[i]);
cancella(v1, n1, i);
}
}
}
*/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 () {
int v[DIM], n, num=0, k;
il riempimento

//allocazione statica del vettore, n

//inserisci un'intro x spiegare a ke serve il progra


//.............................
cout << "Insert size: ";
cin >> n;
//inserisce elementi in v
for (int i=0; i<n; i++) {
cout << "Insert v[" << i << "] : "; //puoi chiederlo come
vuoi...
cin >> v[i];
}
//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++) {
if (v[i]>k) num++;
}
for (int i=0; i<n; i++) {
if (v[i]<=k) v[i]=num;
}
//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
funzione
#include
#include
#include

un opportuno messaggio per comunicare lesito della


CONTA.
<iostream>
<stdlib.h>
<string.h>

using namespace std;


const int MAX_LEN = 100;
void ricevi (char [], char &);
int conta (const char [], const char);
int main () {
char parola[MAX_LEN], k;
int num = 0; //contatore, registra le occorrenze
ricevi (parola, k);
num = conta (parola, k);
cout << "\nIl carattere " << k << " e' stato trovato " << num <<
" volte.\n";
system ("pause");
return 0;
}
void ricevi (char parola[], char &k) {
cout << "\nInserire la parola: ";
cin.getline (parola, MAX_LEN-1);
cout << "\nInserire il carattere: ";
cin >> k;
}
int conta(const char s[], int k) {
int i, temp;
temp=0;
for(i=0; s[i] != '\0'; i++)
if (s[i]==k)
temp++;
return temp;
}
*/LABORATORIO
Compilazione separata, sottoprogrammi, schemi algoritmici
Specifica esercizio: Punto di sella di una matrice
In una matrice A ad m
sella un elemento aij
contemporaneamente il
esima e il minimo fra
oppure risulti essere

righe ed n colonne, si definisce


tale che esso risulti essere
massimo fra tutti elementi della
tutti gli elementi della colonna
contemporaneamente il minimo fra

punto di
riga ij-esima
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 linserimento 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){
int min,i;
if (mode==1){//ricerca per colonna
min=m[0][at];
for (i=1; i<r; i++)
if (m[i][at]<min)
min=m[i][at];
return min;
}
else{//ricerca per riga
min=m[at][0];
for (i=1; i<c; i++)
if (m[at][i]<min)
min=m[at][i];
return min;
}
}
int max(matrice m,int r,int c,int at,int mode){
int max,i;
if (mode==1){//ricerca per colonna
max=m[0][at];
for (i=1; i<r; i++)
if (m[i][at]>max)
max=m[i][at];
return max;
}

else{//ricerca per riga


max=m[at][0];
for (i=1; i<c; i++)
if (m[at][i]>max)
max=m[at][i];
return max;
}
}
bool cerca(matrice m,int r,int c){
int i;
bool result=false;
for(i=0; i<r; i++)
{
for (int j=0; j<c; j++)
if (((minel(m,r,c,i,0)==m[i][j])&&(max(m,r,c,j,1)==m[i][j]))||
((minel(m,r,c,j,1)==m[i][j])&&(max(m,r,c,i,0)==m[i][j])))
{ cout<<"\n\nPunto di sella in posizione: "<<i<<";"<<j;
result=true;}
}
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){
int i,j;
int s=0,c=n;
for (i=0; i<n; i++)
{
s+=m[i][--c];
}
return s;
}
cio metti un'altra variabile che funge da variabile colonna, che
si decrementa man mano...fino 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){
int i,j;
for (i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
cout<<"Inserisci l'elemento M["<<i+1<<";"<<j+1<<"]=";
cin>>m[i][j];
}
}
}
void vediM(matrice m,int nr,int nc){
int i,j;
cout<<endl;
for (i=0; i<nr; i++)
{
for(j=0; j<nc; j++)
{
cout<<m[i][j]<<" ";
}
cout<<endl;
}
}
//restituisce l'indice del minimo dell'i-esima riga della matrice
m
int minimo(matrice m,int nc,int riga,int inizio)
{
int i,im=inizio,min=m[riga][inizio];
for (i=inizio+1; i<nc; i++)
{
if (m[riga][i]<min)
{min=m[riga][i];
im=i;
}
}
return im;
}

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


{
//NB: a e b sono le colonne di m i cui elementi devono essere
scambiati
int c=m[riga][a];
m[riga][a]=m[riga][b];
m[riga][b]=c;
}
//ordina le singole righe
void ordina(matrice m,int nr,int nc){
int i,j,c,im;
for (i=0; i<nr; i++)
{
for (j=0; j<nc; j++){
scambia(m,i,j,minimo(m,nc,i,j));
}
}
}
void fusione(matrice m1,matrice m2,int n){
int i,j;
matrice c;
for (i=0; i<n; i++)
{
//allungo il for fino a coprire tutte le colonne di entrambe le
matrici!
for (j=0; j<n*2; j++)
{
//se j<n ci troviamo ancora nella prima matrice
if (j<n)
c[i][j]=m1[i][j];
//altrimenti prelevo dalla seconda
else
c[i][j]=m2[i][j-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(){
matrice A,B;
int n;

cout<<"Inserisci l'ordine delle matrici:";


cin>>n;
caricaM(A,n);
caricaM(B,n);
vediM(A,n,n);
cout<<endl;
vediM(B,n,n);
fusione(A,B,n);
system("PAUSE");
return 1;
}
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.
| 1 6 2 |
|-4 3 0 |=A
|9 1 3 |
|- 2 4 0|
|9 -1 4|=B
|1 4 7|
| 1 6 2 -2 4 0|
|-4 -1 0 3 4 9|=C
|9 1 3 1 4 7|
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){
int i,j;
for (i=0; i<n; i++)
{
for(j=0; j<n; j++)
{
cout<<"Inserisci l'elemento M["<<i+1<<";"<<j+1<<"]=";
cin>>m[i][j];
}
}
}
void vediM(matrice m,int nr,int nc){
int i,j;
cout<<endl;
for (i=0; i<nr; i++)
{
for(j=0; j<nc; j++)
{
cout<<m[i][j]<<" ";
}
cout<<endl;
}
}
//restituisce l'indice del minimo dell'i-esima riga della matrice
m
int minimo(matrice m,int nc,int riga,int inizio)
{
int i,im=inizio,min=m[riga][inizio];
for (i=inizio+1; i<nc; i++)
{
if (m[riga][i]<min)
{min=m[riga][i];
im=i;
}
}
return im;
}
void scambia(matrice m,int riga,int a,int b)

{
//NB: a e b sono le colonne i cui elementi devono essere scambiati
int c=m[riga][a];
m[riga][a]=m[riga];
m[riga][b]=c;
}
void ordina(matrice m,int nr,int nc){
int i,j,c,im;
for (i=0; i<nr; i++)
{
[b]if (i%2!=0)//se l'indice dispari ordina
for (j=0; j<nc; j++){
scambia(m,i,j,minimo(m,nc,i,j));
}
}
}
void fusione(matrice m1,matrice m2,int n){
int i,j;
matrice c;
for (i=0; i<n; i++)
{
//allungo il for fino a coprire tutte le colonne di entrambe le
matrici!
for (j=0; j<n*2; j++)
{
//se j<n ci troviamo ancora nella prima matrice
if (j<n)
c[i][j]=m1[i][j];
//altrimenti prelevo dalla seconda
else
c[i][j]=m2[i][j-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()
{
matrice A,B;
int n;

cout<<"Inserisci l'ordine delle matrici:";


cin>>n;
caricaM(A,n);
caricaM(B,n);
vediM(A,n,n);
cout<<endl;
vediM(B,n,n);
fusione(A,B,n);
system("PAUSE");
return 1;
}
Il tipo di ordinamento che uso io quello sequenziale o come
dicono i prof: per minimi successivi!!!
Gi puoi capire il perch della funzione...Cmq 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=
(5 4 3)
(1 -2 7)
(4 6 9)
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=
(5 4 3)
(-2 1 7)
(4 6 9)
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.
si...cmq:
|1 2 3|
|1 9 4|
|6 5 2
DIVENTA:
|3 2 1|
|1 9 4|
|2 5 6|
#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()
{
matrice m;
int n;
cout<<"Inserisci l'ordine della matrice: ";
cin>>n;
carica(m,n);
elimina(m,n);
cout<<"Inversione effettuata: "<<endl;
vedi(m,n);
system("pause");
return(1);
}
void carica(matrice m,int n){
for (int i=0; i<n; i++){
for(int j=0; j<n; j++)
{
cout<<"Inserisci un elemento: ";
cin>>m[i][j];
}
}
}
void vedi(matrice m,int n){
for (int i=0; i<n; i++){
for(int j=0; j<n; j++)

cout<<m[i][j]<<" ";
cout<<endl;
}
}
void elimina(matrice m,int n){
int j=0;
for (int i=0; i<n; i++)
{int c=m[i][j];
m[i][j]=m[i][(n-1)-j];
m[i][(n-1)-j]=c;
j++;
}
}
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:
1 2 3
4 5 6
3 4 6
diventa al primo ciclo
3 2 1
4 5 6
3 4 6
poi al secondo ciclo
3 2 1
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
void elimina_dispari (int vet[], int &dim)
{
//Ordina in vettore in modo che compaiano nelle prime
posizioni
//i numeri pari e nelle ultime quelli dispari
int elem;
int k=1;
for (int i=0; i<dim-k; i++)
{
if( vet[i]%2 != 0)
{
elem = vet[i];

while(vet[dim-k]%2 != 0 && i<(dim-k)) k++;


vet[i] = vet [dim-k];
vet[dim-k] = elem;
}
}
//Calcola la nuova lunghezza del vettore
int j=0;
while(vet[j]%2 == 0 && j<dim) j++;
dim = j;
}
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){
int i;
for(i=0; i<n; i++){
if (v[i]%2!=0)//shifto il vettore, ricomincio il ciclo, decremento
n
{
for (int j=i; j<n-1; j++)
v[j]=v[j+1];
i+=-1;
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)


{
int i=0;
while((i<dim))
{
if(vet[i]%2!=0)
{
for(int j=i+1;j<=dim;j++)
vet[j-1]=vet[j];
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) {
int i, j;
j=0;
for(i=0; i<dim; i++)
if (a[i]%2 == 0) // Se PARI (e quindi non va eliminato...)
{ a[j] = a[i];
j++;
}
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 k=0;
bool ok=true;
while(b[k]!='\0') { //cerco la dimensione del vettore
cout<<b[k]; //per debugging
k++;
}
int i=0, j=k-1;
while(i<k && j>=0) { //confronto elemento per elemento, se solo
uno != non si
//ha in b un palindromo.
cout<<"\n a["<<i<<"]= "<<a[i]<<" e b["<<j<<"]= "<<b[j];

if(a[i]!=b[j]) ok=false;
i++;
j--;
}
if (ok) {return 1;}
else {return 0;}
}
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){
cout<<"Inserisci n:";
cin>>n;
for(int i=0; i<n; i++){
cout<<"Inserisci il valore ASCII di a["<<i+1<<"]: ";
cin>>a[i];}
}
void conta(char a[],int n){
int i,f=0,ifr=0;
for (i=0; i<n; i++)
{
//trovo l'occorrenza di a[i]
int j,c=0;
for (j=0; j<n; j++){
//se a[i] gi stato sondato, esco
if (a[i]==a[j]&&j<i)
goto esci;
//altrimenti conto le occorrenze nel vettore di a[i]
if (a[i]==a[j])
c++;
}
//verifica dell'occorrenza maggiore
if (c>f)

{f=c;ifr=i;}
esci:{continue;}
}
cout<<"\nL'elemento con piu' occorrenze e': "<<a[ifr];
cout<<"\nLe occorrenze sono: "<<f<<endl;
}
int main()
{
char a[MAX];
int n;
carica(a,n);
conta(a,n);
system("pause");
return(1);
}
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:{continue;}
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){
int i,c=0,p=-1,j=-1;
bool lett=false;//non si sta leggendo una parola
for(i=0; i<strlen(s); i++){

if ((s[i]!=' ')&&(lett==false))//inizio lettura p-esima parola


{lett=true;p++;}
if ((s[i]==' ')&&(lett==true))
{lett=false;}
if ((p==n)&&(lett==true))
{j++;t[j]=s[i];}
else if (p>n) break;
}
t[j+1]='\0';
}
int conta(stringa s){
int i,p=0;
bool lett=false;//non si sta leggendo una parola
for(i=0; i<strlen(s); i++){
if ((s[i]!=' ')&&(lett==false))//inizio lettura p-esima parola
{lett=true;p++;}
if ((s[i]==' ')&&(lett==true))
{lett=false;}
}
return p;
}
void occorrenze(stringa s,int n){
int i,f=0,ifr=-1;
stringa t;
//per tutte le n parole della frase
cout<<"Puoi guardare i confronti tra tutte le stringhe. Ti ricordo
che se il confronto 0, le stringhe sono uguali!"<<endl;
for (i=0; i<n; i++)
{
//trovo l'occorrenza della i-esima parola
int j,c=0;
for (j=0; j<n; j++){
//se la parola i-esima gi stato sondato, esco
parola(s,t,j);
stringa g;
parola(s,g,i);
cout<<"Sto confrontando tra :"<<g<<" e
"<<t<<"="<<strcmp(t,g)<<endl;
if((strcmp(g,t)==0)&&(j<i))
goto esci;
//altrimenti conto le occorrenze nella frase
if(strcmp(g,t)==0)
c++;
}
//verifica dell'occorrenza maggiore

if (c>f)
{f=c;ifr=i;}
esci:{continue;}
}
parola(s,t,ifr);
cout<<"\nL'elemento con piu' occorrenze e': "<<t;
cout<<"\nLe occorrenze sono: "<<f<<endl;
}
int main()
{
stringa s,t;
cin.getline(s,MAX);
cout<<"Sono presenti: "<<conta(s)<<" parole."<<endl;
//legge le parole da 0 a n-1, ove n sono le parole totali della
stringa s
for(int i=0; i<conta(s); i++)
{
//il '|' una terminazione visiva ma non effettiva
parola(s,t,i);cout<<t<<"|"<<endl;
}
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){
int i,temp;
for(i=0; i<N && i < N1 ;i++)
{
temp=a[i];
a[i]=b[i];
b[i]=temp;
}
}
*/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)
{
cin>>n;
for(int i=0; i<n; i++)
{cout<<"Inserisci un elemento: ";
cin>>v[i];
}
}
void vedi(vettore v,int n)
{
for(int i=0; i<n; i++)
cout<<v[i]<<" ";
}
bool nonce(vettore v,int p,int a){
int i;
for(i=0; i<p; i++)
if (v[i]==a)
return false;
return true;
}
void unisci(vettore A,vettore B,int n1,int n2)
{
int i,j=0,d=n1+n2;
int C[d];
for(i=0; i<n1; i++)
{
if(nonce(C,j,A[i])==true)
{C[j]=A[i];j++;}
else d--;
}
for(i=0; i<n2; i++)
{
if(nonce(C,j,B[i])==true)
{C[j]=B[i];j++;}
else d--;
}

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


vedi(C,d);
}
int main()
{
vettore A,B;
int n1,n2;
carica(A,n1);
carica(B,n2);
unisci(A,B,n1,n2);
system("pause");
return(1);
}
*/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 ()
{
int result;
stringa s, t;
leggi_stringa( s);
leggi_stringa( t);
result=reverse(s, t);
cout<< "Reverse = " << result << endl;
system("PAUSE");
return 0;
}
void leggi_stringa (stringa s)
{
cin>>s;
}
int lun(stringa s){
int i=0;
while (s[i]!='\0')
i++;
return i;
}
int reverse (stringa s,stringa t)
{

//sono palindrome <==> hanno almeno la stessa lunghezza


if (lun(t)==lun(s)){
{for (int j=0; j<lun(s); j++)
if (s[j]!=t[(lun(t)-1)-j])//confronto ogni jesimo char di s con il
t[n-j] carattere!!!
return 0;//appena c' un carattere che non corrisponde, ritorno un
false!
}
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){
int i;
for(i=0; i<n; i++)
{cout<<"Inserisci l'elemento V["<<i+1<<"]: ";
cin>>v[i];
}
}
void calcola(vettore v,int n){
int i,s=0,p=1;//occhio alle inizializzazioni(il prodotto a 1!)
for(i=0; i<n; i++)
{
//OCCHIO A i+1: INFATTI GLI ELEMENTI PARTONO DA 0 A N-1, MA
LOGICAMENTE ALL'UTENTE LI FACCIAMO PARTIRE DA 1 A N!!!
if((i+1)%2==0)//con l'istruzione calcolo il resto della
divisione per 2, se 0 l'indice pari, calcolo il prodotto
p*=v[i];
else// dispari, calcolo la somma
s+=v[i];

}
cout<<"Il prodotto dei pari e': "<<p<<"\nLa somma dei dispari
e': "<<s<<endl;
}
int main()
{
vettore v;
int n;
cout<<"Inserisci il fattore di riempimento: ";
cin>>n;
carica(v,n);
calcola(v,n);
system("pause");
return(1);
}
*/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
Codice:
#include <cstdlib>
#include <iostream>
#include "prototipi.h"
using namespace std;
int main()
{
int dim, neg, pos, zer;
vettore v;
input_dimensione(dim);
input_vettore (v,dim);
neg=negativi (v,dim);
cout << "Gli elementi negativi sono: " <<neg << endl;
pos=positivi (v,dim);
cout << "Gli elementi positivi sono: " <<pos << endl;
zer=zeri (v,dim);
cout << "Gli elementi 0 sono: " <<zer << endl;
system("PAUSE");
return 0;

}
prototipi.h
Codice:
#define dim_max 100
typedef int vettore[dim_max];
void input_dimensione (int &dim);
void input_vettore (vettore v, int dim);
int negativi (vettore v, int dim);
int positivi (vettore v, int dim);
int zeri (vettore v, int dim);
funzioni.cpp
Codice:
#include <cstdlib>
#include <iostream>
#include "prototipi.h"
using namespace std;
void input_dimensione (int &dim)
{
cout << "Inserisci la dimensione: ";
cin >> dim;
if (dim > 100)
cout << "La dimensione deve essere inferiore a
100.\n";
}
void input_vettore (vettore v, int dim)
{ for (int i=0; i<dim; i++)
{ cout << "Immettere l'elemento di posizione " <<i+1 <<
" : ";
cin >> v[i];
}
}
int negativi (vettore v, int dim)
{
int n=0;
for (int i=0; i<dim; i++)
if ( v[i] < 0)
n ++;
return n;
}
int positivi (vettore v, int dim)

{
int n=0;
for (int i=0; i<dim; i++)
if ( v[i] > 0)
n ++;
return n;
}
int zeri (vettore v, int dim)
{
int n=0;
for (int i=0; i<dim; i++)
if ( v[i] == 0)
n ++;
return n;
}
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:
Codice:
void input_dimensione (int &dim)
{
do{
cout << "Inserisci la dimensione: ";
cin >> dim;
if (dim > 100)
cout << "La dimensione deve essere inferiore a
100.\n";
}while((dim>100)||(dim<1));
}
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 i=0;

while(s[i]!='\0')
i++;
return i;
}
int conta(stringa s)
{
int c=0;
if (s[0]!=' ')c++;
for(int i=0; i<lun(s); i++){
if((s[i-1]==' ')&&(s[i]!=' '))
c++;
}
return c;
}
//funzione che restituisce l'indice nella stringa s1, dove iniza
la p-esima parola
int inizio(stringa s,int p)
{
int c=0,i=1;
if (s[0]!=' ')c++;
while(c<p){
if((s[i-1]==' ')&&(s[i]!=' '))
c++;
i++;
}
return i-1;
}
//funzione che restituisce l'indice nella stringa s1, dove finisce
la p-esima parola
int fine(stringa s,int p)
{
int c=0,i=1;
if (s[0]!=' ')c++;
while(c<=p){
if((s[i-1]==' ')&&(s[i]!=' '))
c++;
if((c==p)&&(s[i]==' '))break;
i++;
}
return i;
}
void estrai(stringa s,stringa t,int p){
int i;
int c=0,j=0;
if (s[0]!=' ')c++;
for(int i=0; i<lun(s); i++){
if((s[i-1]==' ')&&(s[i]!=' '))
c++;

if((c==p)&&(s[i]!=' '))
{t[j]=s[i];j++;}
}
t[j]='\0';
}
//FUNZIONE FONDAMENTALE
int sostituisci(stringa s1,stringa s2,stringa s3){
int i,j,ir=0,in=0,s=0;//ir=indice di ricostruzione della
frase nella variabile n,in=indice inziale per i blank _
stringa t,n;//stringa di appoggio per la lettura delle parole
e stringa di scambio
//CICLO DI CONTEGGIO PAROLE E CONFRONTO CON s2
for(i=1; i<=conta(s1); i++)
{
//estraggo la i-esima parola dalla frase s1 e la metto in
t
stringa t;
estrai(s1,t,i);
//predispongo la nuova stringa con gli spazi originari
della prima!
if(i>1)in=fine(s1,i-1);
//alla fine di ogni parola e all'inzio della successiva
metto gli spazi necessari!
for(j=in; j<(inizio(s1,i)); j++)
{n[ir]=' ';ir++;}
//confronto la stringa estrapolata con s2
//se uguale opero la sostituzione
if(strcmp(t,s2)==0)
{for(j=0;j<lun(s3); j++)
{n[ir]=s3[j];ir++;}
s++;
}
//altrimenti ricopio la parola che c'era nella frase
else
{for(j=inizio(s1,i); j<fine(s1,i); j++)
{n[ir]=s1[j];ir++;}
}
}
//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()
{
stringa s1,s2,s3;
cout<<"Inserisci la frase:";
cin.getline(s1,MAX);
cout<<"Inserisci la parola che sara' sostituita:";
cin>>s2;
cout<<"Inserisci la parola che sovrascrivera' "<<s2<<" :";
cin>>s3;
cout<<"---------------------------------------------------------------\n";
cout<<"La frase e' lunga: "<<lun(s1)<<" caratteri char.\n";
cout<<"Ha "<<conta(s1)<<" parole totali\n";
for(int i=1; i<=conta(s1); i++){stringa t;estrai(s1,t,i);
cout<<endl<<i<<"^ parola: |"<<t<<"|";if(strcmp(t,s2)==0)cout<<"[da
sostituire]";}
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.
#include <iostream>
#include <stdlib.h>
#define MAX 60
typedef int matrice[MAX][MAX];
typedef int vettore[MAX];
using namespace std;
void carica(matrice m,int n){
int i,j;
for(i=0; i<n; i++)
for(j=0; j<n; j++)
{cout<<"Inserisci
M["<<i+1<<";"<<j+1<<"]: ";
cin>>m[i][j];
}
}
int trovariga(matrice m,int n){
int i,j,c,max=0,riga;
for(i=0;i<n;i++){c=0;
for(j=0;j<n;j++){

if(m[i][j]%2!=0)c++;
}if(c>max){max=c;riga=i;}
}
return riga;
}
void copia(vettore v,matrice m,int n){
int i=trovariga(m,n);
for(int j=0; j<n; j++)
v[j]=m[i][j];
}
void vediv(vettore v,int n){
cout<<"Vettore della riga con piu' numeri dispari: \n";
for(int i=0; i<n; i++)
cout<<v[i]<<" ";
}
void vedim(matrice m,int n){
cout<<"\n\nMatrice senza la riga con piu' numeri dispari:
\n";
for(int i=0; i<n; i++)
if(i!=trovariga(m,n)){
for(int j=0; j<n; j++)
{cout<<m[i][j]<<" ";}cout<<endl;}
}
int main()
{
int n;
matrice m;
vettore v;
cout<<"Inserisci n, cioe' l'ordine della matrice: ";
cin>>n;
carica(m,n);
copia(v,m,n);
vediv(v,n);
vedim(m,n);
system("pause");
return(1);
}
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 lordinamento. Per lo sviluppo del programma
si utilizzino ove possibile sottoprogrammi.
#include <iostream>
#include <stdlib.h>

using namespace std;


#define nmax 100
void
void
void
void

leggivet(int vet[], int n);


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

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


{
int v1[nmax],v2[nmax],v3[2*nmax];
int n,m;
do{
cout<<"Inserisci la dimensione del primo vettore"<<endl;
cin>>n;
cout<<"Inserisci la dimensione del secondo vettore"<<endl;
cin>>m;
}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)
{
int i;
for(i=0;i<n;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>vet[i];
}
}

void stampavet(int vet[], int n)


{
int i;
for(i=0;i<n;i++)
cout<<"v["<<i<<"]="<<vet[i]<<endl;
}
void fusioneOrd(int v1[],int v2[],int v3[],int n,int m)
{
int i,j,k;
k=0;i=0;j=0;
while(k<n+m)
{
while(((v1[i]<=v2[j])||(j==m))&&(i<n))
{
v3[k]=v1[i];
k++;i++;
}
while(((v2[j]<=v1[i])||(i==n))&&(j<m))
{
v3[k]=v2[j];
k++;j++;
}
}
}
void bubblesort(int v[], int n)
{
int i, j, temp;
for(i=0;i<n-1;i++)
for(j=0;j<n-i-1;j++)
if(v[j]>v[j+1])
{
temp=v[j];
v[j]=v[j+1];
v[j+1]=temp;
}
}
/* 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[])
{
char str[MAX_LEN];
cout << "Inserire una stringa di 60 caratteri)\n";
cin.getline(str,MAX_LEN-1);
contalettere(str,MAX_LEN);
cout << "\n";
system("PAUSE");
return 0;
}
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){
int iniz=0;
int x;
x=strlen(str);
for (int i=iniz;i<x+1;i++){
if (str[i]==' ' || str[i]=='\0'){
if (i-iniz>=7){
stampaparola(str,iniz,i);
iniz=i+1;
}
else iniz=i+1;
}
}
}
void stampaparola (char str[MAX_LEN],const int iniz,const int i){
for (int j=iniz;j<=i;j++)
cout<<str[j];
}
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){
int j;
l=0;
for(j=i; j<strlen(s); j++)
{
if(s[j]!=' ')
{t[l]=s[j];l++;}
else break;
}
t[l]='\0';
i=(j+1);
}
int main()
{
stringa s,t;
cin.getline(s,MAX);
int l,i=0,cont=0;
cout<<"La stringa e' di dimensione "<<strlen(s)<<endl<<"Ecco
le parole con dimensione maggiore/uguale di 7:"<<endl;
while(i<strlen(s)){
estrai(s,t,i,l);
if(l>=7)
{cout<<cont+1<<"^ parola: "<<t<<" di dimensione
"<<l<<endl;cont++;}
}
if(cont==0) cout<<"Nessuna parola ha dimensione
maggiore/uguale di 7!"<<endl;
system("pause");
return(1);
}
#include
#include
#include
#include

<cstdlib>
<iostream>
<string.h>
"header.h";

using namespace std;


int main(int argc, char *argv[])
{
char s[n];
int i,j,lung;
cout<<"Inserire una stringa di massimo 60 caratteri :";
cin.getline(s,60);

lung=strlen(s);
for(i=0;((s[i]!=' ')&&(i<lung));i++)
{ j=i;
estraiParola(s,i,lung);
cout<<"\n La lunghezza della parola letta e' :"<<(i-j);
if((i-j)>7)
{ cout<<"\n La parola e': ";
while((s[i]!=' ')&&(i<lung))
{ cout<<s[i];
i++;
}
}
else
cout<<"\n\t\t ** 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)
{ cout<<"\n SCANSIONE PAROLA ";
while((s[i]!=' ')&&(i<lung))
{ cout<<"\n"<<s[i];
i++;
}
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[])
{
char S[DIM];
cout<<"\n Inserisci la stringa : ";
cin.getline(S,DIM-1);
int l=strlen(S);
if(palindroma(S,l))
cout<<"\n La parola e' sicuramente una parola palindroma";
else
cout<<"\n La parola non e'palindroma";

cout<<"\n ";
system("PAUSE");
return 0;
}
bool palindroma(char S[],const int l){
bool trovato=true;int i=0;
while(i<l/2 && trovato){
if(S[l-i-1]!=S[i]){
trovato=false;
}else{
i++;
}
}
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 i;
for(i=p; i<strlen(s)-1; i++)
s[i]=s[i+1]; //shift verso sinistra
s[strlen(s)-1]='\0'; //decremento la dimensione della stringa s,
dopo aver tolto il p-esimo carattere
}
int eliminalettera(stringa s,char L){
int i=0,c=0;//variabili di indice e conteggio
while(i<strlen(s)){//ricalcola sempre la lunghezza, che cambia
quando si shifta

if((s[i]>L)||
((s[i]>toupper(L))&&(s[i]==toupper(s[i]))))//elimina solo se sono
maggiori di L(confronto ASCII, anche quelli maiuscoli)
{shifta(s,i);c++;}
else i++;
}
return c;
}
int main()
{
stringa s;
cout<<"Inserisci una stringa: ";
cin>>s;
char L;
cout<<"Inserisci un carattere per l'eliminazione:";
cin>>L;
cout<<"Eliminati "<<eliminalettera(s,L)<<" caratteri dalla
stringa!"<<endl;
cout<<"La stringa modificata e': "<<s<<endl;
system("pause");
return(1);
}
modo alternativo:
#include <cstdlib>
#include <iostream>
#include <string.h>
#include "header.h"
using namespace std;
int main(int argc, char *argv[])
{
char s[n];
char L;
int cont;
cout<<" Inserire una stringa di massimo 60 lettere
dell'alfabeto: ";
cin.getline(s,n);
cout<<" Inserire carattere: ";
cin>>L;
cin.get();
cont=EliminaLettera(s,L);
cout<<"\n Sono state cancellate "<<cont<<" lettere!!!";
cout<<" La striga ora e' la seguente: ";
cout<<s;
cout<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
//prototipi e funzioni
int EliminaLettera(char[],char);

const int n=60;


int EliminaLettera(char s[],char L)
{ int i=0,j,cont=0;
while(s[i]!='\0')
{
cout<<"\n iL NUMERO CORRISPONDENTE AD a: "<<'a'<<endl;
if(((s[i]>tolower(L))&& (s[i]<'z')) ||
((s[i]>toupper(L))&& (s[i]<'Z')))
{ j=i;
while(s[j]!='\0')
{ s[j]=s[j+1];
j++;
}
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)
{
cin>>n;
for(int i=0; i<n; i++)
{cout<<"Inserisci un elemento: ";
cin>>v[i];
}
}
void vedi(vettore v,int n)
{
for(int i=0; i<n; i++)
cout<<v[i]<<" ";
}
bool nonce(vettore v,int p,int a){
int i;
for(i=0; i<p; i++)
if (v[i]==a)
return false;
return true;
}

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


{
int i,j=0,d=n1+n2;
int C[d];
for(i=0; i<n1; i++)
{
if(nonce(C,j,A[i])==true)
{C[j]=A[i];j++;}
else d--;
}
for(i=0; i<n2; i++)
{
if(nonce(C,j,B[i])==true)
{C[j]=B[i];j++;}
else d--;
}
cout<<endl<<"Il vettore C e':";
vedi(C,d);
}
int main()
{
vettore A,B;
int n1,n2;
carica(A,n1);
carica(B,n2);
unisci(A,B,n1,n2);
system("pause");
return(1);
}
*/ 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){
int i;
for(i=0; i<n; i++){
cout<<"Inserisci l'elemento V["<<i+1<<"]: ";
cin>>v[i];}

}
//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){
int i;
for(i=0; i<n; i++){
if(i%2!=0)/*i di posto pari*/
v2[i]=v1[i]*x;
else//i di posto dispari
v2[i]=v1[i]+x;
}
}
void vedi(vettore v,int n){
int i;
cout<<endl;
for(i=0; i<n; i++)
cout<<v[i]<<" ";
}
int main()
{
vettore v1,v2;
int n,X;
cout<<"Inserisci n:";
cin>>n;
carica(v1,n);
cout<<"Inserisci l'elemento X:";
cin>>X;
costruisci(v1,v2,n,X);
cout<<endl<<"Vettore originario:";
vedi(v1,n);
cout<<endl<<"Vettore costruito:";
vedi(v2,n);
system("pause");
return(1);
}
*/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){
do{
cout<<"Inserisci il fattore di riempimento:";
cin>>n;
}while((n<0)||(n>100)); //controllo lettura fattore di
riempimento per n di [0;100]
for(int i=0; i<n; i++){cout<<"Inserisci l'elemento
V["<<i+1<<"]: ";cin>>v[i];}
}
void vedi(vettore v,int n){
for(int i=0; i<n; i++)cout<<v[i]<<"
}

";

void costruire(vettore v1,int n1,vettore v2,int n2,vettore v3,int


&n3){
int i;
bool primo=true;//inizio alternativamente dal primo vettore,
per ipotesi! :D
for(i=0; i<n1; i++){
if(primo==true){//se primo vero, allora leggo il
primo vettore, v1
v3[i]=v1[i];primo=false;}//assegno ed imposto la
lettura di v2
else//se primo falso leggo il secondo vettore, v2
{
if(i<n2)//controllo se n2<n1! Se vero,
continuer sempre a leggere v1 fino a i=n1-1!
{v3[i]=v2[i];}
else i--;
primo=true;}//imposto la lettura di v1
}//fine ciclo for di n1
if(n1<n2){while(i<n2){v3[i]=v2[i];i++;}}
//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()
{
vettore v1,v2,v3;
int n1,n2,n3;
carica(v1,n1);

carica(v2,n2);
costruire(v1,n1,v2,n2,v3,n3);
cout<<endl<<"Il vettore v3 e':"<<endl;
vedi(v3,n3);
system("pause");
return(1);
}
*/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){
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
{cout<<"Inserisci l'elemento
M["<<i+1<<";"<<j+1<<"]:";cin>>m[i][j];}
}
void vedi(matrice m,int n){
for(int i=0; i<n; i++){
for(int j=0; j<n; j++)
cout<<m[i][j]<<"
cout<<endl;}
}
int diagp(matrice m,int n){
int i,s=0;
for(i=0; i<n; i++)
s+=m[i][i];
return s;
}
int diags(matrice m,int n){
int i,s=0;
for(i=0; i<n; i++)
s+=m[i][(n-1)-i];
return s;
}

";

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


int i,j;
for(i=0; i<n; i++)
for(j=0; j<n; j++)
t[i][j]=m[j][i];
}
void verifica(matrice m,matrice t,int n){
cout<<"Matrice originaria:"<<endl;
cout<<"La somma della diagonale principale e':
"<<diagp(m,n)<<endl;
cout<<"La somma della diagonale secondaria e':
"<<diags(m,n)<<endl;
cout<<"Matrice trasposta:"<<endl;
cout<<"La somma della diagonale principale e':
"<<diagp(t,n)<<endl;
cout<<"La somma della diagonale secondaria e':
"<<diags(t,n)<<endl;
if((diagp(m,n)==diagp(t,n)&&(diags(m,n)==diags(t,n))))
cout<<endl<<"La somma delle diagonali di entrambe le
matrici e' rimasta invariata!";
}
int main()
{
matrice m,t;
int n;
cout<<"Inserisci il fattore di riempimento NxN:";
cin>>n;
carica(m,n);
cout<<"Matrice originaria:"<<endl;
vedi(m,n);
trasposta(m,t,n);
cout<<"Matrice trasposta:"<<endl;
vedi(t,n);
verifica(m,t,n);
system("pause");
return(1);
}
codice scrivi_mat e trasp
void trasposta (int M[][DIM], int dim){
int i,j, temp;
for(i=0;i<dim;i++){

for (j=i;j<dim;j++){
temp=M[i][j];
M[i][j]=M[j][i];
M[j][i]=temp;
}
}
}
void scrivi_mat (int M[][DIM], int dim){
int i,j;
cout<<endl;
cout<<"La matrice :"<<endl;
for (i=0;i<dim;i++){
for (j=0;j<dim;j++)
cout<<" "<<M[i][j];
cout<<endl;
}
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[])
{
int n;
cout<<"inserisci il valore di riga della matrice quadrata\n";
cin>>n;
int M[n][n];
//riempimento prima riga.
for (int i=0;i<n;i++){
M[0][i]=i+1;
}
//riempimento prima colonna
for(int i=0;i<n;i++){
M[i][0]=i+1;
}
//calcolo tabella
for(int i=1;i<n;i++){
for(int j=0;j<n;j++){
M[i][j]=M[i][0]*M[0][j];
}
}
//stampa
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){

cout<<M[i][j]<<" ";
}
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++){
M[0][i]=i+1;
}
quindi ti scrive alla prima riga i valori 1 2 3 .... n
//riempimento prima colonna
for(int i=0;i<n;i++){
M[i][0]=i+1;
}
invece ti scrive gli stessi valori nella colonna 0
//calcolo tabella
for(int i=1;i<n;i++){
for(int j=0;j<n;j++){
M[i][j]=M[i][0]*M[0][j];
}
}
infine ti calcola tutti gli altri valori.
Modo alternativo
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
M[i][j]=(i+1)*(j+1);}
}
*/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){
for(int i=0; i<nr; i++)
for(int j=0; j<nc; j++)
{cout<<"Inserisci un elemento: ";

cin>>m[i][j];}
}
//PROCEDURE FONDAMENTALE
void elimina(matrice m,int &nr,int nc,int riga){
for(int i=riga; i<nr-1; i++)
for(int j=0; j<nc; j++)
m[i][j]=m[i+1][j];
nr--;
}
void vedi(matrice m,int nr,int nc){
for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++)
cout<<m[i][j];
cout<<endl;}
}
int main()
{
matrice m;
int nr,nc,riga;
cout<<"Inserisci numero righe:";
cin>>nr;
cout<<"Inserisci numero colonne:";
cin>>nc;
cout<<"Inserisci riga da eliminare:";
cin>>riga;
carica(m,nr,nc);
elimina(m,nr,nc,riga); //eliminer la riga-esima riga(ricorda
che se metti in input 1, elimina la riga 0! Altrimenti devi
passare "riga-1")
vedi(m,nr,nc);
system("pause");
return(1);
}
*/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){
cout<<"Inserisci una frase:";

cin.getline(s,MAX);
if(s[strlen(s)-1]!='.') //se l'utente dimentica l'inserimento
del punto, glielo piazzio io!:D
{s[strlen(s)]='.';s[strlen(s)+1]='\0';}
}
//OCCHIO ALLA PROCEDURE: carica in una matrice per riga le
stringhe e le stampa partendo dall'ultima riga
void stampa(stringa s){
matrice m;//Definizione matrice di contenimento
int c=0,i=0,j;
while(c<strlen(s)-1){//ciclo di creazione della matrice, si
parte da strlen(s)-1 per la presenza del punto alla finde della
stringa
if(s[c]!=' ')//se il carattere diverso dallo spazio,
inizio a caricare la i-esima parola nella i-esima riga della
matrice
{j=0;
while((s[c]!=' ')&&(c<strlen(s)-1)){//caricamento iesima riga della matrice
m[i][j]=s[c];
j++;c++;//scorro avanta con le colonne e con i
caratteri della parola
}
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<<i+1<<"^ parola: ";
while(m[i][j]!='\0')//lettura dei caratteri di
ogni riga...
{cout<<m[i][j];j++;if(m[i]
[j]=='\0')cout<<" con "<<j<<" caratteri."<<endl;}
cout<<endl;j=0;}
}
int main()
{
stringa s;
//solo due funzioni!
leggi(s);
stampa(s);
system("pause");
return(1);
}

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){
cout<<"Inserisci una frase:";
cin.getline(s,MAX);
}
void stampa(stringa s){
//variabile booleana che indica la lettura di una
parola(true) o meno(false)
bool par=false;
int i,c=0,j=0;
//stringa di appoggio
stringa t;
cout<<endl;
//variabile della dimensione della frase, si tiene conto se il
punto('.') c' o non c'!
int n;
if(s[strlen(s)-1]=='.')//il punto c' e si parte da dim-2
n=strlen(s)-2;
else//non c' e si parte da dim-1
n=strlen(s)-1;
//ciclo di creazione delle parole "inverse"
for(i=n; i>=0; i--){
//se siamo in prossimit di uno spazio o
stiamo all'inizio della frase, allora stampiamo la parola
intermedia
if (((s[i]==' ')||(i==0))&&(par==true))
{//metto la clausola par==true, altrimenti gli spazi rompono
il .....
//clausola quando il primo
carattere diverso da ' '
if((s[0]!=' ')&&(i==0))t[j+
+]=s[0];
//chiudiamo la parola attuale
t[j]='\0';
j=0;
//stampiamo la parola dall'ultimo
carattere al primo
for(int c=strlen(t)-1; c>=0; c--)
{cout<<t[c];}

//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]!=' ')
{par=true;t[j]=s[i];j++;}
}
}
int main()
{
stringa s;
leggi(s);
stampa(s);
system("pause");
return(1);
}
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
Codice:
[b] else if (s[i]!=' ')
{par=true;t[j]=s[i];j++;} [/b]
}
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
Codice:
[b]if (((s[i]==' ')||(i==0))&&(par==true)){[/b]
if((s[0]!=' ')&&(i==0))t[j+
+]=s[0];

t[j]='\0';
j=0;
for(int c=strlen(t)-1; c>=0;
c--)
{cout<<t[c];}
cout<<" di dimensione
"<<strlen(t)<<endl;
t[0]='\0';
par=false;
}

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
Codice:
#ifndef
#define
#define
typedef

libreria
libreria
MAX 100
char stringa[MAX];

void mostra(stringa s);


void mostra(stringa s);
void estrai(stringa s,stringa t,int p);
#endif
prototipi.cpp
Codice:
#include <cstdlib>
#include <iostream.h>
#include "prototipi.h"
#define MAX 100
typedef char stringa[MAX];

void mostra(stringa s);


void mostra(stringa s);
void estrai(stringa s,stringa t,int p);
int conta(stringa s){
int i=0,c=0;
if(s[0]!=' ')c++;
while((s[i]!='.')&&(i<strlen(s))){
if((s[i]==' ')&&(s[i+1]!=' ')&&(s[i+1]!='.'))
c++;
i++;
}
return c;
}
void estrai(stringa s,stringa t,int p){
int i=0,c=0,j=0;
if(s[0]!=' ')c++;
while((s[i]!='.')&&(i<strlen(s))){
if((s[i]==' ')&&(s[i+1]!=' '))
c++;
if((p==c)&&(s[i]!=' '))
{t[j]=s[i];j++;}
i++;
}
t[j]='\0';
}
void mostra(stringa s){
int i;
stringa t;
cout<<"La frase contiene: "<<conta(s)<<" parole."<<endl;
for(i=conta(s); i>0; i--){
estrai(s,t,i);
cout<<"La "<<i<<"^ parola con "<<strlen(t)<<"
caratteri, e': |"<<t<<"|"<<endl;
}
}
main
Codice:
#include <cstdlib>
#include <iostream>
#include "prototipi.h"
using namespace std;
int main(int argc, char *argv[])
{

stringa s;
cout<<"Inserisci una frase:";
cin.getline(s,MAX);
mostra(s);
system("PAUSE");
return EXIT_SUCCESS;
}
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[])
{
int M[DIM][DIM];
int n,ris,risu,i,j;
leggi(M,n);
cout<<"la matrice e'"<<endl;
scrivi_mat (M,n);
cout<<"\n Il minimo e' : "<<ris=minimo(M,n,i,j);
cout<<\n Gli indici del minimo sono : <<i<< e <<j;
cout<<"\n Il max e' : "<<risu=max(M,n,i,j);
cout<<\n Gli indici del max sono : <<i<< e <<j;
cout<<"\n";
system("PAUSE");
return 0;
}
void leggi(int M[][DIM],int & n){
cout<<"\n Inserisci il fattore di riempimento";
cin>>n;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<"\n Elemento ["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}

}
void scrivi_mat (int M[][DIM], int dim){
int i,j;
cout<<endl;
cout<<"La matrice :"<<endl;
for (i=0;i<dim;i++){
for (j=0;j<dim;j++)
cout<<" "<<M[i][j];
cout<<endl;
}
cout<<endl;
}
int minimo(int M[][DIM],int dim,int &i,int &j){
int min=M[0][0];
for(int i=0;i<dim;i++){
for(int j=0;j<dim;j++){
if(min>M[i][j])
min=M[i][j];
}
}
return min;
}
int massimo(int M[][DIM],int dim,int &i,int &j){
int max=M[0][0];
for(int i=0;i<dim;i++){
for(int j=0;j<dim;j++){
if(max<M[i][j])
max=M[i][j];
}
}
return max;
}
ALTRO MODO
MAIN:
#include <iostream>
#include <cstdlib>
#include "prototipi.h"
using namespace std;
int main()
{
int righe,colonne;
matrix A;
righe=leggi_dim_righe();
colonne=leggi_dim_colonne();
leggi_matrix(A,righe,colonne);

stampa(A,righe,colonne);
operazione(A,righe,colonne);
system("PAUSE");
return 0;
}
FUNZIONI:
#include <iostream>
#include <cstdlib>
#include "prototipi.h"
using namespace std;
int leggi_dim_righe()
{
cout<<"inserire il numero di righe: ";
int r;
bool e;
do{
cin>>r;
e=r<=0 || r>100;
if (e)
cout<<"La dimensione deve essere compresa tra 1 e 100"<<endl;
}
while (e);
return r;
}
int leggi_dim_colonne()
{
cout<<"inserire il numero di colonne: ";
int c;
bool e;
do{
cin>>c;
e=c<=0 || c>100;
if (e)
cout<<"La dimensione deve essere compresa tra 1 e 100"<<endl;
}
while (e);
return c;
}
void leggi_matrix(matrix M,int r,int c)
{
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{

cout<<endl<<"inserire l'elemento di posizione: ";


cout<<"["<<i<<"]["<<j<<"]: ";
cin>>M[i][j];
}
}
}
void stampa(matrix M,int r,int c)
{
cout<<"la matrice risulta: "<<endl;
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
cout<<M[i][j]<<" ";
if(j==c)
{
cout<<endl;
}
}
}
}
void elimina_riga_colonna(matrix M,int r,int c)
{
int choice,del;
cout<<endl<<"indicare se si desidera annullare una riga[1] o una
colonna[2]: ";
cin>>choice;
switch(choice)
{
case 1:
cout<<endl<<"inserire la riga da cancellare: ";
cin>>del;
if(del<=r)
{
for(int i=0;i<=c;i++)
{
M[del][i]=0;
}
}
else
{
cout<<endl<<"la riga selezionata non esiste nella matrice";
elimina_riga_colonna(M,r,c);
}
break;
case 2:
cout<<endl<<"inserire la colonna da cancellare: ";
cin>>del;
if(del<=c)
{

for(int j=0;j<=r;j++)
{
M[j][del]=0;
}
}
else
{
cout<<endl<<"la colonna selezionata non esiste nella matrice";
elimina_riga_colonna(M,r,c);
}
break;
default:
cout<<endl<<"sparati e chiedi a qualcuno di inserire dati
coerenti";
}
if(del==1 || del==2)
{
stampa(M,r,c);
}
}
void operazione(matrix M,int r,int c)
{
int n;
cout<<endl<<"si desidera eliminare una riga o colonna dgt (1) ";
cout<<endl<<"si desidera trovare l'elemento minimo dgt (2) ";
cout<<endl<<"si desidera trovare l'elemento massimo dgt (3) ";
cout<<endl<<"Premere (0) per interrompere le operazioni sulla
matrice"<<endl;
cin>>n;
switch(n)
{
case 1:
elimina_riga_colonna(M,r,c);
operazione(M,r,c);
break;
case 2:
minimo(M,r,c);
operazione(M,r,c);
break;
case 3:
massimo(M,r,c);
operazione(M,r,c);
break;
default:
cout<<endl<<"arrivederci"<<endl;
}
}
void minimo(matrix M,int r,int c)
{
int min;

int p=1;
int q=1;
min=M[1][1];
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
if(min>M[i][j])
{
min=M[i][j];
p=i;
q=j;
}
}
}
cout<<endl<<"il minimo e': "<<min<<" alla posizione ["<<p<<"]
["<<q<<"]"<<endl;
}
void massimo(matrix M,int r,int c)
{
int max;
int p=1;
int q=1;
max=M[1][1];
for(int i=1;i<=r;i++)
{
for(int j=1;j<=c;j++)
{
if(max<M[i][j])
{
max=M[i][j];
p=i;
q=j;
}
}
}
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 n;
cout<<"inserisci il valore della riga della matrice\n";
cin>>n;
int M[n][n];
cout<<"inserisci gli elementi della matrice\n";
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
cin>>M[i][j];
}
}
int COMP=0;
int indR, indC;
//componente pi grande
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(M[i][j]>COMP){
COMP=M[i][j];
indR=i;
indC=j;
}
}
}

int comp=M[0][0];
int indRc,indCc;
//componente pi piccola
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(M[i][j]<comp){
comp=M[i][j];
indRc=i;
indCc=j;
}
}
}
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 n;
cout<<"inserisci il valore della riga della matrice quadrata\n";
cin>>n;
int M[n][n];
//inserimento
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>M[i][j];
}
}
int h=0;
int k=0;
//controllo riga
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(M[i][j]!=0) break;
else if (j==n-1) h++;

}
}
//controllo colonna
for (int j=0;j<n;j++){
for(int i=0;i<n;i++){
if(M[i][j]!=0) break;
else if (i==n-1) k++;
}
}
cout<<"la matrice ha "<<h<<" righe composte da elementi tutti
nulli\n";
cout<<"la matrice ha "<<k<<" colonne composte da elementi tutti
nulli\n";
//stampa
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cout<<M[i][j]<<" ";
}
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[])
{int Matrice[DIM][DIM];
int fill;
bool fine=false;
do{
cout<<"CONTEGGIO DELLE RIGHE E COLONNE NULLE DI UNA MATRICE
QUADRATA"<<endl;

cout<<"\n Inserisci il riempimento di riga e di colonna (max. 50):


"; cin>>fill;
if (fill>DIM) cout<<"\n Il riempimento inserito non e'
valido!"<<endl;
else scrivi_matrice (Matrice,fill);
cout<<"\n Un altro giro? (SI'=1/NO=0) "; cin>>fine;
cout<<"\n";
}while(fine);
system("PAUSE");
return 0;
}
void scrivi_matrice (int Matrice [][DIM],int fill)
{int i,j,row=0,col=0;
for (i=0; i<fill; i++){
for (j=0; j<fill; j++){
cout<<"Elemento di posto ["<<i<<"] ["<<j<<"]: "; cin>>Matrice[i]
[j];
}
if (esamina_riga (Matrice,fill,i)) {
cout<<"\n La riga di indice "<<i<<" e' nulla!"<<endl;
cout<<"\n";
row++;
}
}
for (j=0; j<fill; j++){
if (esamina_colonna (Matrice,fill,j)) {
cout<<"\n La colonna di indice "<<j<<" e' nulla!"<<endl;
cout<<"\n";
col++;
}
}
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)
{int k;
bool trovato=true;
for (k=0; k<fill; k++){
if (Matrice[i][k]!=0) trovato=false;}
return trovato;
}
bool esamina_colonna (int Matrice[][DIM],int fill,int j)
{int l;
bool trovato=true;
for (l=0; l<fill; l++){
if (Matrice[l][j]!=0) trovato=false;}
return trovato;
}
MODO ALTERNATIVO

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


{
int zeri;
int nulle=0;
int j=1;
while(j<=r)
{
zeri=0;
for(int i=1;i<=c;i++)
{
if(M[j][i]==0)
{
zeri++;
}
}
if(zeri==c)
{
nulle++;
}
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){
cout<<"Inserisci nr:";
cin>>nr;
cout<<"Inserisci nc:";
cin>>nc;
for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++)
{cout<<"Inserisci M["<<i+1<<";"<<j+1<<"]: ";
cin>>m[i][j];
}
}

}
void vedi(matrice m,int nr,int nc){
cout<<"La matrice e':"<<endl;
for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++)
cout<<m[i][j]<<"
cout<<endl;
}
}

";

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


for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++)
if(m[i][j]==0)
cout<<"0 in riga: "<<i+1<<" e
colonna: "<<j+1<<endl;
}
}
void verifica(matrice m,int nr,int nc){
int nulli=0;
for(int i=0; i<nr; i++){
for(int j=0; j<nc; j++)
if(m[i][j]==0)
nulli++;
}
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()
{
matrice m;
int nr,nc;
carica(m,nr,nc);
vedi(m,nr,nc);
verifica(m,nr,nc);
system("pause");
return(1);
}
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(tabella[iN][iM] == 0)
iNumNulli++;
}
if(iNumNulli > iNumMaxNulli)
{
for(int i = 0; i < iN; i++)
for(int k = 0; k < iM; k++)
{
if(tabella[iN][iM] != 0)
cout << "Elemento " << iN << "," << iM << ":" << tabella[iN]
[iM] << endl;
}
}
*/GIOCO DEL TRIS
MAIN:
#include <iostream>
#include <cstdlib>
#include "prototipi.h"
using namespace std;
int main()
{
griglia TRIS;
nome nam1,nam2;
presentazione(nam1,nam2);
assegna(TRIS);
stampa(TRIS);
gioco(TRIS,nam1,nam2);

system("PAUSE");
return 0;
}
FUNZIONI:
#include <iostream>
#include <cstdlib>
#include "prototipi.h"
using namespace std;
void assegna(griglia T)
{
for(int i=1;i<=3;i++)
{
for(int j=1;j<=3;j++)
{
T[i][j]='-';
}
}
}
void presentazione(nome n1,nome n2)
{
cout<<"giocatore1 inserisci il tuo nome: ";
cin>>n1;
cout<<"giocatore2 inserisci il tuo nome: ";
cin>>n2;
}
void stampa(griglia T)
{
cout<<"Ecco la tua griglia: "<<endl<<endl;
for(int i=1;i<=3;i++)
{
for(int j=1;j<=3;j++)
{
cout<<" "<<T[i][j]<<" ";
if(j==3)
{
cout<<endl;
}
}
}
cout<<endl;
}
void giocatore1(griglia T)

{
int a,b;
cout<<" inserire la riga: ";
cin>>a;
cout<<" inserire la colonna: ";
cin>>b;
if(T[a][b]=='-')
{
T[a][b]='X';
stampa(T);
}
else
{
cout<<"non si imbroglia, str****!!"<<endl;
giocatore1(T);
}
}
void giocatore2(griglia T)
{
int a,b;
cout<<" inserire la riga: ";
cin>>a;
cout<<" inserire la colonna: ";
cin>>b;
if(T[a][b]=='-')
{
T[a][b]='O';
stampa(T);
}
else
{
cout<<"non si imbroglia, str****!!"<<endl;
giocatore2(T);
}
}
void gioco(griglia T,nome n1,nome n2)
{
int i=0;
int a=0;
while(i<9)
{
if(i%2==0 && a==0)
{
giocatore1(T);
verifica_tris(T,a,n1,n2);
}
if(i%2==1 && a==0)
{
giocatore2(T);
verifica_tris(T,a,n1,n2);

}
i++;
}
}
void verifica_tris(griglia M,int &o,nome n1,nome n2)
{
o=0;
if((M[1][1]=='X' && M[1][2]=='X' && M[1][3]=='X')||(M[2][1]=='X'
&& M[2][2]=='X' && M[2][3]=='X')||(M[3][1]=='X' && M[3][2]=='X' &&
M[3][3]=='X'))
{
cout<<"Complimenti "<<n1<<" hai vinto tu!!!"<<endl;
o=1;
}
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'))
{
cout<<"Complimenti "<<n1<<" hai vinto tu!!!"<<endl;
o=1;
}
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'))
{
cout<<"Complimenti "<<n1<<" hai vinto tu!!!"<<endl;
o=1;
}
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'))
{
cout<<"Complimenti "<<n2<<" hai vinto tu!!!"<<endl;
o=1;
}
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'))
{
cout<<"Complimenti "<<n2<<" hai vinto tu!!!"<<endl;
o=1;
}
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'))
{
cout<<"Complimenti "<<n2<<" hai vinto tu!!!"<<endl;
o=1;
}
}
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
1)
#include <iostream.h>
#include <stdlib.h>
typedef char Stringa[30];
typedef struct Studente
{
char nome[30];
char cognome[30];
int
anni;
};
void leggiStruct(Studente * s);
void stampaStruct(Studente s);
int contenuta(Stringa s1, Stringa S2);

int main()
{
Studente v[100];
char str[30];
int n, i;
cout<<"Quanti studenti vuoi inserire ?\n";
cin>>n;
for (i=0;i<n;i++)

leggiStruct(&v[i]);
cout<<"Inserisci la sottostringa da ricercare nel campo nome
\n";
cin.getline(str,30);
for(i=0;i<n;i++)
if(contenuta(v[i].nome, str))
stampaStruct(v[i]);
system("PAUSE");
return 0;
}

void leggiStruct(Studente * s)
{
cout<<"Inserisci nome \n";
cin>>s->nome;
cout<<"Inserisci cognome \n";
cin>>s->cognome;
cout<<"Inserisci anni \n";
cin>>s->anni;
}
void stampaStruct(Studente s)
{
cout<<"Nome: \n"<< s.nome;
cout<<"Cognome: %s \n"<<s.cognome;
cout<<"Anni: %d \n"<< s.anni;
}

int contenuta(Stringa v1, Stringa v2)


{
//verifica
che v2 sia contenuta in v1
int cont=0;
int i=0,j=0;
int again;
while(v1[i]!='\0')
{
j=0;

//confronto primo carattere della stringa contenuta


if(v1[i]==v2[j])
{
//memor
izzazione posizione da cui ricominciare nuova ricerca
again=i+1;
//confronto restanti caratteri
do{
i+
+;
j+
+;
}
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()
{
char s[N];
int numC=0;
cout<<"Inserici la stringa\n";
cin.getline(s,N);
numC=contaP(s);
cout<<"ci sono"<<numC<<" parole nella stringa";
system("PAUSE");
return 0;
}

int contaP(char v[])


{
int i=0,occ=0;
//toglie i caratteri vuoti in testa
while(v[i]==' ')
{
i++;
}
while(v[i]!='\0')
{
//incremento fino a termine parola
while((v[i]!=' ')&&(v[i]!='\0'))
i++;
occ++;
//eliminazione spazi bianchi
while(v[i]==' ')
i++;
}
return occ;
}
3) #include <iostream.h>
#include <stdlib.h>
#define N 100
bool contenuta(char v1[], char v2[]);
int main()
{
char s1[N],s2[N];
bool cont=false;
cout<<"Inserici la prima stringa\n";
cin.getline(s1,N);
cout<<"Inserici la seconda stringa\n";
cin.getline(s2,N);
if(strlen(s1)<strlen(s2))
{
cont=contenuta(s2,s1);
if(cont)
cout<<"la stringa"<<s1<<"e' contenuta nella stringa"<<s2;
}

else
{
cont=contenuta(s1,s2);
if(cont)
if(strlen(s1)==strlen(s2))
cout<<"le stringhe sono uguali \n";
else
cout<<"la stringa"<<s2<<"e' contenuta nella stringa"<<s1;
}
if(!cont) cout<<"nessuna delle stringhe e' contenuta
nell'altra\n";
system("PAUSE");
return 0;
}

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


{
//verifica
che v2 sia contenuta in v1
bool cont=false;
int i=0,j=0;
int again;
while((v1[i]!='\0')&(v2[j]!='\0'))
{
j=0;
//confronto primo carattere della stringa contenuta
if(v1[i]==v2[j])
{
//memor
izzazione posizione da cui ricominciare nuova ricerca
again=i+1;
//confronto restanti caratteri
do{

i+
+;
j+
+;
}
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()
{
char s[N];
cout<<"Inserisci la stringa da invertire\n";
//printf("Inserisci la stringa da invertire\n");
cin.getline(s,N);
//scanf("%s",s);
inverti2(s);
cout<< "\nStringa invertita: " <<s;
system("PAUSE");
return 0;
}
void scambia(char *a, char *b)
{

char aux;
aux = *a;
*a = *b;
*b = aux;
}
/* Funzione che calcola la lunghezza della stringa */
int lung(char s[])
{
int i=0;
/* incremento il contatore fintanto che non incontro il carattere
di terminazione */
while(s[i] != '\0')i++;
return i;
}
void inverti2(char v[])
{
int i,l;
l = lung(v);
for (i=0; i<l/2; i++) scambia(&v[i],&v[l-i-1]);
}
5) #include <iostream.h>
#include <stdlib.h>
#define N 31
int conta(char v[],char x);
int main()
{
char s[N];
char x;
int numC=0;
cout<<"Inserici la stringa\n";
cin.getline(s,N);
cout<<"Inserisci il carattere da cercare\n";
cin>>x;
numC=conta(s,x);
cout<<"Il carattere"<<x<<"e' presente"<<numC<<"volte nella
stringa \n";
system("PAUSE");
return 0;
}

int conta(char v[],char x)


{
int i=0,occ=0;
while(v[i]!='\0')
{
if(v[i]==x)
occ++;
i++;
}
return occ;
}
6) #include <stdio.h>
#include <stdlib.h>
#include <iostream>
typedef char stringa[30] ;
typedef struct contatto
{
stringa nome;
stringa cognome;
long telefono ;
};
void ordina(contatto v[], int n);
void stampaStruct(contatto s);
void inserisciRecord(contatto v[], int *n);
void main()
{
contatto rub[100];
int i;
int risposta, numCont=0;
int stop=0;
do{
cout<<"Scegli l'operazione da effettuare \n";
cout<<"1-inserisci record \n2- ordina rubrica \n3 - stampa
rubrica \n4 - esci\n";
cin>> risposta;
switch(risposta)
{
case 1:
inserisciRecord(rub,&numCont);
break;

case 2:
ordina(rub,numCont);
break;
case 3: {for (i=0;i<numCont;i++)
stampaStruct(rub[i]); }
break;
case 4:
stop=1;
break;
default:
cout<<"Opzione non valida \n";
}
}
while(stop==0);
}
void inserisciRecord(contatto v [ ], int * n)
{
int temp,i;
cout<<"Quanti record vuoi inserire ?";
cin>>temp;
for(i=*n;i<(*n+temp);i++)
{
cout<<"inserisci nome \n";
cin>>v[i].nome;
cout<<"inserisci cognome \n";
cin>>v[i].cognome;
cout<<"inserisci telefono \n";
cin>>v[i].telefono;
}
*n=i;
}
void ordina(contatto v [ ], int n)
{

int i,j;
contatto
temp;
for(i=0;i<n;i++)
for(j=0;j<n-i-1;j++)
if(v[j].nome[0]>v[j+1].nome[0])
{
strcpy(temp.nome,v[j].nome);
strcpy(v[j].nome,v[j+1].nome);
strcpy(v[j+1].nome,temp.nome);

strcpy(temp.cognome,v[j].cognome);
strcpy(v[j].cognome,v[j+1].cognome);
strcpy(v[j+1].cognome,temp.cognome);
temp.telefono=v[j].telefono;
v[j].telefono=v[j+1].telefono;
v[j+1].telefono=temp.telefono;
}
}
void stampaStruct(contatto
{

s)

cout<<"Nome: "<< s.nome <<endl;


cout<<"Cognome: "<<s.cognome<<endl;
cout<<"Anni: "<< s.telefono<<endl;
}
7) #include <iostream.h>
#include <stdlib.h>
void
void
void
bool

leggid(int &giorno, int &mese);


legginascita(int &giorno_n, int &mese_n);
verifica( int giorno, int mese, int giorno_n, int mese_n,
auguri);

int main()
{
int nuovo_giorno, nuovo_mese;
int giorno_nascita, mese_nascita;
bool auguri;
//legge giorno attuale
cout<<"inserisci che giorno e' oggi"<<endl;
cin >>nuovo_giorno;
cout<<"inserisci il mese di oggi"<<endl;
cin >> nuovo_mese;
//leggi data di nascita
cout<<"inserisci il giorno di nascita"<<endl;
cin >>giorno_nascita;
cout<<"inserisci il mese di nascita"<<endl;
cin >> mese_nascita;
// verifica
auguri =false;
if ((nuovo_giorno==giorno_nascita) && (nuovo_mese==
mese_nascita))
auguri =true;
if (auguri)
cout<<"auguri ";
else

cout<<"oggi e' il tuo NON compleanno ";


system("PAUSE");
return 0;

}
8) #include <iostream>
#include <stdlib.h>
using namespace std;
// calcola la media di 3 elementi inseriti da tastiera
int main()
{
int var1,var2,var3, somma;
float media;
cout<<"Inserisci il primo elemento "<<endl;
cin>>var1;

cout<<"Inserisci il secondo elemento


"<<endl;
cin>>var2;
cout<<"Inserisci il terzo elemento "<<endl;
cin>>var3;
cout<<endl;
somma=0;
media=0;
somma=var1+var2+var3;
media=somma/3;
cout<<"La media e':"<<media;
cout<<endl;
system("PAUSE");
return 0;
}
9) #include <iostream>
#include <stdlib.h>
using namespace std;
// dati tre valori, cerca il minimo ed il massimo
int main()
{
int a,b,c;
cout<<"Inserire il valore di a:"<<endl;
cin>>a;
cout<<"Inserire il valore di b:"<<endl;
cin>>b;
cout<<"Inserire il valore di c:"<<endl;
cin>>c;
if((a<=b)&&(a<=c))
cout<<"Il minimo e' "<<a<<endl;
else if ( (b<=a)&&(b<=c))
cout<<"Il minimo e' "<<b<<endl;
else
cout<<"Il minimo e' "<<c<<endl;
if((a>=b)&&(a>=c))
cout<<"Il massimo e' "<<a<<endl;
else if ( (b>=a)&&(b>=c))
cout<<"Il massimo e' "<<b<<endl;
else
cout<<"Il massimo e' "<<c<<endl;
system("PAUSE");
return 0;

}
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()
{
int v1[nmax],v2[nmax],i;
int dim1,dim2,ris;
do{
cout<<"Inserisci la dimensione del primo vettore"<<endl;
cin>>dim1;
}while(dim1<=0 || dim1>100);
cout<<"Inserisci gli elenmenti del primo vettore"<<endl;
for(i=0;i<dim1;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>v1[i];
}
do{
cout<<"Inserisci la dimensione del secondo vettore"<<endl;
cin>>dim2;
}while(dim2<=0 || dim2>100);
cout<<"Inserisci gli elenmenti del secondo vettore"<<endl;
for(i=0;i<dim2;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>v2[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)
{

for(i=0;i<dim1;i++)
{
if(v1[i]==v2[i])
{ris=ris+1;}
}
//chiusura del for
if(ris==dim1){
cout<<" I 2 vettori
inseriti dall'utente sono uguali."<<endl;
}
else{
cout<<"I 2 vettori inseriti
dall'utente NON sono uguali"<<endl;
}
} //chiusura del primo if
else
diverse"<<endl;

cout<<"i due vettori hanno dimensioni

//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) { i=0;
while ((i<dim1)&&(v1[i]==v2[i]))
{
i++;
}
//chiusura del while
if(i==dim1){
cout<<" I 2 vettori
inseriti dall'utente sono uguali."<<endl;
}
else{
cout<<"I 2 vettori inseriti
dall'utente NON sono uguali"<<endl;
}
} //chiusura del primo if
else
diverse"<<endl;

cout<<"i due vettori hanno dimensioni

// /* versione alternativa con i cili while:


cout<<"Comincia la sezione 2 di controllo con il
while"<<endl;
if(dim1==dim2)

{ i=0; bool uguali=true;


while ((i<dim1)&& (uguali))
{
if(v1[i]!=v2[i]) { uguali=false;
i++;
}
//chiusura del while

if(uguali){
cout<<" I 2 vettori
inseriti dall'utente sono uguali."<<endl;
}
else{
cout<<"I 2 vettori inseriti
dall'utente NON sono uguali"<<endl;
}
} //chiusura del primo if
else
diverse"<<endl;
//

cout<<"i due vettori hanno dimensioni

*/

system("PAUSE");
return 0;
}
11) #include <iostream>
#include <stdlib.h>
using namespace std;
//Inverte gli elementi di un vettore inserito da tastiera
int main(){
int
Vet[10], i, n, max,swap;
//Richiedi il numero di elementi del vettore (<= 10)
cout<<"Quanti elementi vuoi inserire nel vettore?(1-10)"<<endl;
cin>>n;
//Richiedi gli elementi del vettore
for (i=0;
i<n; i++) {
cout<<"Vet["<<i<<"]=";
cin>>Vet[i];
}

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

swap=Vet[i];
Vet[i]=Vet[n-i-1];
Vet[ni-1]=swap;
}
//Stampa il risultato
cout<<"Il
vettore invertito e':"<<endl;
for (i=0;
i<n; i++) {
cout<<Vet[i]<<" ";
}
system("PAUSE");
}
12) // ricerca del massimo e del minimo in una matrice
#include<iostream.h>
#include<stdlib.h>
void main()
{
int mat[100][100],r,c, max,min,i,j;
cout<<"inserisci righe"<<endl;
cin>>r;
cout<<"inserisci colonne"<<endl;
cin>>c;
//lettura elementi della matrice
for(i=0;i<r;i++)
for(j=0;j<c;j++)
{
cout<<"mat["<<i<<"]["<<j<<"] ?"<<endl;
cin>>mat[i]
[j];
}

//stampa elementi della matrice


for(i=0;i<r;i++)
{cout<<endl;
for(j=0;j<c;j++)
cout<<mat[i][j]<<" ";
}
max=mat[0][0];
min=mat[0][0];
for(i=0;i<r;i++)
for(j=0;j<c;j++)
{
if(max<mat[i][j])
max=mat[i][j];
if(min>mat[i][j])
min=mat[i][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()
{
int v[nmax];
int n,i,x;
bool trovato=false;

do{
cout<<"Inserisci la dimensione del
cin>>n;
}while(n<=0 || n>100);

vettore"<<endl;

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


for(i=0;i<n;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>v[i];
}
cout<<"Inserisci l'elemento da cercare"<<endl;
cin>>x;
i=0;
while((i<n)&&(trovato==false))
{
if(v[i]==x) trovato=true;
else i++;
}
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;
}
14) /*
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()
{
int v1[nmax],v2[nmax],i,j;
int dim1,dim2,ris;
do{
cout<<"Inserisci la dimensione del primo vettore"<<endl;

cin>>dim1;
}while(dim1<=0 || dim1>100);
cout<<"Inserisci gli elenmenti del primo vettore"<<endl;
for(i=0;i<dim1;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>v1[i];
}
do{
cout<<"Inserisci la dimensione del secondo vettore"<<endl;
cin>>dim2;
if (dim2>dim1) cout<<"dim2 deve essere minore di dim1"<<endl;
}while(dim2<=0 || dim2>100 || dim2>dim1);
cout<<"Inserisci gli elenmenti del secondo vettore"<<endl;
for(i=0;i<dim2;i++)
{
cout<<"inserisci l'elemento "<<i<<endl;
cin>>v2[i];
}
int contenuto=0, again=0;;
i=0;j=0;
while((contenuto==0) && (i<dim1-dim2+1))
{
if(v1[i]==v2[0])
{
again=++i;
j=1;
while((v1[i]==v2[j])&&(j<dim2))
{
i++;
j++;
}
if(j==dim2)
contenuto=1;
else
i=again;
}
else i++;
}
if(contenuto==1)
{
if(dim1==dim2)

cout<<"i vettori sono uguali"<<endl;


else
cout<<"il vettore 1 contenuto nel vettore 2"<<endl;
}
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()
{
int n;
float med;
cout<<"quanti valori vuoi inserire?"<<endl;
cin>>n;
med=media(n);
cout<<"la media "<<med<<endl;
system("PAUSE");
return 0;
}
float media(int n)
{
int i,somma,val;
float med;
somma=0;med=0;
for(i=0;i<n;i++){
val= ValueRead(i);
somma=somma+val;
}
med=somma/n;
return med;
}

int ValueRead(int i) {

int val;
cout<<"Inserisci il valore"<<i<<endl;
cin>>val;
return val;
}
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 res;
// chiamata di una funzione
res=ValueRead();
cout<<"Hai inserito "<<res<<endl;
system("PAUSE");
return 0;
}
int ValueRead(void) {
int val;
cout<<"Inserisci il valore"<<endl;
cin>>val;
return val;
}
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()
{
int A,B;
cout<<"Inserisci elemento A ";
cin>>A;
cout<<"Inserisci elemento B ";
cin>>B;
scambio(&A,&B);
cout<< "stampa finale"<<endl;
cout<< "A = "<<A<<endl;
cout<< "B = "<<B<<endl;

system("PAUSE");
return 0;
}
void scambio(int *A, int *B)
{
int temp;
temp=*A;
*A=*B;
*B= temp;
}
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()
{
int A,B;
int s,res;
cout<<"Inserisci elemento A ";
cin>>A;
cout<<"Inserisci elemento B ";
cin>>B;
somma(A,B,&s);
cout<< "stampo a e b fuori della procedura"<<endl;
cout<<"A="<<A<<endl;
cout<<"B="<<B<<endl;
cout<<"somma="<<s<<endl;
cout<< "stampo a e b fuori della funzione"<<endl;
cout<<"A="<<A<<endl;
cout<<"B="<<B<<endl;
res=som(A,B);
cout<<"somma="<<res<<endl;
system("PAUSE");
return 0;
}
void somma(int a, int b, int *s)
{
*s=a+b;

cout<<"sono nella procedura, inserisci un nuovo


A"<<endl;
cin>>a;
cout<<"sono nella procedura, inserisci un nuovo
B"<<endl;
cin>>b;
}
int som(int a, int b)
{
int temp;
temp=a+b;
return temp;
}
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()
{
int val;
// chiamata di una procedura
ValueRead(&val);
cout<<"Hai inserito "<<val<<endl;
system("PAUSE");
return 0;
}
void ValueRead(int *val) {
cout<<"Inserisci il valore"<<endl;
cin>>*val;
}
20) #include <stdlib.h>
#include <iostream>
typedef char Stringa[30];
typedef struct Studente
{
Stringa nome;
Stringa cognome;
int
anni;
};

int main()
{
Studente v[100];
Stringa str;
int n, i;
cout<<"Quanti studenti vuoi inserire ?";
cin>> n;
for (i=0;i<n;i++)
{
cout<<"Inserisci nome \n";
cin>>v[i].nome;
cout<<"Inserisci cognome \n";
cin>>v[i].cognome;
cout<<"Inserisci anni \n";
cin>>v[i].anni;
}
cout<<"Stampa degli studenti ";
for (i=0;i<n;i++)
{
cout<<"studente "<<i+1<<endl;
cout<<"Nome: "<< v[i].nome <<endl;
cout<<"Cognome: "<<v[i].cognome<<endl;
cout<<"Anni: "<< v[i].anni<<endl;
}
system("PAUSE");
return 0;
}
21) #include <stdio.h>
#include <stdlib.h>
#include <iostream>
typedef char Stringa[30];
typedef struct Studente
{
Stringa nome;
Stringa cognome;
int
anni;
};
void leggiStruct(Studente * s);
void stampaStruct(Studente s);

int main()
{
Studente v[100];
Stringa str;
int n, i;
cout<<"Quanti studenti vuoi inserire ?\n";
cin>>n;
for (i=0;i<n;i++)
leggiStruct(&v[i]);
for (i=0;i<n;i++)
stampaStruct(v[i]);
system("PAUSE");
return 0;
}

void leggiStruct(Studente * s)
{
cout<<"Inserisci nome \n";
cin>>s->nome;
cout<<"Inserisci cognome \n";
cin>>s->cognome;
cout<<"Inserisci anni \n";
cin>>s->anni;
/*
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
{

s)

cout<<"Nome: "<< s.nome <<endl;


cout<<"Cognome: "<<s.cognome<<endl;
cout<<"Anni: "<< s.anni<<endl;

}
22) #include <stdio.h>
#include <stdlib.h>
#include <iostream>
typedef char Stringa[30];
typedef struct Studente
{
Stringa nome;
Stringa cognome;
int
anni;
};
void leggiStruct(Studente v[],int n);
void stampaStruct(Studente v[], int n);
int main()
{
Studente v[100];
Stringa str;
int n, i;
cout<<"Quanti studenti vuoi inserire ?\n";
cin>>n;
//

for (i=0;i<n;i++)
leggiStruct(v,n);
// for (i=0;i<n;i++)
stampaStruct(v,n);
system("PAUSE");
return 0;

void leggiStruct(Studente v[],int n)


{
int i;
for (i=0;i<n;i++){
cout<<"Inserisci nome \n";
cin>>v[i].nome;
cout<<"Inserisci cognome \n";
cin>>v[i].cognome;
cout<<"Inserisci anni \n";
cin>>v[i].anni; }

/*
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
{
int i;
for (i=0;i<n;i++){

v[],int n)

cout<<"Nome: "<< v[i].nome <<endl;


cout<<"Cognome: "<<v[i].cognome<<endl;
cout<<"Anni: "<< v[i].anni<<endl;
}
}
23) // ricerca della riga di somma
#include<iostream.h>
#include<stdlib.h>

massima in una matrice

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
{
int
int
int

main()
M[100][100],r,c, max,i,j;
vet[100];
pos_riga,sommamax;

leggimat(M,&r,&c);
stampamat(M,r,c);
riga_max(M,r,c,&pos_riga,&sommamax);
cout<<endl;
cout<<"La riga con somma max e': "<<pos_riga;
cout<<"il massimo e': "<<sommamax<<endl;
system("PAUSE");
}

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


{
int i,j;
cout<<"inserisci righe"<<endl;
cin>>*r;
cout<<"inserisci colonne"<<endl;
cin>>*c;
//lettura elementi della matrice
for(i=0;i<*r;i++)
for(j=0;j<*c;j++)
{
cout<<"mat["<<i<<"]["<<j<<"] ?"<<endl;
cin>>M[i]
[j];
}
}
void stampamat(int M[100][100],int r, int c)
{
int i,j;
//stampa elementi della matrice
for(i=0;i<r;i++)
{cout<<endl;
for(j=0;j<c;j++)
cout<<M[i]
[j]<<" ";
}
}
void riga_max(int M[100][100],int r, int c, int *pos_riga, int
*sommamax)
{
int vet[100],i,j;
for(i=0;i<r;i++)
{
//inizializ
zazione

del vettore delle somme


vet[i]=0;

for(j=0;j<c;j++)
{
vet[i]=vet[i]+M[i][j];
}
}

//Iniziliazzazione della variabile max e della posizione


*sommamax=vet[0];
*pos_riga=0;
//Ricerca massimo
for (i=1;
i<r; i++) {
if
(vet[i]>*sommamax) {
*sommamax=vet[i];
*pos_riga=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()
{
int Vect[100];
int dim;
int sp;
VectRead(Vect,&dim);
SommaPari(Vect,dim,&sp);
cout<<"La somma e':"<<sp;
cout<<endl;
cout<<"Il vettore inserito e':"<<endl;
VectWrite(Vect,dim);
system("PAUSE");
return 0;

}
void VectRead(int V[],int *dim) {
int i;
cout<<"Inserisci dimensione vettore ";
cin>>*dim;
for (i=0;i<*dim;i++) {
cout<<"Inserisci elemento["<<i<<"] ";
cin>>V[i];
}
}
void VectWrite(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {
cout<<"elemento["<<i<<"]= "<<V[i]<<endl;
}
}
void SommaPari(int V[],int dim, int *sommapari) {
int i;
*sommapari=0;
for(i=0;i<dim;i=i+2) {
*sommapari = *sommapari+V[i];
}
}
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()
{
int Vect[10];
int max;
VectRead(Vect,10);
//VectWrite(Vect,10);
max=Max(Vect,10);
cout<<"Il massimo e':"<<max<<endl;
system("PAUSE");
return 0;
}
void VectRead(int V[],int dim) {
int i;

for (i=0;i<dim;i++) {
cout<<"Inserisci elemento["<<i<<"] ";
cin>>V[i];
}
}
void VectWrite(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {
cout<<"elemento["<<i<<"]= "<<V[i]<<endl;
}
}
int Max(int V[],int dim) {
int max=V[0];
for(int i=1;i<dim;i++) {
if(V[i]>max) max=V[i];
}
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()
{
int Vect[10];
int pos;
VectRead(Vect,10);
//VectWrite(Vect,10);
pos=Search(Vect,10,3);
cout<<"La posizione e':"<<pos<<endl;
system("PAUSE");
return 0;
}
void VectRead(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {
cout<<"Inserisci elemento["<<i<<"] ";
cin>>V[i];
}
}
void VectWrite(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {

cout<<"elemento["<<i<<"]= "<<V[i]<<endl;
}
}
int Search(int V[],int dim,int Value) {
int i=0;
int pos;
bool found=false;
while(i<dim && !found) {
if(V[i]==Value) {
found=true;
}
i++;
}
if (i==dim) {
pos=-1;
} else {
pos=i-1;
}
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()
{
int Vect[10];
VectRead(Vect,10);
VectWrite(Vect,10);
system("PAUSE");
return 0;
}
void VectRead(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {
cout<<"Inserisci elemento["<<i<<"] ";
cin>>V[i];
}
}
void VectWrite(int V[],int dim) {
int i;
for (i=0;i<dim;i++) {
cout<<"elemento["<<i<<"]= "<<V[i]<<endl;
}
}

TESTI ESERCIZI

Esercizi per lesame 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
dellesercizio svolto.
1) Sviluppare tre sottoprogramma per: leggere, scrivere e ordinare un vettore. Sviluppare,
inoltre, un programma principale che utilizzi i tre sottoprogrammi.
2) 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 lordinamento. Per lo sviluppo del
programma si utilizzino ove possibile sottoprogrammi.
3) Assegnata una matrice si sviluppi un programma per eseguire la trasposta
4) Sviluppare un sottoprogramma per la risoluzione delle equazioni di secondo grado.
5) Assegnata una matrice si determini la riga che contiene il massimo numero di elementi con
valore pari a 0.
6) 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.
7) 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.
8) Assegnata una matrice quadrata si invertano gli elementi della diagonale principale e di
quella secondaria.
9) 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.
10) 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 loperazione 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=
8465
3215

B=
4568
1235

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

B=
4856
23 51

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=
8465
3215
4856
23 51

B=
3215
8465
23 51
4856

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:
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.

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 lordinamento.

ES:
1 6 2
-24 0
A = -4 3 0
B= 9 -1 4
9 1 3
1 4 7

C=

1 6 2 -2 4 0
-4 -1 0 3 4 9
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
S1 = ciao universo crudele

S2 = mondo

28) #include <iostream.h>


#include <stdlib.h>
#include "matrici.h"
int main(){
matrice mat,mat1,mat2,mat3;
int r,r1,c,c1;

S3 = universo

cout << "\nLettura e stampa di una matrice\n";


leggi(mat,r,c);
stampa(mat,r,c);
cout << "\nCalcolo della trasposta di una matrice\n";
leggi(mat,r);
stampa(mat,r,r);
trasposta(mat,r);
stampa(mat,r,r);
cout << "\nCalcolo del prodotto riga per colonna\n";
leggi(mat,r,c);
leggi(mat1,r1,c1);
rigacolonna(mat,mat1,mat2,r,c);
stampa(mat,r,c);
stampa(mat1,r1,c1);
stampa(mat2,r,c1);
system("PAUSE");
return 0;
}
const int MAX_DIM=10;
typedef int vettore[MAX_DIM];
typedef vettore matrice[MAX_DIM];
void
void
void
void
void

leggi(matrice,int &);
leggi(matrice,int &,int &);
stampa(const matrice,const int,const int);
trasposta(matrice,const int);
rigacolonna(matrice,matrice,matrice,const int,const int);

#include "matrici.h"
#include <iostream.h>
void leggi(matrice mat, int &riga, int &col){
cout << "Dammi il numero di righe: ";
cin >> riga;
cout << "Dammi il numero di colonne: ";
cin >> col;
for (int i=0;i<riga;i++)
for (int j=0;j<col;j++){
cout << "Inserisci l'elemento mat["<<i<<"]["<<j<<"]: ";
cin >> mat[i][j];
}
}
void leggi(matrice mat, int &riemp){
cout << "\nMatrice quadrata - dammi il riempimento: ";
cin >> riemp;
for (int i=0;i<riemp;i++)

for (int j=0;j<riemp;j++){


cout << "Inserisci l'elemento mat["<<i<<"]["<<j<<"]: ";
cin >> mat[i][j];
}
}
void scambia (matrice mat, const int i, const int j){
int temp=mat[i][j];
mat[i][j]=mat[j][i];
mat[j][i]=temp;
}
void trasposta(matrice mat, const int riemp){
cout << "Calcolo la matrice trasposta ...\n";
for (int i=0;i<riemp-1;i++)
for (int j=i+1;j<riemp;j++)
scambia(mat,i,j);
}
void stampa (const matrice mat,const int riga,const int col){
cout << "\nMATRICE ("<<riga<<"x"<<col<<")\n";
for (int i=0;i<riga;i++) {
for (int j=0;j<col;j++)
cout << mat[i][j] << ' ';
cout << '\n';
}
}
void rigacolonna(matrice mat1, matrice mat2, matrice mat3, const
int riga, const int col){
for (int i=0;i<riga;i++)
for (int j=0;j<riga;j++){
mat3[i][j]=0;
for (int k=0;k<col;k++)
mat3[i][j]+=mat1[i][k]*mat2[k][j];
}
}
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 () {
int n,i;
int fattoriale;

// Ciclo per controllare che il valore di n inserito


// dall'utente sia maggiore o uguale a zero
do {
cout << "Inserire il valore di n: ";
cin >> n;
}while (n < 0);
// Calcolo del fattoriale
i = 1;
fattoriale = 1;
while ( i <= n ) {
fattoriale = fattoriale * i;
i++;
}
// Stampa del risultato
cout << "\nIl fattoriale di " << n << " e': ";
cout << fattoriale<<"\n\n";
system("PAUSE");
return 0;
}
30) #include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
// Dichiarazioni
const int DIM=30;
int V1[DIM],V2[DIM];
int i,n;
// Input con controllo sui dati
do {
cout<<"Inserire il riempimento del primo vettore (MAX " << DIM
<< " elementi): ";
cin>>n;
} while (n>DIM);
// Lettura dei valori di V1
for (i=0;i<n;i++){
cout<<"Inserire il " << i+1 << "^ elemento del vettore: ";
cin>>V1[i];
}
// Copia di V1 in V2
for (i=0;i<n;i++){
V2[i]=V1[i];
}

// Stampa di V2
cout<<"\nEcco gli elementi di V2:\n";
for (i=0;i<n;i++)
cout<< V2[i] << ' ';
cout<<"\n\n";
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(){
int n,val,ind;
vett v;
bool trovato;
leggi(n,v);
trovato=cerca(n,v,val,ind);
stampa(trovato,val,ind);
system("PAUSE");
return 0;
}
//FUNZIONE DI LETTURA
void leggi (int &riemp,vett v) {
int i;
cout<<"Inserisci il numero di elementi che compongono il
vettore: ";
cin>>riemp;
for (i=0;i<riemp;i++){
cout<<"Inserisci il "<<i+1<<"^ valore: ";
cin>>v[i];
}
}
//FUNZIONE DI RICERCA
bool cerca (int riemp,const vett v,int &val,int &ind) {
int i=0;

bool trovato=false;
while (i<riemp && !trovato)
if (v[i]<0) {
trovato=true;
val=v[i];
ind=i;
}
else i++;
return trovato;
}
//FUNZIONE DI STAMPA
void stampa (bool trovato,int val,int ind) {
if (trovato==true) {
cout<<"\nIl valore del primo elemento negativo di V e':
"<<val;
cout<<"\nL'indice del primo elemento negativo di V e' :
"<<ind<<"\n\n";
}
else cout<<"\nNon esiste nessun elemento di V avente valore
negativo.\n\n";
}
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 lungh;
cout<<"Inserire la prima stringa (MAX "<<MAX_ELEM<<" caratteri):
";
cin>>s1;

lungh=strlen(s1);
cout<<"Inserire la seconda stringa ("<<lungh<<" caratteri): ";
cin>>s2;
}
int calcola(const stringa s1, const stringa s2){
int lungh,i,num=0;
lungh=strlen(s1);
for (i=0;i<lungh;i++)
if (s1[i]!=s2[i])
num++;
return num;
}
void stampa(int n, const stringa s1, const stringa s2){
cout<< "\nIl numero di caratteri diversi e': " <<n;
cout << "\nLe due stringhe sono:\n";
cout<< s1 <<'\n'<< s2 << "\n\n";
}
// main
int main() {
int num;
stringa s1,s2;
leggi(s1,s2);
num=calcola(s1,s2);
stampa(num,s1,s2);
system("PAUSE");
return 0;
}
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){
int i;
cout<<"Inserire riempimento del vettore (MAX "<<MAX_ELEM<<"
elementi): ";
cin>>n;
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
cin>>v[i];
}
}
void copia(int n1, const vett v1, int & n2, vett v2){
int i,j=0;
for (i=0;i<n1;i++)
if (v1[i]%2==0) {
v2[j]=v1[i];
j++;
}
n2=j;
}
void stampa(int n, const vett v){
int i;
cout << "\nGli elementi del vettore v2 sono: ";
for (i=0;i<n;i++)
cout<< v[i]<<' ';
cout << "\n\n";
}
// main
int main() {
int n1,n2;
vett v1,v2;
leggi(n1,v1);
copia(n1,v1,n2,v2);
stampa(n2,v2);
system("PAUSE");
return 0;
}

34) /*
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() {

stringa s;
char c1, c2;
int num;
leggi(s,c1,c2);
num=sostituisci(s,c1,c2);
stampa(s,num);
system("PAUSE");
return 0;
}
void leggi(stringa s, char &c1, char &c2){
cout<<"Inserisci una stringa (max "<<MAX<<" caratteri): ";
cin>>s;
cout<<"\nInserisci il carattere da sostituire: ";
cin>> c1;
cout<<"Inserisci il carattere che vuoi sostituire al precedente:
";
cin>>c2;
}
int sostituisci(stringa s, char c1, char c2){
int i,num=0;
int len=strlen(s);
for(i=0;i<len;i++)
if(s[i]==c1){
s[i]=c2;
num++;
}
return num;
}
void stampa(const stringa s, int num){
if (num==0)
cout<<"\nNon sono state effettuate sostituzioni.\n\n";
else {
cout<<"\nIl numero di sostituzioni effettuate e': "<<num;
cout<<"\nLa nuova stringa e': " <<s<<"\n\n";
}
}
35) #include <fstream.h>
#include <stdlib.h>
const int MAX=50;
typedef int lista[MAX];
int main()
{
int i,n;
lista l;

ifstream input;
ofstream output;
input.open("dati.txt");
if (input.fail())
exit(1);
i=0;
while (!input.eof()){
input >> l[i];
i++;
}
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) {
bool trovato=false;
int i = n-1;
while ( (i>=0) && !trovato )
if ( strcmp(str,lista[i])<0 ){ /* str < lista[i] */
strcpy(lista[i+1],lista[i]);
i--;
}
else /* str >= lista[i] */
trovato = true;
strcpy(lista[i+1],str);
n++;
}
37) // =================== Scambia
=================================
void scambia(int a[], const int i, const int j){
int temp = a[i];
a[i]=a[j];
a[j]=temp;

}
// =================== SelectSort
=================================
void SelectSort(int a[], const int n){
for (int i=0;i<n-1;i++){
int posmin=i;
for (int j=i+1;j<n;j++)
if (a[j] < a[posmin])
posmin = j;
if (posmin!=i)
scambia(a,i,posmin);
}
}
// =================== BubbleSort
=================================
void BubbleSort0 (int a[],const int n){
for(int i=1;i<n;i++)
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j])
scambia(a,j-1,j);
}
void BubbleSort (int a[], const int n){
bool bubble=true;
int i=1;
while(i<n && bubble) {
bubble = false;
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j]) {
scambia(a,j-1,j);
bubble = true;
}
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){
int i;
cout<<"Inserire riempimento del vettore (MAX "<<MAX_ELEM<<"
elementi): ";
cin>>n;
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
cin>>v[i];
}
cout<<"\nInserire l'elemento da cercare: ";
cin>>x;
}
bool ricerca(int n, const vett v, int x){
int i=0,j=n-1,k;
do {
k=(i+j)/2;
if (v[k]<x)
i=k+1;
else j=k-1;
}while (i<=j && v[k]!=x);
if (v[k]==x)
return true;
else return false;
}
void stampa(bool t, int x){
if (t)
cout << "\n\nL'elemento "<< x <<" appartiene all'insieme\n\n";
else cout << "\n\nL'elemento "<< x << " non appartiene
all'insieme\n\n";
}
// main
int main() {
int n,x;
vett v;
bool trovato;
leggi(n,v,x);
trovato=ricerca(n,v,x);

stampa(trovato,x);
system("PAUSE");
return 0;
}
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){
int i;
cout<<"Inserire riempimento del vettore (MAX "<<MAX_ELEM<<"
elementi): ";
cin>>n;
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
cin>>v[i];
}
}
bool ricerca(int n, const vett v){
int i=0;
bool trovato=false;
while (i<n && !trovato)
if (v[i]%2==0)
trovato = true;
else i++;
return trovato;
}
void stampa(int r, const vett a, bool t){
int i;
cout << "\nGli elementi inseriti sono: ";
for (i=0;i<r;i++)
cout<< a[i]<<' ';
if (t)
cout << "\n\nEsiste un elemento pari nel vettore\n\n";
else cout << "\n\nNon esiste un elemento pari nel vettore\n\n";

}
// main
int main() {
int n;
vett v;
bool trovato;
leggi(n,v);
trovato=ricerca(n,v);
stampa(n,v,trovato);
system("PAUSE");
return 0;
}
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(){
vett v;
int riemp;
int pari,dispari;
leggi(riemp,v);
ricerca_pd(riemp,v,pari,dispari);
stampa(pari,dispari);
system("PAUSE");
return 0;
}
//Definizioni funzioni
void leggi(int&n,vett v){
int i;
cout<<"Inserisci un riempimento per un vettore di "<<MAX<<"
elementi: ";
cin>>n;
for(i=0;i<n;i++){
cout<<"Inserisci elemento "<<i+1<<": ";
cin>>v[i];
}

}
void ricerca_pd(int n,const vett v,int& pari,int& dispari){
int i;
pari=dispari=0;
for (i=0;i<n;i++)
if (v[i]%2==0)
pari++;
else dispari++;
}
void stampa(int pari,int dispari){
cout<<"\nNel vettore ci sono "<<pari<<" elementi pari ";
cout<<"e "<<dispari<<" elementi dispari\n";
}
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){
cout<<"Inserisci una parola di massimo "<<MAX<<" caratteri: ";
cin>>s;
cout<<"\nOra inserisci un solo carattere: ";
cin>>c;
}
int conta(const stringa s, char c){
int i,lungh;
int cont=0;
lungh=strlen(s);
for (i=0;i<lungh;i++)
if(s[i]==c)
cont++;
return cont;
}
void stampa(int n_volte){
cout<<"\nIl carattere compare "<<n_volte<<" volte\n";
}
// main

int main(){
int n_volte;
stringa s;
char c;
leggi (s,c);
n_volte=conta(s,c);
stampa(n_volte);
system("PAUSE");
return 0;
}
42) *
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){
cout<<"Inserisci una parola (MAX "<<MAX<<" caratteri): ";
cin>>a;
cout<<"\nOra inserisci un'altra parola (MAX "<<MAX<<"
caratteri): ";
cin>>b;
}
void compara (stringa a,const stringa b,vett v,int &n){

int i,j,m;
n=strlen(a);
m=strlen(b);
for (i=0;i<n;i++)
v[i]=0;
for (i=0;i<n;i++)
for(j=0;j<m;j++)
if (a[i]==b[j])
v[i]++;
}
void stampa(const stringa a,const vett v,const int n){
int i;
cout<<"\nNella seconda parola, la lettera:\n\n";
for (i=0;i<n;i++)
cout<<a[i]<<" compare "<<v[i]<<" volte\n\n";
}
//Main
int main(){
stringa s1,s2;
int n;
vett v;
leggi(s1,s2);
compara(s1,s2,v,n);
stampa(s1,v,n);
cout<<"\n\n";
system("PAUSE");
return 0;
}
43) #include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
// Dichiarazioni
int n;
int i;
int somma;
cout<<"Inserire n: ";
cin>>n;
cout<<"\nPRIMO MODO DI RISOLVERE IL PROBLEMA";
cout<<"\nLa somma dei primi n numeri e': " << n*(n+1)/2;

// Calcolo in altro modo la sommatoria


i=1;
somma=0;
while (i<=n){
somma=somma+i;
i++;
}
cout<<"\n\nSECONDO MODO DI RISOLVERE IL PROBLEMA";
cout<<"\nLa somma dei primi n numeri e': " <<somma;
cout<<"\n\n";
system("PAUSE");
return 0;
}
44) #include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
// Dichiarazioni
int a,b,c;
// Input con controllo sui dati
do {
cout<<"Inserire i valori di a b e c: ";
cin>>a>>b>>c;
} 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() {
// Dichiarazioni
int a,b,c;
// Input
cin>>a>>b>>c;
// equivale a:

// cin >> a;
// cin >> b;
// cin >> c;
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;
}
46) // Prototipi
int
int
void
void
void

strlen(const char s[]);


strcmp(const char s[], const char t[]);
strcpy(char s[], const char t[]);
strrev(char s[]);
scambia(char s[],const int i,const int j);

// Funzioni
int strlen(const char s[]){
int i=0;
while (s[i]!='\0')
i++;
return i;
}
int strcmp(const char s[], const char t[]){
int i=0;
while (s[i]==t[i]){
if (s[i]=='\0')
return 0;
i++;
}
return s[i]-t[i];
}
void strcpy(char s[], const char t[]){
int i=0;
while (t[i]!='\0'){
s[i]=t[i];
i++;
}
s[i]='\0';
}

void strrev(char s[]){


int k=strlen(s);
for(int i=0;i<k/2;i++)
scambia(s,i,k-i-1);
}
void scambia(char s[], const int i, const int j){
char temp=s[i];
s[i]=s[j];
s[j]=temp;
}
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){
cout<<"\nDammi il numero in base 10 da convertire: ";
cin>>numero;
cout<<"Dammi la base: ";
cin>>base;
}
void converti(int numero,const int base, stringa str){
const char ch[]="0123456789ABCDEF";
int i=0;
while (numero>=base){
str[i] = ch[numero % base];
numero /= base;
i++;
}
str[i++]=ch[numero];
str[i]='\0';
strrev(str);
}
void stampa (const stringa str){
cout << "\nIl numero dopo la conversione di base e': " << str <<
"\n\n";
}
int main (){
int num,base;
stringa out;
leggi(num,base);
converti(num,base,out);

stampa(out);
system("PAUSE");
return 0;
}
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() {
stringa s1,s2,s3;
leggi(s1);
leggi(s2);
copia(s1,s2,s3);
stampa(s3);
system("PAUSE");
return 0;
}
// definizione delle funzioni
void leggi(stringa s){
cout<<"Inserire una stringa (MAX "<<MAX_ELEM<<" caratteri): ";
cin>>s;
}
void copia(const stringa s1, const stringa s2, stringa s3){
int lungh,i,j=0;

lungh=strlen(s1);
for (i=0;i<lungh;i++)
if (s1[i]==s2[i]){
s3[j]=s1[i];
j++;
}
s3[j]='\0';
}
void stampa(const stringa s){
if (strlen(s)!=0){
cout << "\nLa stringa composta da tutti i caratteri uguali in
posizione omologa delle due stringhe inserite e': ";
cout << s << "\n\n";
}
else cout << "\nNelle due stringhe inserite non esistono
caratteri in posizione omologa che siano uguali.\n\n";
}
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() {
int num;
char risp;
do{
stringa s1,s2; //stringhe inserite dall'utente
stringa s3; //stringa costituita dai caratteri uguali
system("cls"); //pulisce lo schermo
leggi(s1,s2);
num=calcola(s1,s2,s3);
stampa(num,s1,s2,s3);
do{
cout<<"\nVuoi continuare (s/n)?";
cin>>risp;
} 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){
int l1,l2;
do{
fflush(stdin); //pulisce lo "standard input" prima
dell'input delle stringhe
cout<<"Inserire la prima stringa (MIN 1, MAX "<<MAX_ELEM<<"
caratteri): ";
gets(s1);
l1=strlen(s1); //la funzione strlen fornisce la lunghezza
della stringa (ossia il numero di caratteri che costituiscono la
stringa escluso il terminatore)
if ((l1==0)||(l1>MAX_ELEM)){ //se viene inserita una
stringa vuota (ossia di lunghezza pari a zero) o una stringa pi
lunga del massimo consentito, l'input non considerato
valido ....
cout<<"\nInput non corretto, la lunghezza della stringa
deve essere compresa tra.\n"<<endl;
}else {
//...altrimenti, viene chiesto di inserire la
seconda stringa
cout<<"Inserire la seconda stringa ("<<l1<<" caratteri):
";
gets(s2);
l2=strlen(s2);
if(l1!=l2){
//verifica che le due stringhe inserite
abbiano la stessa lunghezza
cout<<"\nDevi inserire due stringhe che abbiano la
stessa lunghezza.\n"<<endl;

}
}
}while((l1!=l2)||(l1==0)||(l1>MAX_ELEM));
}
int calcola(const stringa s1, const stringa s2, stringa s3){
//s1 ed s2 sono parametri di input, s3 un parametro di output.
La funzione restituisce il risultato del conteggio come valore di
ritorno.
int lungh,i;
int num=0;
i=0;
while (s1[i]!='\0'){
if (s1[i]==s2[i]){ //se i caratteri di s1 ed s2 in posizione
omologa sono uguali
s3[num]=s1[i];
//il carattere viene inserito in coda alla
stringa s3. Non possiamo usare strcat, perch s1[i] un carattere
e questa funzione vuole due argomenti di tipo stringa (array di
caratteri)
num++;
}
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){
cout<< "\nIl numero di caratteri uguali e': " <<n;
cout << "\nLe due stringhe inserite dall'utente sono:\n";
cout<< s1 <<endl<< s2 <<endl;
if(strlen(s3)!=0){ //la stringa con i caratteri uguali viene
stampata solo se non vuota
cout << "\nLa stringa costituita dai soli caratteri uguali
delle due stringhe e':\n";
cout<< s3<<endl;
}
}
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()
{
char risp;
float num,quadrato;
do{
num=input();
quadrato=calcola_quadrato(num);
output(num,quadrato);
do{
cout<<"Vuoi continuare (s/n)? ";
cin>>risp;
}while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!
='N'));
}while ((risp=='s')||(risp=='S'));
system("pause");
return 0;
}
float input(){
float tempnum;
cout<<"Inserisci il numero da elevare al quadrato: ";
cin >>tempnum;
return tempnum;
cout<<"QUESTA LINEA NON VIENE MAI ESEGUITA";
}
float calcola_quadrato(float numero){
float tempnum;
tempnum=numero*numero;
return tempnum;
// in alternativa avrei potuto direttamente scrivere:
numero*numero;
}

return

void output(float numero,float quadrato){


cout<<"\nIl quadrato di "<<numero<<" e' "<<quadrato<<"\n\n";
}
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()
{
char risp;
float v[MAX_ELEM],q[MAX_ELEM];
int r;
do{
input(r,v);
calcola_quadrato(r,v,q);
output(r,v,q);
do{
cout<<"\nVuoi continuare (s/n)? ";
cin>>risp;
}while ((risp!='s')&&(risp!='S')&&(risp!='n')&&(risp!
='N'));
}while ((risp=='s')||(risp=='S'));
system("pause");
return 0;
}
void input(int &riemp, float v[]){
int i;
do{
cout<<"Inserisci il riempimento (max "<<MAX_ELEM-1<<")
: ";
cin>>riemp;
}while((riemp>MAX_ELEM-1)||(riemp<1));
for(i=0;i<riemp;i++){
cout<<"Inserisci l'elemento di posizione "<<i+1<<": ";
cin>>v[i];
}
}
void calcola_quadrato(int riemp,float v[],float q[]){
int i;
for(i=0;i<riemp;i++){
q[i]=v[i]*v[i];
}

}
void output(int riemp,float v[],float q[]){
int i;
cout<<"\n";
for(i=0;i<riemp;i++){
cout<<"Il quadrato di "<<v[i]<<" e' "<<q[i]<<"\n";
}
}
52) // INDOVINA IL NUMERO
// prima versione (semplificata)
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(){
int es;
considerato
int ed;
considerato
int pm;
char risposta;
int contatore;
es=0;
ed=128;
contatore=0;
contatore

//estremo sinistro dell'intervallo


//estremo destro dell'intervallo
//punto medio dell'intervallo considerato
//risposta fornita dall'utente
//contatore dei tentativi effettuati
//inizializzazione della variabile es
//inizializzazione della variabile ed
//inizializzazione della variabile

do {
contatore=contatore+1; //ad ogni iterazione il contatore dei
tentativi viene incrementato di una unit
pm=(es+ed)/2;
//calcolo del punto medio
cout<<"Il numero che hai pensato e' piu' alto (a), piu'
basso (b), o uguale (u) a "<<pm<<"?"<<endl; //messaggio inviato
allo standard output per chiedere all'utente di rispondere
cin>>risposta;
//il carattere digitato dall'utente
viene prelevato dallo standard input ed assegnato alla variabile
risposta.
if (risposta=='a'){
//se la risposta 'a' ...
es=pm;
//...allora l'estremo sinistro viene
fatto coincidere con il punto medio
}
if (risposta=='b'){
//se la risposta 'b' ...
ed=pm;
//...allora l'estremo destro viene
fatto coincidere con il punto medio
}

}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()
{
stringa lista[LEN];
int riemp=0;
int j;
stringa s;
for (j=0;j<ITERAZIONI;j++){
cout<<"inserisci la stringa numero "<<j+1<<": ";
gets(s);
inserisci_in_ordine_stringa (lista, riemp, s);
}
cout<<endl;
cout<<"LISTA ORDINATA:"<<endl;
for (j=0;j<ITERAZIONI;j++){
cout<<lista[j]<<endl;
}
system("pause");
}
void inserisci_in_ordine_stringa (stringa
stringa str) {
bool trovato = false;
int i = r-1;

lista[], int &r,

while ( (i>=0) && !trovato )


if ( strcmp(str,lista[i])>=0 )/* str>=lista[i] */
trovato = true;
else {/* str<lista[i] */
strcpy(lista[i+1],lista[i]);
i--;
}
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() {
int M[MAX_ELEM][MAX_ELEM];
int r1,r2;
int num;
char risp;
do{
system("cls"); //pulisce lo schermo
leggi(M,r1,r2);
num=calcola(M,r1,r2);
stampa(M,r1,r2,num);
do{
cout<<"\nVuoi continuare (s/n)?";

cin>>risp;
} 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){
int i,j;
do{
cout<<"Quante righe deve avere la matrice (MIN 1, MAX
"<<MAX_ELEM<<"): ";
cin>>r1;
}while((r1<1)||(r1>MAX_ELEM));
do{
cout<<"Quante colonne deve avere la matrice (MIN 1, MAX
"<<MAX_ELEM<<"): ";
cin>>r2;
}while((r2<1)||(r2>MAX_ELEM));
for(i=0;i<r1;i++){
cout<<"Inserisci gli elementi della riga num. "<<i+1<<"
separati da uno spazio:"<<endl;
for(j=0;j<r2;j++){
cin>>M[i][j];
}
}
}
int calcola(const int M[][MAX_ELEM],int r1, int r2){
int i,j;
int num=0;
for(i=0;i<r1;i++){
for(j=0;j<r2;j++){
if((M[i][j]%2)==0){
num++;
}
}
}
return num;
}
void stampa(const int M[][MAX_ELEM],int r1, int r2,int n){
int i,j;
cout<<endl<<endl;
cout<<"La matrice inserita e' la seguente."<<endl<<endl;
for(i=0;i<r1;i++){

for(j=0;j<r2;j++){
cout<<M[i][j]<<"\t";
}
cout<<endl;
}
cout<<endl;
cout<<"Ci sono "<<n<<" elementi pari."<<endl<<endl;
}
55) #include <iostream>
#include <stdlib.h>
using namespace std;
int main()
{
int n1;
int n2;
int n3;
int max;
cout<<"Inserisci il primo numero"<<endl;
cin>>n1;
cout<<"Inserisci il secondo numero"<<endl;
cin>>n2;
cout<<"Inserisci il terzo numero"<<endl;
cin>>n3;
max=n1;
if (n2>max){
max=n2;
}
if (n3>max){
max=n3;
}
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()
{
int V[100]; //array destinato a contenere gli elementi
int riemp; //riempimento dell'array
int i; //contatore

int numpari,numdispari; //contatori dei numeri pari e di quelli


dispari
int sommapari,sommadispari; //accumulatori delle somme dei
numeri pari e di quelli dispari
float mediapari,mediadispari; //variabili destinate a contenere
la media dei numeri pari e quella dei numeri dispari
//input:
do{
//inserimento del riempimento
cout<<"Quanti elementi vuoi inserire?(max 100) ";
cin>>riemp;
}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++){ //poich conosco il numero di iterazioni
da compiere, uso il for
cout<<"Inserisci il numero "<<i+1<<": ";
cin>>V[i];
}
numpari=0;
//inizializzazione dei contatori
numdispari=0;
sommapari=0;
//inizializzazione degli accumulatori
sommadispari=0;
//calcolo della media
for(i=0;i<riemp;i++){ //poich conosco il numero di iterazioni
da compiere, uso il for
if(V[i]%2==0){ //se il numero pari
sommapari+=V[i]; //aggiungo il valore dell'elemento
di indice i dell'array alla somma dei numeri pari
numpari++;
//incremento il contatore dei numeri
pari
}else{ //se il numero dispari
sommadispari+=V[i]; //aggiungo il valore
dell'elemento di indice i dell'array alla somma dei numeri dispari
numdispari++;
//incremento il contatore dei
numeri dispari
}
}
if (numpari>0){ //se sono presenti valori pari
mediapari=(float)sommapari/numpari;
//calcolo la media,
uso il casting per fare in modo che il risultato sia un float
}else{//altrimenti, se non sono presenti valori pari
mediapari=0; //pongo la media pari a zero
}
if (numdispari>0){ //se sono presenti valori dispari

mediadispari=(float)sommadispari/numdispari; //calcolo la
media, uso il casting per fare in modo che il risultato sia un
float
}else{ //altrimenti, se non sono presenti valori dispari
mediadispari=0; //pongo la media pari a zero
}
//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){
int i;
cout<<"Inserire il riempimento del vettore ordinato(MAX
"<<MAX_ELEM<<" elementi): ";
cin>>n;
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
cin>>v[i];
}
cout<<"\nInserire l'elemento da cercare: ";
cin>>x;
}
bool ricerca(int n, const vett v, int x){
int i=0,j=n-1,k;
do {
k=(i+j)/2;

if (v[k]<x)
i=k+1;
else j=k-1;
}while (i<=j && v[k]!=x);
if (v[k]==x)
return true;
else return false;
}
void stampa(bool t, int x){
if (t)
cout << "\n\nL'elemento "<< x <<" appartiene all'insieme\n\n";
else cout << "\n\nL'elemento "<< x << " non appartiene
all'insieme\n\n";
}
// main
int main() {
int n,x;
vett v;
bool trovato;
leggi(n,v,x);
trovato=ricerca(n,v,x);
stampa(trovato,x);
system("PAUSE");
return 0;
}
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;
const int LUNG_STR=150;

//Massima lunghezza degli array


//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() {
int V1[MAX_ELEM],V2[MAX_ELEM];
//V1: array principale usato;
V2:array usato come destinazione dalle funzioni che effettuano la
copia dei valori di alcuni elementi di V1
int r1,r2;
//r1: riempimento di V1; r2:
riempimento di V2

char risp;
//carattere inserito
dall'utente per selezionare una delle opzioni del menu
int ind,val;
input_array(r1, V1);
do{
system("CLS");
//pulisce lo schermo
output_array(r1,V1,"N.1");
//stampa sul video l'array V1
cout<<endl<<endl;
//stampa di due righe vuote
per distanziare le informazioni stampate da "output_array" dal
menu sottostante
cout<<"Seleziona l'operazione da effettuare:\n\n"; //menu.
N.B. Per portare il cursore alla riga successiva, oltre ad "endl"
si pu usare "\n". Quest'ultimo va inserito direttamente nella
stringa
cout<<"a) Inserisci un nuovo elemento\n";
cout<<"b) Elimina un elemento fornendone il valore\n";
cout<<"c) Elimina un elemento fornendone l'indice\n";
cout<<"d) Elimina tutti gli elementi maggiori di un dato
valore\n";
cout<<"e) Elimina tutti gli elementi minori di un dato
valore\n";
cout<<"f) Inserisci nuovamente tutti i valori dell'array\n";
cout<<"g) Ricerca lineare\n";
cout<<"h) Ricerca binaria\n";
cout<<"i) Calcola il massimo\n";
cout<<"l) Calcola il minimo\n";
cout<<"m) Ordina (select sort)\n";
cout<<"n) Ordina (bubble sort - tipo 1)\n";
cout<<"o) Ordina (bubble sort - tipo 2)\n";
cout<<"p) Copia in un secondo array gli elementi maggiori di
un dato valore\n";
cout<<"q) Copia in un secondo array gli elementi minori di
un dato valore\n";
cout<<"x) Esci\n";
cin>>risp;
//L'opzione selezionata dall'utente viene
memorizzata nella variabile "risp"
switch (risp) { //A seconda del valore della variabile
"risp", viene selezionato il gruppo di istruzioni appropriato
//Inserimento nuovo elemento:
case ('a') : //qualora l'utente dovesse selezionare 'a',
non essendoci un "break" in corrispondenza di questa opzione,
//verrebbero eseguite tutte le istruzioni
successive fino al primo "break. In pratica verrebbero eseguite
//le istruzioni associate ad 'A'. In questo
modo possibile associare lo stesso gruppo di istruzioni sia
//ad 'a' che ad 'A'
case 'A' :

val=input_intero("Digita il valore da inserire:


"); //input del valore da inserire
do{
ind=input_intero("Quale indice dovra' avere?");
if ((ind>=r1)||(ind<0)) cout<<"L'indice inserito
non e' valido.\n"; //notare che sulla stessa linea sono stati
inseriti l'if ed il blocco then. Poich il blocco then
costituito da una sola istruzione, non stato necessario
racchiuderlo tra parentesi graffe
}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)){
//mediante
una ricerca lineare si individua l'indice "ind" dell'elemento da
eliminare
elim_elem(r1, V1, ind);
//eliminazione
dell'elemento di indice "ind"
cout<<"E' stato eliminato il primo elemento il
cui valore e' risultato uguale a "<<val<<".\n";
}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' :
do{
ind=input_intero("Inserisci l'indice dell'elemento
da eliminare: ");
if ((ind>=r1)||(ind<0)) cout<<"L'indice inserito
non e' valido.\n";

}while((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)){
cout<<"Sono stati eliminati gli elementi il cui
valore e' maggiore di "<<val<<".\n";
}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)){
cout<<"Sono stati eliminati gli elementi il cui
valore e' minore di "<<val<<".\n";
}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 trovato\n";
else
cout<<"Il valore non e' stato trovato\n";
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){
//Inserimento di un elemento in un array
int i;
for(i=r;i>indice;i--){
//spostamento verso il basso di
tutti gli elementi che dovranno trovarsi sotto il nuovo elemento
inserito
v[i]=v[i-1];
}
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){
elemento in un array
int i;

//Inserimento di un

for(i=indice;i<r;i++){
//spostamento verso l'alto di tutti
gli elementi si trovano sotto l'elemento da eliminare.
v[i]=v[i+1];
}
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){ //Eliminazione
dall'array di tutti gli elementi maggiori di "valore"
//l'algoritmo usato consente, SCORRENDO UNA SOLA VOLTA
L'ARRAY, di eliminare tutti gli elementi maggiori di "valore"
int i,k;
//k il contatore degli elementi eliminati
bool eliminato; //variabile che assume il valore true se
stato eliminato almeno un elemento
k=0;
eliminato=false;
for(i=0;i<r;i++){
if(v[i]>valore){
//se l'elemento considerato
maggiore di "valore", deve essere eliminato

k++;
//viene incrementato il contatore
degli eliminati
eliminato=true; //viene posto a true il flag che
indica che almeno un elemento stato eliminato
}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){ //Eliminazione
dall'array di tutti gli elementi maggiori di "valore"
//l'algoritmo usato identico a quello utilizzato da
"elim_elem_magg", l'unica differenza sta nella condizione usata
per identificare gli elementi da eliminare
int i,k;
bool eliminato;
k=0;
eliminato=false;
for(i=0;i<r;i++){
if(v[i]<valore){
k++;
eliminato=true;
}else
v[i-k]=v[i];
}
r-=k;
return eliminato;
}
int input_intero(const stringa stringa_messaggio){
l'inserimento di un intero
int valore_inserito;

//funzione per

cout<<stringa_messaggio; //il messaggio da mostrare stato


passato come parametro
cin>>valore_inserito;
return valore_inserito;
}
void input_array(int &n, int v[]){ //Input dell'array
int i;

do{
cout<<"Inserire riempimento del vettore (MAX "<<MAX_ELEM<<"
elementi): ";
cin>>n;
if (n<0) cout<<"Non e' possibile indicare un riempimento
negativo.\n";
if (n>MAX_ELEM) cout<<"Non e' possibile indicare un
riempimento maggiore di "<<MAX_ELEM<<".\n";
}while((n<0)||(n>MAX_ELEM));
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
cin>>v[i];
}
}
void output_array(int n, const int v[], const stringa nome_array){
//Output dell'array
int i;
cout<<"ARRAY "<<nome_array<<":\t";
for (i=0;i<n;i++){
cout<<v[i]<<"\t";
}
cout<<endl;
}
int max(int n, const int v[]){ //Ricerca del valore massimo
int i;
int m=v[0]; //Massimo parziale. Inizialmente si pone il
massimo parziale pari al valore dell'elemento di indice zero,
//per questo motivo l'algoritmo prevede che
l'array non possa essere vuoto.
for (i=1;i<n;i++){
if (v[i]>m) m=v[i];
}
return m;
}
int min(int n, const int v[]){
int i;
int m=v[0];

//Ricerca del valore minimo

for (i=1;i<n;i++){
if (v[i]<m) m=v[i];
}
return m;
}
void scambia(int a[], int i, int j){
di due elementi di un array
int temp = a[i];

//Scambio (swap) dei valori

a[i]=a[j];
a[j]=temp;
}
void SelectSort(int a[], int n){ //Ordinamento in senso crescente
degli elementi di un array mediante l'algoritmo del select sort
//Il vettore viene diviso in due parti: una ordinata,
inizialmente vuota,
//ed una disordinata. Ad ogni passo del ciclo, il minimo della
parte ancora
//disordinata del vettore viene selezionato e scambiato con
l'elemento
//nella prima posizione, che viene incluso nella parte ordinata.
for (int i=0;i<n-1;i++){
int posmin=i;
for (int j=i+1;j<n;j++)
if (a[j] < a[posmin])
posmin = j;
if (posmin!=i)
scambia(a,i,posmin);
}
}
void BubbleSort1 (int a[], int n){ //Ordinamento in senso
crescente degli elementi di un array mediante l'algoritmo del
bubble sort (prima versione)
//Il vettore viene diviso in due parti: una ordinata,
inizialmente vuota,
//ed una disordinata. Ad ogni passo del ciclo, il minimo della
parte ancora
//disordinata del vettore viene fatto gorgogliare verso l'alto
per mezzo
//di scambi successivi di coppie di elementi consecutivi. Giunto
nella prima
//posizione, viene incluso nella parte ordinata ed il processo
viene iterato.
for(int i=1;i<n;i++)
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j])
scambia(a,j-1,j);
}
void BubbleSort2 (int a[], int n){ //Ordinamento in senso
crescente degli elementi di un array mediante l'algoritmo del
bubble sort (seconda versione)
//Questa versione utilizza lo stesso principio della precedente,
ma, usando

//un ciclo while ed un ciclo for, invece di due for, risulta pi


efficiente
bool bubble=true;
int i=1;
while(i<n && bubble) {
bubble = false;
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j]) {
scambia(a,j-1,j);
bubble = true;
}
i++;
}
}
bool ricerca_lineare1(int n, const int v[], int x){ //Ricerca di
un valore in un array di interi mediante l'algoritmo della ricerca
lineare (prima versione)
bool trovato=false;
int i=0;
while((i<n)&&(!trovato)){
if(v[i]==x){
trovato=true;
}else{
i++;
}
}
return trovato;
}
bool ricerca_lineare2(int n, const int v[], int x, int &indice)
{ //Ricerca di un valore in un array di interi mediante
l'algoritmo della ricerca lineare (seconda versione)
bool trovato=false;
indice=0;
while((indice<n)&&(!trovato)){
if(v[indice]==x){
//
Le parentesi graffe non sono
necessarie perch il blocco costituito da UNA SOLA ISTRUZIONE...
trovato=true;
//... Si pu decidere di usarle o di
ometterle a seconda delle proprie preferenze. ...
}else{
//... Qualora si il blocco fosse
stato costituito da pi istruzioni, le parentesi graffe ...
indice++;
//... sarebbero state
obbligatorie. ...
}
}
return trovato;

}
bool ricerca_binaria(int n, const int v[], int x){ //Ricerca di un
valore in un array di interi mediante l'algoritmo della ricerca
binaria
bool trovato;
int i=0,j=n-1,k;
do {
k=(i+j)/2;
if (v[k]<x)
i=k+1;
//si noti che non sono state usate parentesi
graffe per identificare l'inizio e la fine del blocco perch il
blocco then costituito da una sola riga
else j=k-1;
}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){ //Copia in un secondo array, inizialmente vuoto, di tutti gli
elementi di un array il cui valore maggiore di un intero
indicato dall'utente
int i;
r2=0;
for(i=0;i<r1;i++)
if(v1[i]>x) v2[r2++]=v1[i];
}
void copia_minori (const int v1[],int v2[], int r1, int &r2, int
x){ //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 i;
r2=0;
for(i=0;i<r1;i++)
if(v1[i]<x) v2[r2++]=v1[i];
}
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() {
char risp;
stringa str1,str2,str3;
stringa lista[MAX_ELEM];
int r=0;
int indice;
bool trovato;
int risultato_confronto;
input_stringa(str1, "N.1");
do{
system("CLS");
output_stringa(str1,"N.1");
cout<<endl<<endl;
cout<<"Seleziona l'operazione da effettuare:\n"<<endl;

cout<<"a)
cout<<"b)
cout<<"c)
cout<<"d)
cout<<"e)
cout<<"f)
cout<<"g)
cout<<"h)
cout<<"i)
cout<<"l)
cout<<"m)
cout<<"n)
cout<<"o)
cout<<"x)

Calcola lunghezza (usando la funzione strlen)\n";


Calcola lunghezza (contando i caratteri)\n";
Confronta stringhe (usando strcmp)\n";
Confronta stringhe (senza usare strcmp)\n";
Copia stringa (usando strcpy)\n";
Copia stringa (senza usare strcpy)\n";
Concatena stringhe (usando strcat)\n";
Concatena stringhe (senza usare strcat)\n";
Inserisci nuovamente\n";
Inserisci lista stringhe\n";
Stampa lista stringhe\n";
Cerca stringa in lista\n";
Inserisci in ordine stringhe\n";
Esci\n";

cin>>risp;
fflush(stdin); //pulisce lo "standard input" prima
dell'input delle stringhe
switch (risp) {
case ('a') : //lunghezza con strlen
case 'A' :
cout<<"La stringa e' lunga "<<strlen(str1)<<"
caratteri\n";
system("PAUSE");
break;
case 'b' :
//lunghezza contando i caratteri
case 'B' :
cout<<"La stringa e' lunga "<<lung_stringa(str1)<<"
caratteri\n";
system("PAUSE");
break;
case 'c' :
//confronto con strcmp
case 'C' :
input_stringa(str2, "N.2");
risultato_confronto=strcmp(str1,str2);
if(risultato_confronto>0)
cout<<"La stringa N.1 e' maggiore della
stringa N.2.\n";
else if (risultato_confronto<0)
cout<<"La stringa N.1 e' minore della
stringa N.2.\n";
else
cout<<"Le stringhe sono uguali.\n";
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'd' :
case 'D' :

//confronto senza strcmp

input_stringa(str2, "N.2");
risultato_confronto=confronta_stringhe(str1,str2);
if(risultato_confronto>0)
cout<<"La stringa N.1 e' maggiore della
stringa N.2.\n";
else if (risultato_confronto<0)
cout<<"La stringa N.1 e' minore della
stringa N.2.\n";
else
cout<<"Le stringhe sono uguali.\n";
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'e' : //copia stringa con strcpy
case 'E' :
input_stringa(str2, "N.2");
strcpy(str1,str2);
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'f' : //copia stringa senza strcpy
case 'F' :
input_stringa(str2, "N.2");
copia_stringa(str1,str2);
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'g' : //concatenazione di stringhe con strcat
case 'G' :
input_stringa(str2, "N.2");
strcat(str1,str2);
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'h' : //concatenazione stringhe senza strcat
case 'H' :
input_stringa(str2, "N.2");
concatena_stringhe(str1,str2);
output_stringa(str1,"N.1");
output_stringa(str2,"N.2");
system("PAUSE");
break;
case 'i' :

//input di una stringa

case 'I' :
input_stringa(str1, "N.1");
output_stringa(str1,"N.1");
system("PAUSE");
break;
case 'l' : //input di un array di stringhe
case 'L' :
leggi_lista_stringhe (lista, r);
stampa_lista_stringhe(lista, r);
system("PAUSE");
break;
case 'm' : //output di un array di stringhe
case 'M' :
if (r>0)
stampa_lista_stringhe(lista, r);
else
cout<<"L'array di stringhe e' vuoto.\n";
system("PAUSE");
break;
case 'n' : //ricerca di una stringa in un array di
stringhe
case 'N' :
if (r>0){
input_stringa(str2, " da cercare");
cerca_lista_stringhe (lista, r, str2, trovato,
indice);
if (trovato){
cout<<"STRINGA TROVATA.
INDICE:"<<indice<<endl;
}else{
cout<<"STRINGA NON TROVATA\n";
}
}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' :
case 'X' :
break;
default :

//uscita

cout<<"Selezione non valida.\n";


system("PAUSE");
break;
}
} while ((risp!='x')&&(risp!='X'));
return 0;
}
void input_stringa(stringa s, const stringa nome_stringa){
cout<<"Inserisci la stringa "<<nome_stringa<<": ";
gets(s);
}
int lung_stringa(const stringa s){
int i=0;
while (s[i]!='\0')
i++;
return i;
}
void output_stringa(const stringa s, const stringa nome_stringa){
cout<<"STRINGA "<<nome_stringa<<":\t"<<s<<endl;
}
int confronta_stringhe(const stringa s, const stringa t){
int i=0;
while (s[i]==t[i]){
if (s[i]=='\0')
return 0;
i++;
}
return s[i]-t[i];
}
void copia_stringa(stringa s, const stringa t){
int i=0;
while (t[i]!='\0'){
s[i]=t[i];
i++;
}
s[i]='\0';
}
void concatena_stringhe(stringa s, const stringa t){
int i=0,j=0;
while (s[i]!='\0'){
i++;
}
while (t[j]!='\0'){
s[i]=t[j];

i++;
j++;
}
s[i]='\0';
}
void leggi_lista_stringhe (stringa lista[], int &n ) {
int i;
do{
cout<<"Inserire riempimento del vettore di stringhe(MAX
"<<MAX_ELEM<<" elementi): ";
cin>>n;
fflush(stdin);
if (n<0) cout<<"Non e' possibile indicare un riempimento
negativo.\n";
if (n>MAX_ELEM) cout<<"Non e' possibile indicare un
riempimento maggiore di "<<MAX_ELEM<<".\n";
}while((n<0)||(n>MAX_ELEM));
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
gets(lista[i]);
}
}
void stampa_lista_stringhe (const stringa lista[], int n ) {
int i;
cout<<"LISTA DI STRINGHE: \n";
for (i=0; i<n; i++ )
cout << lista[i]<<endl;
}
void cerca_lista_stringhe (const stringa lista[], int n, const
stringa str, bool &trovato, int &i ) {
trovato = false;
i = 0;
while ( (i<n) && !trovato )
if ( strcmp(str,lista[i])==0 )/* str==lista[i] */
trovato = true;
else /* str!=lista[i] */
i++;
}
void inserisci_in_ordine_stringa (stringa lista[],int &n,const
stringa str) {
int trovato = false;
int i = n-1;
while ( (i>=0) && !trovato )
if ( strcmp(str,lista[i])>=0 )/* str>=lista[i] */
trovato = true;
else{ /* str<lista[i] */

strcpy(lista[i+1],lista[i]);
i--;
}
strcpy(lista[i+1],str);
n++;
}
void leggi_e_ordina_lista_stringhe (stringa lista[], int &n){
int i;
stringa s;
int n1=0;
do{
cout<<"Inserire riempimento del vettore di stringhe(MAX
"<<MAX_ELEM<<" elementi): ";
cin>>n;
fflush(stdin);
if (n<0) cout<<"Non e' possibile indicare un riempimento
negativo.\n";
if (n>MAX_ELEM) cout<<"Non e' possibile indicare un
riempimento maggiore di "<<MAX_ELEM<<".\n";
}while((n<0)||(n>MAX_ELEM));
for (i=0;i<n;i++){
cout<<"Inserire l'elemento di posto "<<i+1<<": ";
gets(s);
inserisci_in_ordine_stringa (lista,n1,s);
}
}
60) // =================== Scambia
=================================
void scambia(int a[], const int i, const int j){
int temp = a[i];
a[i]=a[j];
a[j]=temp;
}
// =================== SelectSort
=================================
void SelectSort(int a[], const int n){
for (int i=0;i<n-1;i++){
int posmin=i;
for (int j=i+1;j<n;j++)
if (a[j] < a[posmin])
posmin = j;
if (posmin!=i)
scambia(a,i,posmin);

}
}
// =================== BubbleSort
=================================
void BubbleSort0 (int a[],const int n){
for(int i=1;i<n;i++)
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j])
scambia(a,j-1,j);
}
void BubbleSort (int a[], const int n){
bool bubble=true;
int i=1;
while(i<n && bubble) {
bubble = false;
for (int j=n-1;j>=i;j--)
if (a[j-1] > a[j]) {
scambia(a,j-1,j);
bubble = true;
}
i++;
}
}
61) /*
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
#include
#include
#include

<iostream>
<stdlib.h>
<stdio.h>
<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() {
stringa s;
char c1, c2;
int num;
leggi(s,c1,c2);
num=sostituisci(s,c1,c2);
stampa(s,num);
system("PAUSE");
return 0;
}
void leggi(stringa s, char &c1, char &c2){
cout<<"Inserisci una stringa (max "<<MAX<<" caratteri): ";
gets(s);
cout<<"\nInserisci il carattere da sostituire: ";
cin>> c1;
cout<<"Inserisci il carattere che vuoi sostituire al precedente:
";
cin>> c2;
}

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


int i,num=0;
int len=strlen(s);
for(i=0;i<len;i++)
if(s[i]==c1){
s[i]=c2;
num++;
}
return num;
}
void stampa(const stringa s, int num){
if (num==0)
cout<<"\nNon sono state effettuate sostituzioni.\n\n";
else {
cout<<"\nIl numero di sostituzioni effettuate e': "<<num;
cout<<"\nLa nuova stringa e': " <<s<<"\n\n";
}
}
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()
{
int V[100];
int riemp;
int i;
bool trovato;
stato trovato

//array destinato a contenere gli elementi


//riempimento dell'array
//contatore del ciclo
//variabile che uso per indicare se l'elemento

//input:
do{
//inserimento del riempimento
cout<<"Quanti elementi vuoi inserire?(max 100) ";
cin>>riemp;
}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++){
//poich conosco il numero di
iterazioni da compiere, uso il for
cout<<"Inserisci il valore dell'elemento numero "<<i+1<<":
";
cin>>V[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)){
if(V[i]>10){
//se l'elemento maggiore di
10....
trovato=true;
//... pongo trovato uguale a true
}else{
//altrimenti...
i++;
//...incremento il contatore del
ciclo
}
}
//stampa dei risultati
cout<<endl;
//stampo una riga vuota per distanziare l'output dall'input
if (trovato){
//se stato trovato un elemento maggiore di 10 ...
cout<<"L'indice del primo elemento maggiore di 10 e' :
"<<i<<endl; //...stampo i risultati
cout<<"Il suo valore e': "<<V[i]<<endl;
}else{
//altrimenti ...
cout<<"Non esiste alcun elemento maggiore di 10"<<endl;
//...stampo un messaggio che segnala che l'elemento non stato
trovato
}
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()
{

int mat[Max][Max];
int riem;
caricamat(mat,riem);
system("pause");
stampamat(mat,riem);
cout<<"\n";
system ("PAUSE");
cout<<"La Somma della diagonale maggiore e':
"<<somma_DM_mat(mat,riem);
cout<<"\n";
system("Pause");
cout<<"La Somma della diagonale minore e':
"<<somma_Dm_mat(mat,riem);
cout<<"\n";
system("Pause");
return 0;
}
void caricamat(int a[Max][Max], int &n)
{
int j,i;
cout<<"Inserisci la lunghezza delle righe ecolonne della
tua matrice quadrata\n(Max 10): ";
cin>>n;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cout<<"Inserisci l'elemento di posto
("<<i<<","<<j<<"): ";
cin>>a[i][j];
}
}
}
void stampamat(int const a[Max][Max], const int n)
{
int j,i;
for(i=0;i<n;i++)
{
cout<<"\n";
for(j=0;j<n;j++)
{
cout<<a[i][j]<<"\t";

}
}
}
int somma_DM_mat(int const a[Max][Max], int n)
{
int somma=0;
int i;
for(i=0;i<n;i++)
{
somma=somma+a[i][i];
}
return somma;
}
int somma_Dm_mat(int const a[Max][Max], int n)
{
int somma=0;
int i,j;
for(i=0;i<n;i++)
{
j=n-1-i;
somma=somma+a[i][j];
}
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()
{
int elem, i, v[MAX], n, Vsup[MAX], N;
double media;
leggivett(v, n);
stampavett(v, n);
media= med(v, n);
cout<<"\n ecco la media degli elementi: "<<media<<"\n\n";
nuovovett(media,v,n,Vsup,N);
stampavett(Vsup,N);

system ("pause");
return 0;
}
void leggivett(int v[], int &riemp)
{
int i;
cout<<"\n inserisci il numero di elementi del tuo vettore
(massimo"<<MAX<<"): ";
cin>>riemp;
for(i=0; i<riemp; i++) {
cout<<"\n inserisci l'elemento nella posizione "<<i<<"
del tuo vettore: ";
cin>>v[i];
}
}
void stampavett(int const v[], int const riemp)
{
int i;
cout<<"\n ecco il tuo vettore:\n";
for(i=0; i<riemp; i++)
cout<<"\t"<<v[i];
cout<<"\n";
}
double med(int const v[], int const riemp)
{
int i;
double s,m;
s=0;
for(i=0; i<riemp; i++)
s=s+v[i];
m=s/riemp;
return m;
}
void nuovovett(double const m, int const v[], int const riemp, int
Vs[], int &Rs)
{
int i;
Rs=0;
for (i=0; i<riemp; i++)
if(v[i]>=m)

{ Vs[Rs]=v[i];
Rs=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()
{
// Dichiarazione delle variabili
double altezza,base,area;
// Richiedi valori
cout << "Inserisci il valore dell'altezza: " << endl;
cin >> altezza;
cout << "Inserisci il valore della base: " << endl;
cin >> base;
// Calcola l'area
area = calcolaArea(altezza,base);
// Stampa il risultato
cout << "L'area del triangolo di base: " << base << " e
altezza " << altezza << " e\' : " << area << endl;
system("PAUSE");
return 0;
}
double calcolaArea(double altezza,double base)
{
double area = (altezza*base)/2;
return area;
}
ESERCIZI VARI
TUTTI ESERCIZI C++
*/Termina la lista se si inserisce un numero negativo
#include <iostream>
#include <stdlib.h>
using namespace std;
int main()
{
int x;

int primo=0;
do{
cout<<"Inserisci il numero : ";
cin>>x;
if (x<=0)
cout<<"\n Inserire un numero maggiore o uguale a
1"<<endl;
else{
if (x==1)
cout<<"\n Il numero 1 e' sicuramente primo"<<endl;
else{
for(int i=2;i<x-1;i++){
if(x%i==0){
primo=1;
break;
}
}
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()
{
int n;
char car;
cout<<"Inserire l'altezza del triangolo : ";
cin>>n;
cout<<"inserire il carattere : ";
cin>>car;
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++){
cout<<car;
}
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[])
{
int n,m,car;
char V[DIM];
cout<<"Inserisci la lunghezza delvettore";
cin>>n;
leggi_vetint(V,n);
cout<<"\n Inserisci il carattere da eliminare";cin>>car;
elimina_dispari(V,n);
stampa_vetint(V,n);
system("PAUSE");
return 0;
}
void leggi_vetint(char V[DIM],int &n){
for(int i=0;i<n;i++){
cout<<"V["<<i<<"]";
cin>>V[i];
}
}
int elimina_dispari(char V[DIM], int &n){
int conta=0;
for(int i=0;i<n;i++){
if(V[i]==car){
for(int j=i;j<n-1;j++){
V[j]=V[j+1];
}
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){
cout<<"Stampa del vettore modificato";
for(int i=0;i<n;i++)
cout<<V[i];
}

*/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[])
{
Matrice_int M;
int vet [R];
int numR, numC;
inserisci_matrice(M, numR, numC);
cout << "\n la matrice di interi inserita:\n";
stampa_matrice(M, numR, numC);
crea_vet(M, vet,numR, numC);
cout << "\n il vettore dei minimi:\n";
stampa_vet(vet, numR);
cout << "\n";
system("PAUSE");
return EXIT_SUCCESS;
}
void inserisci_matrice(Matrice_int M,int& numR,int & numC){
cout<<"\n Inserisci il numero di righe";
cin>>numR;
cout<<"\n Inserisci il numero di colonne";
cin>>numC;
for(int i=0;i<numR;i++){
cout<<" ";
for(int j=0;j<numC;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
}
void stampa_matrice(Matrice_int M,const int numR,const int numC){
for(int i=0;i<numR;i++){
cout<<" ";
for(int j=0;j<numC;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cout<<M[i][j];
}
}

}
void crea_vet(Matrice_int M,int vet[R],const int numR,const int
numC){
for(int i=0;i<numR;i++){
vet[i]=cerca_min(M,numR,numC,i);
}
}
int cerca_min(Matrice_int M,const int numR,const int numC,int i){
int min;
min=M[i][0];
for(int j=0;j<numC;j++){
if(M[i][j]<min){
min=M[i][j];
}
}
return min;
}
void stampa_vet(int vet[R],const int numR){
for(int i=0;i<numR;i++){
cout<<"\n V["<<i<<"]
";
cout<<vet[i];
}
}
*/vede se un numero 0 oppure no
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int c=0;
int num;
cout<<"\n Inserisci il numero da confrontare";
cin>>num;
if(num==c)
cout<<"\n Il numero inserito e' proprio uguale a zero";
else
cout<<"\n Il numero inserito e' diverso da zero";
system("PAUSE");
return 0;
}
*/convertitore euro-lire
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
float euro,lire;
float c=1.93627;

cout<<"\n Inserisci la lira da convertire in euro";


cin>>lire;
euro=lire/c;
cout<<"Il valore convertito in euro e' :"<<euro;
cout<<"Inserisci l'euro da convertire in lire";
cin>>euro;
lire=euro*c;
cout<<"Il valore convertito in lire e' :"<<lire;
system("PAUSE");
return 0;
}
*/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[])
{
int n;
vettore A;
vettore B;
cout<<"\n Riempimento del vettore";
leggi(A,n);
cout<<"\n ";
copia(A,B,n);
stampa(B,n);
system("PAUSE");
return 0;
}
void leggi(vettore V1,int & dimensione){
cout<<"\n Inserisci la dimensione del vettore";
cin>>dimensione;
for(int i=0;i<dimensione;i++){
cout<<"\n V["<<i<<"]";
cin>>V1[i];
}
}
void copia(vettore V1,vettore V2,int & dimensione){
for(int i=0;i<dimensione;i++){
V2[i]=V1[i];
}
}
void stampa(vettore V2,int dimensione){
for(int i=0;i<dimensione;i++){
cout<<V2[i];
}

}
*/potenza
#include <iostream.h>
main()
{
int potenza=1;
int n,m;0.
cout << "Inserisci la base";
cin>>n;
cout<<"metti la p";
cin>>m;
for(int i=1;i<=m;i++)
potenza=potenza*n;
cout<<potenza;
system("PAUSE");
return 0;
}
*/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[])
{
int riga,colonna;
cout<<"\n Inserisci il numero max di righe";
cin>>riga;
cout<<"\n Inserisci il numero max di colonne";
cin>>colonna;
for(int i=0;i<riga;i++){
cout<<" "<<endl;
for(int j=0;j<colonna;j++){
cout<<"M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
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[])
{
int n,ris;
vettore V;
cout<<"\n Inserimento del vettore";
cout<<"\n Inserisci la lunghezza del vettore";
cin>>n;
for(int i=0;i<n;i++){
cout<<"\n V["<<i<<"]";
cin>>V[i];
}
ris=somma(V,n);
cout<<"\n La somma e' : "<<ris;
system("PAUSE");
return 0;
}
int somma(vettore V,int n){
int somma=0;
for(int i=0;i<n;i++){
somma+=V[i];
}
}
*/menu
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int scelta;
do{
cout<<"\n 1 -- calcolo del fattoriale";
cout<<"\n 2 -- potenza";
cout<<"\n 3 -- equazione di primo grado";
cout<<"\n 4 -- esci";
cin>>scelta;
if(scelta==1){
int n,fatt;
cout<<"\n Calcolo del fattoriale";
cout<<"\n Inserisci un numero intero";
cin>>n;
if(n<0)
cout<<"\n Il fattoriale non e' definito per numeri
negativi";

else {
if(n==0 || n==1)
fatt=1;
else
for(int i=1;i<=n;i++)
fatt*=i;
cout<<"\n Il fattoriale di "<<n<<"e':"<<fatt;
}
cout<<"\n";
}else{
if(scelta==2){
cout<<"\n Potenza";
int potenza=1;
int n,m;
cout << "Inserisci la base";
cin>>n;
cout<<"metti la p";
cin>>m;
for(int i=1;i<=m;i++)
potenza=potenza*n;
cout<<potenza;
}else{
if(scelta==3){
cout<<"\n Equazione primo grado";
int a,b;
float x;
cout<<"\n a=";
cin>>a;
cout<<"\n b=";
cin>>b;
if(a==0)
if(b!=0)
cout<<"\n Equa impossibile \n";
else cout<<"\n equa indeterminata \n";
else{
x=-b/a;
cout<<"\n x="<<x;
cout<<"\n";
}
}else{
if(scelta!=4){
cout<<"\n Inserisci uno,due,tre,quattro";
}
}
}
}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[])
{
Vettore V;
int n, ris;
char prec, succ;
leggi(V,n);
cout << "\n inserisci il valore 'prec': ";
cin >> prec;
cout << "\n inserisci il valore 'succ': ";
cin >> succ;
ris=inserisci(V,n,prec,succ);
cout << "\n Sono stati effettuati " << ris << " inserimenti.";
stampa(V,n);
cout << "\n";
system("PAUSE");
return 0;
}
void leggi(Vettore V, int & n){
cout << "\n Inserimento del vettore.";
cout << "\n Fattore di riempimento (max " << MAX << ") -> ";
cin >> n;
for (int i=0; i<n; i++) {
cout << "\n inserisci l'elemento di posizione " << i << ": ";
cin >> V[i];
}
}

void stampa(const Vettore V, const int n){


cout << "\n Stampa del vettore.";
cout << "\n Fattore di riempimento: ";
cout << n;
cout << "\n";
for (int i=0; i<n; i++) {
cout << V[i] << " ";
}
}
int inserisci(Vettore V, int & n, const tipo prec, const tipo
succ){
int cont=0;
int j,pos;
/* individua la posizione pos: si usa il 'for' al posto del
'while' perche'
e' necessario individuare tutti gli elementi uguali a 'prec',
e non solo il primo */
for (int i=0; i<n; i++) {
if (V[i]==prec) {
pos=i+1;
/* inserisce 'succ' in posizione pos */
for ( j=n; j>pos; j-- )
V[j] = V[j-1];
V[pos] = succ;
i++;
// occhio!
n++;
cont++;
}
}
return cont;
}
*/menu convertitore euro lira
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
float euro,lire;
float c=1.93627;
int scelta;
do{
cout<<"\n 1 --Conversione lira-euro "<<endl;
cout<<"\n 2 --Conversione euro-lira "<<endl;
cout<<"\n 3 -- uscita"<<endl;
cin>>scelta;

if(scelta==1){
cout<<"\n Inserisci la lira da convertire in euro";
cin>>lire;
euro=lire/c;
cout<<"\n Il valore convertito in euro e' :"<<euro;
}
else{
if(scelta==2){
cout<<"\n Inserisci l'euro da convertire in lire";
cin>>euro;
lire=euro*c;
cout<<"\n Il valore convertito in lire e' :"<<lire;
}
else{
if(scelta!=3){
cout<<"\n Inserisci 1,2 o 3";
}
}
}
}while(scelta!=3);
system("PAUSE");
return 0;
}
*/prova dell8 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[])
{
int riga,colonna;
matrice A;
matrice B;
matrice C;
matrice D;
cout<<"\n Inserimento della matrice A";
leggi(A,riga,colonna);
cout<<"\n Inserimento della matrice B";
leggi(B,riga,colonna);
appendi_righe(A,B,C,riga,colonna);
fondi_righe(A,B,riga,colonna,D);

cout<<"\n ";
cout<<"stampa di D"<<endl;
for(int i=0;i<riga;i++){
for(int j=0;j<2*riga;j++){
cout<<"\n M["<<i<<"]["<<j<<"]"<<endl;
cout<<D[i][j]<<endl;
}
}
system("PAUSE");
return 0;
}
void leggi(matrice M,int& riga,int & colonna){
cout<<"\n Inserisci il numero di righe";
cin>>riga;
cout<<"\n Inserisci il numero di colonne";
cin>>colonna;
for(int i=0;i<riga;i++){
cout<<" ";
for(int j=0;j<colonna;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
}
void appendi_righe(matrice M1,matrice M2,matrice M3,const int
riga,int & colonna){
for(int i=0;i<riga;i++){
for(int j=0;j<colonna;j++){
M3[i][j]=M1[i][j];
}
}
for(int i=0;i<riga;i++){
for(int j=0;j<2*colonna;j++){
M3[i][colonna+j]=M2[i][j];
}
}
for(int i=0;i<riga;i++){
cout<<" "<<endl;
for(int j=0;j<2*colonna;j++){
cout<<" ";
cout<<M3[i][j];
}
}
}
void fondi_righe(matrice A,matrice B,int & riga,int &
colonna,matrice D){
int colA,colB;
for(int i=0;i<riga;i++){
colA=colB=0;
while(colA<colonna && colB<colonna){
if(A[i][colA]<=B[i][colB]){

D[i][colA+colB]=A[i][colA];
colA++;
}else{
D[i][colA+colB]=B[i][colB];
colB++;
}
}
while(colA<colonna){
D[i][colA+colB]=A[i][colA];
colA++;
}
while(colB<colonna){
D[i][colA+colB]=B[i][colB];
colB++;
}
}
}
*/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[])
{
int n,m;
bool trovato=false;
matrice M;
cout<<"\n";
cout<<"Riempimento di una matrice";
leggi_matrice(M,n,m);
cout<<"\n";
cerca_sella(M,n,m,trovato);
system("PAUSE");

return 0;
}
void leggi_matrice(matrice M,int & n,int & m){
cout<<"\n Inserisci il fattore di riempimento della riga";
cin>> n;
cout<<"\n Inserisci il fattore di riempimento della colonna";
cin>> m;
cout<<"\n La matrice puo' essere al massimo"<< " "
<<max_riga<< " " <<max_colonna;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
cout<<"Fine inserimento"<<endl;
}
void cerca_sella(matrice M,const int n,const int m,bool & trovato)
{
int indice_colonna_min=0;
int indice_colonna_max=0;
int minriga,mincolonna,maxriga,maxcolonna;
for(int i=0;i<n;i++){
minelriga(M,n,m,i,indice_colonna_min,minriga);
maxelcolonna(M,n,m,indice_colonna_min,maxcolonna);
if(minriga==maxcolonna){
trovato=true;
cout<<"\n L'elemento sella e' "<<minriga;
}
for(int k=indice_colonna_min;k<m;k++){
if(M[i][k]==minriga){
indice_colonna_min=k;
maxelcolonna(M,n,m,indice_colonna_min,maxcolonna);
if(minriga==maxcolonna){
trovato=true;
cout<<"\n L'elemento sella e' "<<minriga;
}
}
}
trovato=false;
maxelriga(M,n,m,i,indice_colonna_max,maxriga);
minelcolonna(M,n,m,indice_colonna_max,mincolonna);
if(mincolonna==maxriga){
trovato=true;
cout<<"\n L'elemento sella e' "<<mincolonna;
}
for(int k=indice_colonna_max;k<m;k++){
if(M[i][k]==maxriga){
indice_colonna_max=k;
minelcolonna(M,n,m,indice_colonna_max,mincolonna);
if(mincolonna==maxriga){

trovato=true;
cout<<"\n L'elemento sella e'

"<<mincolonna;

}
}
}
}
}
void minelriga(matrice M,const int n,const int m,int i,int &
indice_colonna_min,int & minriga){
minriga=M[i][0];
for(int j=1;j<m;j++){
if(M[i][j]<minriga){
minriga=M[i][j];
indice_colonna_min=j;
}
}
}
void maxelcolonna(matrice M,const int n,const int m, int
indice_colonna_min,int & maxcolonna){
maxcolonna=M[0][indice_colonna_min];
for(int j=1;j<n;j++){
if(M[j][indice_colonna_min]>maxcolonna){
maxcolonna=M[j][indice_colonna_min];
}
}
}
void maxelriga(matrice M,const int n,const int m,int i,int &
indice_colonna_max,int & maxriga){
maxriga=M[i][0];
for(int j=1;j<m;j++){
if(M[i][j]>maxriga){
maxriga=M[i][j];
indice_colonna_max=j;
}
}
}
void minelcolonna(matrice M,const int n,const int m, int
indice_colonna_max,int & mincolonna)
{
mincolonna=M[0][indice_colonna_max];
for(int j=1;j<n;j++){
if(M[j][indice_colonna_max]<mincolonna){
mincolonna=M[j][indice_colonna_max];
}
}
}
*/ vede se un numero positivo o negativo

#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int c=0;int num;
cout<<"\n Inserisci un numero che sia diverso da 0";
cin>>num;
if(num>c)
cout<<"\n Il numero e' sicuramente positivo";
else
cout<<"\n Il numero e' sicuramente negativo";
system("PAUSE");
return 0;
}
*/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[])
{
int n,m,i,j,k;
bool trovato=false;
matrice M;
cout<<"\n";
cout<<"Riempimento di una matrice";
leggi_matrice(M,n,m);
cout<<"\n";
cerca_sella(M,n,m,k,j,trovato);
if(trovato==true){
cout<<"\n L'elemento sella e' stato trovato"<<endl;
cout<<"\n ed e' "<<M[j][k];
cout<<"\n ed e' l'elemento di posto "<<j<<k<<endl;
}
system("PAUSE");
return 0;
}

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


cout<<"\n Inserisci il fattore di riempimento della riga";
cin>> n;
cout<<"\n Inserisci il fattore di riempimento della colonna";
cin>> m;
cout<<"\n La matrice puo' essere al massimo"<< " "
<<max_riga<< " " <<max_colonna;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
}
void cerca_sella(matrice M,const int n,const int m,int & k,int &
j,bool & trovato){
int i=0;
int pos_elemento_piu_grande_di_indice_k;
int pos_elemento_piu_piccolo_del_vettore_di_indice_i;
int min,mas;
while(i<n && trovato==false){
minel(M,n,m,i,pos_elemento_piu_piccolo_del_vettore_di_indice_i,min
);
k=pos_elemento_piu_piccolo_del_vettore_di_indice_i;
i++;
max(M,n,m,k,pos_elemento_piu_grande_di_indice_k,mas);
j=pos_elemento_piu_grande_di_indice_k;
if(min==mas){
trovato=true;
}
}
}
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){
min=M[i][0];
for(int j=0;j<m;j++){
if(M[i][j]<min){
min=M[i][j];
pos_elemento_piu_piccolo_del_vettore_di_indice_i=j;
}
}
}
void max(matrice M,const int n,const int m,const int k,int &
pos_elemento_piu_grande_di_indice_k,int & mas){
mas=M[0][k];
for(int j=0;j<n;j++){
if(M[j][k]>mas){
mas=M[j][k];
}
}

}
*/semplice menu
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int scelta;
do{
cout<<"1 -- ciao licia"<<endl;
cout<<"2 -- ciao gianni"<<endl;
cout<<"3 -- uscita"<<endl;
cin>>scelta;
if(scelta==1){
cout<<"CIAO LICIA"<<endl;}
else {
if(scelta==2){
cout<<"CIAO GIANNI"<<endl;}
else{
if(scelta!=3){
cout<<"inserisci 1, 2 o 3"<<endl;}
}
}
}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[])
{
int n,m;
char V[DIM];
cout<<"Inserisci la lunghezza delvettore";
cin>>n;
leggi_vetint(V,n);
elimina_dispari(V,n);
stampa_vetint(V,n);
system("PAUSE");
return 0;

}
void leggi_vetint(int V[DIM],int &n){
for(int i=0;i<n;i++){
cout<<"V["<<i<<"]";
cin>>V[i];
}
}
int elimina_dispari(int V[DIM], int &n){
int conta=0;
for(int i=0;i<n;i++){
if(V[i]%2!=0){
for(int j=i;j<n-1;j++){
V[j]=V[j+1];
}
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){
cout<<"Stampa del vettore modificato";
for(int i=0;i<n;i++)
cout<<V[i];
}
*/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[])
{
int riga,colonna;
matrice A;
cout<<"\n Inserimento della matrice A";
leggi(A,riga,colonna);

crea_matrice(A,riga,colonna);
for(int i=0;i<riga;i++){
for(int j=0;j<riga;j++){
cout<<"\n A["<<i<<"]["<<j<<"]"<<endl;
cout<<A[i][j]<<endl;
}
}
system("PAUSE");
return 0;
}
void crea_matrice(matrice M,int & riga,int & colonna){
for(int j=0;j<riga;j++){
M[j][j]=somma_vettori(M,riga,colonna,j);
}
}
int somma_vettori(matrice M,const int riga,const int colonna,const
int j){
int sommacolonna=0;
int sommariga=0;
for(int i=0;i<riga;i++){
sommacolonna=M[i][j]+sommacolonna;
sommariga=M[j][i]+sommariga;
}
return sommariga+sommacolonna-M[j][j];
}

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


cout<<"\n Inserisci il numero di righe";
cin>>riga;
cout<<"\n Inserisci il numero di colonne";
cin>>colonna;
for(int i=0;i<riga;i++){
cout<<" ";
for(int j=0;j<colonna;j++){
cout<<"\n M["<<i<<"]["<<j<<"]";
cin>>M[i][j];
}
}
}
*/media aritmetica
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{

int a,b,c;
float media;
cout<<"\n Inserisci il primo numero";
cin>>a;
cout<<"\n Inserisci il secondo numero";
cin>>b;
cout<<"\n Inserisci il terzo numero";
cin>>c;
media=float(a+b+c)/3;
cout<<"\n la media e':"<<media;
system("PAUSE");
return 0;
}
*/confronto fra 2 numeri
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
int a,b;
cout<<"\n Inserisci il numero A";
cin>>a;
cout<<"\n Inserisci il numero B";
cin>>b;
cout<<"\n Confronto tra i 2 numeri A e B in cui si suppone che
essi non possano essere mai uguali";
if(a>b)
cout<<"\n A e' piu' grande di B";
else
cout<<"\n B e' piu' grande di A";
system("PAUSE");
return 0;
}
*/contatore pari e dispari
#include <iostream>
#include <stdlib.h>
using namespace std;
int
{
int
int
int
do{

main(int argc, char *argv[])


x;
contatore=0;
cont=0;
cout << " \n Inserisci il numero " ;
cin >> x;
if ( x%2==0){
contatore++;

}else{
cont++;
}
}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[])
{
int a,b,h,s,l;
float c;
int *p;
int *q;
float *r;
int *k;
cin>>a;
cin>>b;
cin>>c;
p=&a;
q=&b;
r=&c;
k=&s;
s=*p+*q;
l=*k * *p * *q ;
cout<<l<<endl<<&l;
system("PAUSE");
return 0;
}
*/stringa
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
//la dimensione di stringa1 =alla lunghezza della parola + il
carattere di terminazione (quindi 7+1=8)
char stringa1[]="parola1";

//pstringa1 un puntatore a carattere


char *pstringa1;
//stringa2 una stringa di 8 parole ('p','a','r','o','l','a','2'
+ '\0')
char stringa2[8]="parola2";
//a pstringa1 gli diamo l'indirizzo di memoria del primo
carattere di stringa1 (quindi indirizzo di 'p')
pstringa1=stringa1;
//il while finisce quando il valore di pstringa1 uguale a '\0'
while(*pstringa1!='\0'){ //while(*pstringa1)
//stampo il valore di pstringa1 (la 1 vol stampa 'p'.la 2 'a'
...... fino a '1'
cout<<*pstringa1<<endl;
//passo all'indirizzo di memoria della lettera
successiva(quindi se pstringa
//contiene l'indirizzo di 'p',dopo l'istruzione conterr
l'indirizzo di 'a'
pstringa1++;
}
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[])
{
int r,k,num;
int V[DIM];
cout<<"\n Inserimento del vettore";
cout<<"\n Inserisci la lunghezza del vettore";
cin>>r;
cout<<"\n Inserisci il numero da confrontare";
cin>>k;
for(int i=0;i<r;i++){
cout<<"\n V["<<i<<"]";
cin>>V[i];
}
num=0;
for(int i=0;i<r;i++){

if(V[i]>k)
num++;}
for(int i=0;i<r;i++){
if(V[i]<=k)
V[i]=num;
}
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[])
{
int n;
float somma=0;
cout << " \n Inserisci un numero positivo " ;
cin >> n;
for(float i=1;i<=n;i++){
somma=somma+ (1/i);
cout<<i;
}
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[])
{
int n , minimo ,x;
cout << " \n Inserisci n " ;
cin >>n;
cout << " \nInserisci il primo numero " ;
cin >> x;
minimo=x;
for (int i=1;i<n;i++){
cout << " \n Inserisci gli altri numeri " ;
cin >> x ;

if(x < minimo){


minimo=x;
}
}
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[])
{
int n,x;
cout << " \n Inserisci n " ;
cin >>n;
int contatore=0;
int cont=0;
for(int i=1;i<=n;i++){
cout << " \n Inserisci gli altri numeri " ;
cin >> x;
if ( x%2==0){
contatore++;
}else{
cont++;
}
}
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()
{
int n,x;
int pari=0;
int dispari=0;
cout << " \n Inserisci gli elementi(per terminare la lista
inserisci uno negativo alla fine)" ;
n=1;
do{

cout << " \n Inserisci un elemento " ;


cin >>x;
if(x%2==0)
pari++;
else
dispari++;
if(x<=0)
cout << " \n Hai inserito un numero negativo, fine
lista"<<endl;
}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()
{
int x;
int k=2;
int nprimo=0;
do{
cout<<"Inserisci il numero : ";
cin>>x;
if (x<=0)
cout<<"\n Inserire un numero maggiore o uguale a
1"<<endl;
else{
if (x==1)
cout<<"\n Il numero 1 e' sicuramente primo"<<endl;
else{
while (k<x && nprimo==0){
if (x%k==0)
nprimo=1;
else
k++;
}
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()
{
int n,i,k;
char car;
cout<<"Inserire l'altezza del triangolo : ";
cin>>n;
cout<<"inserire il carattere : ";
cin>>car;
k=1;
while(k<=n){
for (i=0;i<k;i++)
cout<<car;
cout<<endl;
k++;
}
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[])
{
int esci=1;
do {
int vettore[DIM];

int n,ris;
leggi_vetint(vettore,n);
cout << "\n Eliminazione di tutti gli elementi dispari dal
vettore.";
ris=elimina_dispari(vettore,n);
if(ris==0) cout << "\n nessun elemento eliminato!";
else {
cout << "\n sono stati eliminati n. " << ris << "
elementi.";
cout << "\n Vettore risultante: ";
stampa_vetint(vettore,n);
}
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 Procedura di inserimento del vettore";
cout << "\n Inserisci il riempimento: ";
cin >> n;
cout << "\n Inserisci il vettore. Solo numeri interi positivi:
";
for (int i=0; i<n; i++) {
cout << "\n Elemento di posizione " << i << ": ";
cin >> V[i];
}
cout << "\n Inserimento terminato.";
}
int elimina_dispari(int V[], int & n){
int el=0;
int cont=0;
for (int i=0; i<n; i++)
if (V[i]%2) {
for ( int j=i; j<n-1; j++ )
V[j] = V[j+1];
n--;
cont++;
i--;
}
return cont;
}
void stampa_vetint(const int V [], const int n){
if (n!=0)

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


cout << "\n Elemento di posizione " << i << ": ";
cout << V[i];
}
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[])
{
int esci=1;
do {
char S[DIM];
int ris;
char X;
cout << "\n Inserisci una stringa di caratteri:";
cin.getline(S,DIM-1);
cout << "\n Inserisci un carattere X da eliminare:";
cin >> X;
cout << "\n Eliminazione di tutti gli elementi X dalla
stringa.";
ris=elimina_carattere(S,X);
if(!ris) cout << "\n nessun elemento eliminato!";
else {
cout << "\n sono stati eliminati n. " << ris << "
elementi.";
cout << "\n Stringa risultante: ";
cout << S;
}
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) {
int el=0, i=0;
int cont=0;

while (S[i]!='\0') {
if (S[i]==X) {
int j=i;
while (S[j]!='\0') {
S[j] = S[j+1];
j++;
}
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[]) {
int A[maxrow][maxcol];
int pos_row1, pos_row2;
int n,m;
int esci=0;
while (!esci) {
leggi_matrice(A,n,m);
cout << "\n inserisci l'indice di riga: ";
cin >> pos_row1;
if (pos_row1<=0 || pos_row1>n-1) cout << "\n inserimanto
errato!";
else {
if(verifica_righe_uguali(A,n,m,pos_row1, pos_row2)) {
cout << "\n Trovate due righe uguali. ";
cout << "\n Righe: " << pos_row1 << " e " << pos_row2;
}
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 trovato=false;
pos2=0;
while (pos2<pos1 && !trovato)
if(uguali(M,n,m,pos1,pos2))
trovato=true;
else pos2++;
return trovato;
}
bool uguali(const int M[][maxcol], const int n, const int m,
const int index1, int & index2) {
bool uguali=true;
int j=0;
while (j<m && uguali)
if(M[index1][j]!=M[index2][j]) uguali=false;
else j++;
return uguali;
}
void leggi_matrice(int M [][maxcol], int & n, int & m) {
cout << "\n inserimento della matrice.";
cout << "\n Quante righe? ";
cin >> n;
cout << "\n Quante colonne? ";
cin >> m;
for (int i=0; i<n; i++)
for (int j=0; j<m; j++)
cin >> M[i][j];
cout << "\n Inserimento terminato. ";
}