Programmazione II - esercizi

T=C;

l_t=l_t-l_p;//riduco la dimensione del testo

}

}

while(T<*testo+l_t-l_p+1 && C!=0);

*testo=(char *)realloc(*testo,strlen(*testo));

printf("~~~ Pattern eliminati : ~~~ %d\n\n",num_trov);

}

27- LIV 2/ LIV 3 Scrivere una function c che sostituisca in un testo tutte le

occorrenze di una sottostringa con un'altra

#include <stdio.h> 41

#include <stdlib.h>

#include <string.h>

void sost_din(char **testo,char *patt,char *str);

void sost_stat(char *testo,char patt[],char str[]);

void main()

{ char *testo_d,*patt_d,*str_d,S[200],P[200],T[500]; //C e T variabili d'appoggio

per testo e chiave da assegnare dinamcamente

char testo[500]="0",patt[200]="0",str[200]="0";

int i,j,scelta;

while (scelta!=0)

{ printf("~~~ Scegliere come si desidera allocare la stringa: ~~~ \n-1

-->ALLOCAZIONE STATICA\n-2 -->ALLOCAZIONE DINAMICA\n-0 -->USCITA\n\n");

scanf("%d",&scelta);

if (scelta==1)

{ printf("~~~ Inserire il testo : ~~~ \n ");

fflush(stdin);

gets(testo);

printf("\n~~~ Inserire la sottostringa da cercare: ~~~ \n ");

fflush(stdin);

gets(patt);

printf("\n~~~ Inserire la sottostringa da sostituire : ~~~ \n ");

fflush(stdin);

gets(str);

sost_stat(testo,patt,str);

printf("\n~~~ Il testo dopo la sostituzione e': ~~~\n ");

puts(testo);

printf("\n");

}

if (scelta==2)

{ testo_d=(char *)malloc(500);

patt_d=(char *)malloc(500);

str_d=(char *)malloc(500);

printf("~~~ Inserire il testo : ~~~ \n ");

fflush(stdin);

gets(T);

strcpy(testo_d,T);

testo_d=(char *)realloc(testo_d,strlen(testo_d));

//puts(testo_d);

printf("\n~~~ Inserire la sottostringa da cercare: ~~~ \n ");

fflush(stdin);

gets(P);

strcpy(patt_d,P);

patt_d=(char *)realloc(patt_d,strlen(patt_d));

//puts(patt_d);

printf("\n~~~ Inserire la sottostringa da sostituire : ~~~ \n ");

fflush(stdin);

gets(S);

strcpy(str_d,S);

str_d=(char *)realloc(str_d,strlen(str));

//puts(testo_d);

sost_din(&testo_d,patt_d,str_d);

printf("\n~~~ Il testo dopo la sostituzione e': ~~~\n ");

puts(testo_d); 42

printf("\n");

}

}

}

void sost_din(char **testo,char *patt,char *str)

{ int l_t,l_p,l_s,j=0;

char *T,*C;

l_t=strlen(*testo);

l_p=strlen(patt);

l_s=strlen(str);

T=*testo; do

{ C=strstr(T,patt);

if(C!=0)

{ memcpy(C,str,l_s);//copio gli n byte di str in C

}

}

while (T<*testo+l_t-l_p+1 && C!=0);

*testo=(char *)realloc(*testo,strlen(*testo));

}

void sost_stat(char *testo,char patt[],char str[])

{ int l_t,l_p,l_s,j=0;

char *T,*C;

l_t=strlen(testo);

l_p=strlen(patt);

l_s=strlen(str);

T=testo; do

{ C=strstr(T,patt);

if(C!=0)

{ memcpy(C,str,l_s);//copio gli n byte di str in C

}

}

while (T<testo+l_t-l_p+1 && C!=0);

*testo;

} 43

28- A partire da una matrice A(m*n), allocata per righe staticamente

e dinamicamente visualizzarne gli elementi per colonne

#include <stdio.h>

#include <stdlib.h>

#define m 4

#define n 6

void vis_stat(int a[m][n]);

void vis_din(int a[m][n],int *b);

void main()

{ int a[4][6]={{11,12,13,14,15,16},

{21,22,23,24,25,26},

{31,32,33,34,35,36},

{41,42,43,44,45,46}};

int *b,*c;

int i,j,scelta;

while (scelta!=0)

{ printf("~~~ Scegliere come si desidera allocare la matrice: ~~~ \n-1

-->ALLOCAZIONE STATICA\n-2 -->ALLOCAZIONE DINAMICA\n-0 -->USCITA\n\n");

scanf("%d",&scelta);

if (scelta==1)

vis_stat(a);

if (scelta==2)

vis_din(a,b);

}

}

//visualizza sia per riga che per colonna la matrice allocata staticamente

void vis_stat(int a[m][n])

{ int i,j;

printf("~~~ MATRICE ALLOCATA STATICAMENTE ~~~ \n\n");

printf("~~~ Elementi visualizzati per riga: ~~~ \n");

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

{ 44

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

{ printf(" %d\t ",a[i][j]);

}

printf("\n");

}

printf("\n~~~ Elementi visualizzati per colonna: ~~~ \n");

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

{ for (i=0;i<m;i++)

{ printf(" %d\t ",a[i][j]);

}

printf("\n");

}

printf("\n");

}

//visualizza sia per riga che per colonna la matrice allocata dinamicamente

void vis_din(int a[m][n],int *b)

{ int i,j,h;

int *c;

b=(int *)malloc(m*n*sizeof(int));

printf("\n\n~~~ MATRICE ALLOCATA DINAMICAMENTE ~~~ \n\n");

printf("~~~ Elementi visualizzati per riga: ~~~ \n");

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

{ for (j=0;j<n;j++)

{ *(b+i*n+j)=a[i][j]; //copio l'elemento della matrice

printf(" %d\t ",*(b+i*n+j));

}

printf("\n");

}

printf("\n~~~ Elementi visualizzati per colonna: ~~~ \n");

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

{ for (i=0;i<m;i++)

{ *(b+i*n+j)=a[i][j];

printf(" %d\t ",*(b+i*n+j));

}

printf("\n");

}

printf("\n");

} 45

29 - scrivere una function c che restituisca la matrice C(m x n) prodotto

righe x colonne delle 2 matrici rettangolari A(m x p) e B(p x n) le cui

dimensioni sono stabilite in input(allocazione dinamica) e calcolare il tempo

di esecuzione

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void vis_din(int **b,int m, int n);

void vis_mat(int *a,int m,int n);

void prodotto(int *a,int m,int *b,int n,int p,int **c);

void main()

{ int *a,*b,*c;

int i,j,k,r_a,n,c_b;

float Loop_max;

double rapp_temp;

time_t Time_start, Time_finish; /* dichiara le variabili di tipo time_t */

printf("\n~~~ MATRICE A (m x n) ~~~ \n\n");

printf("~~~ Inserire il numero di righe: ~~~ \n ");

scanf("%d",&r_a);

printf("~~~ Inserire il numero di colonne: ~~~ \n ");

46

scanf("%d",&n);

vis_din(&a,r_a,n);

printf("\n~~~ MATRICE B (n x p) ~~~ \n\n");

printf("~~~ Numero di righe B = Numero colonne A: ~~~ \n ");

printf("%d\n",n);

printf("~~~ Inserire il numero di colonne: ~~~ \n ");

scanf("%d",&c_b);

vis_din(&b,n,c_b);

c=(int *)calloc(r_a*c_b,sizeof(int));

printf("\n~~~ Inserire loop_max ~~~\n ");

scanf("%f",&Loop_max); //loop maggiori per matrici piccole,loop piccoli per

matrici grandi

time( &Time_start ); //tempo iniziale

for(k=0; k<Loop_max; k++)

{ prodotto(a,r_a,b,c_b,n,&c);

}

time( &Time_finish ); //tempo finale

rapp_temp = (Time_finish-Time_start)/(double)Loop_max;

printf( "\n~~~ MATRICE C (m x n) prodotto scalare AxB : tempo di esecuzione in

secondi: ~~~\n %12.3f seconds.\n\n ",rapp_temp);

}

//visualizza la matrice

void vis_mat(int *a,int m,int n)

{ int i,j;

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

{ for (j=0;j<n;j++)

{ printf(" %d\t ",*(a+i*n+j));

}

printf("\n");

}

}

//genera casualmente elementi della matrice allocata dinamicamente

void vis_din(int **b,int m, int n)

{ int i,j,h;

srand((unsigned)time(NULL));

printf("\n");

*b=(int *)calloc(m*n,sizeof(int));

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

{ for (j=0;j<=n-1;j++)

{ *(*b+i*n+j)=rand()*100/RAND_MAX; //RAND_MAX=per avere numeri interi

compresi tra 0 e 100 esclusi gli estremi

}

}

}

//calcoloa il prodotto scalare tra le due matrice restiruendo quindi la terza matrice c

void prodotto(int *a,int m,int *b,int n,int p,int **c)

{ int i,j,k,x,y,cont=0;

double temp;

//*c=(int *)calloc(m*n,sizeof(int)); 47

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

{ for (j=0;j<n;j++)

{ for (k=0;k<p;k++)

{ *(*c+(i*n)+j)=(*(*c+(i*n)+j))+(*(a+(i*p)+k))*(*(b+(k*n)+j));

}

}

}

}

30 – LIV 3 ripetere il prodotto righe per colonne allocando una prima volta

tute le matrici in memoria per colonne ed una seconda volta per righe. per

ciascun tipo di allocazione usare due function c per il prodotto righe per

colonna:una che acceda a tutte le matrici per colonna e l'altra per righe

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

void mat_col(int **b,int m, int n);

void vis_mat_col(int *a,int m,int n);

void mat_rig(int **b,int m, int n);

void vis_mat_rig(int *a,int m,int n);

void prodotto_c(int *a,int m,int *b,int n,int p,int **c);

void prodotto_r(int *a,int m,int *b,int n,int p,int **c);

void main()

{ int *a,*b,*c;

int i,j,r_a,n,c_b;

unsigned long Loop_max;

double rapp_temp,rapp_temp2,rapp_temp3,rapp_temp4;

time_t Time_start, Time_finish; /* dichiara le variabili di tipo time_t */

Loop_max=100000000;

printf("~~~ Inserire il numero di righe della matrice A (m x n): ~~~ \n ");

scanf("%d",&r_a);

printf("~~~ Inserire il numero di colonne della matrice A (m x n): ~~~ \n ");

scanf("%d",&n); 48

printf("~~~ Numero di righe della matrice B (n x p) = Numero colonne A: ~~~ \n ");

printf("%d\n",n);

printf("~~~ Inserire il numero di colonne della matrice B (n x p): ~~~ \n ");

scanf("%d",&c_b);

c=(int *)calloc(r_a*c_b,sizeof(int));

printf("\n\n~~~ ALLOCAZIONE PER COLONNE: ~~~ \n ");

printf("\n~~~ MATRICE A (m x n) ~~~ \n\n");

mat_col(&a,r_a,n);

vis_mat_col(a,r_a,n);

printf("\n\n~~~ MATRICE B (n x p) ~~~\n\n");

mat_col(&b,n,c_b);

vis_mat_col(b,n,c_b);

printf("\n\n~~~ MATRICE C (m x n) prodotto scalare A x B accesso per colonne:

~~~\n\n");

prodotto_c(a,r_a,b,c_b,n,&c);

vis_mat_col(c,r_a,c_b);

printf("\n\n~~~ MATRICE C (m x n) prodotto scalare A x B accesso per righe:

~~~\n\n");

prodotto_r(a,r_a,b,c_b,n,&c);

vis_mat_rig(c,r_a,c_b);

printf("\n\n~~~ ALLOCAZIONE PER RIGHE: ~~~ \n ");

printf("\n~~~ MATRICE A (m x n) ~~~ \n\n");

mat_rig(&a,r_a,n);

vis_mat_rig(a,r_a,n);

printf("\n\n~~~ MATRICE B (n x p) ~~~ \n\n");

mat_rig(&b,n,c_b);

vis_mat_rig(b,n,c_b);

printf("\n\n~~~ MATRICE C (m x n) prodotto scalare A x B accesso per colonne:

~~~\n\n");

prodotto_c(a,r_a,b,c_b,n,&c);

vis_mat_col(c,r_a,c_b);

printf("\n\n~~~ MATRICE C (m x n) prodotto scalare A x B accesso per righe:

~~~\n\n");

prodotto_r(a,r_a,b,c_b,n,&c);

vis_mat_rig(c,r_a,c_b);

}

//visualizza la matrice allocata per colonne

void vis_mat_col(int *a,int m,int n)

{ int i,j;

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

{ for (j=0;j<n;j++)

{ printf(" %d\t ",*(a+j*m+i)); //cambio indici

}

printf("\n");

}

} 49

//ge