EserciziSvoltiPZ < Programmazione1/AA0506/PZ

Tags: view all tags
-- Users.LauraRavagli - 27 Dec 2002
   * [[%ATTACHURL%/Esercizi.mht][Esercizi.mht]]: lista degli esercizi di preparazione all'esame
   * http://cesare.dsi.uniroma1.it/~prog1/EserciziSol.html    esercizi già svolti 

   * *ESAME1*
<verbatim>
   Scrivere una funzione che preso in input una stringa stampa per ciascuna cifra (cioè un       carattere dell'insieme 
0,1,2,3,4,5,6,7,8,9) presente nella stringa il numero di occorrenze. La stampa deve avvenire per cifre 
crescenti. Il prototipo della funzione è  void StampaOcc(const char *). 
Ad esempio se la stringa di input è  "3aB91cz33391a"  allora la funzione deve stampare: 
    la cifra 1 compare 2 volte 
    la cifra 3 compare 4 volte 
    la cifra 9 compare 2 volte 



   void StampaOcc(const char *vstr)
    {
    char vettnum[10]= {0};   //0 e non '0'
    int index;
    
        
    while ( *vstr != '\0')
        {if (*vstr >= '0' && *vstr <= '9')
           vettnum[*vstr - '0']++;
        vstr++;
        }
    
    for (index=0;index <10; index++)        
       {if (vettnum[index] > 0)                                           //0 e non '0'
          printf("la cifra %d compare %d volte\n",index,vettnum[index]);} //%d sul primo non %c anche sul 2°
          
    }
</verbatim>


   * *ESAME2*
<verbatim>
Scrivere una funzione che preso in input il puntatore al primo elemento di una lista di numeri e un intero non 
negativo d, elimina dalla lista gli ultimi d elementi e ritorna il puntatore al primo elemento della lista così modificata. 
Se la lista ha meno di d elementi, tutti gli elementi della lista vengono eliminati. Il tipo degli elementi della lista è 
typedef struct NumElem { 
    float           num; 
    struct NumElem *pros; 
} NumElem, *NumList; 
Il prototipo della funzione è   NumList CutTail(NumList L, unsigned long d). 


   NumList CutTail1(NumList L, unsigned long d) 
   {
    NumList cur,temp;
    if (L==NULL || d==0)
        return L;
 
    cur = L;
    if (cur->pros ==NULL)
      {free(cur);
      return NULL;}
      
    while (cur->pros->pros != NULL)
      {cur=cur->pros;}
    free(cur->pros);
   
    cur->pros =NULL;
   
   
    L=CutTail1(L,--d);                       
   }
</verbatim>


   * *ESAME3*
<verbatim>
Scrivere una funzione che presa in input una lista di stringhe, elimina dalla lista tutti i duplicati e ritorna il puntatore al primo 
elemento della lista così ripulita. Gli elementi della lista hanno il seguente tipo: 
typedef struct SList { 
    char *        stringa; 
    struct SList *next; 
} SList; 
La memoria degli elementi eliminati deve essere rilasciata. Per questo si assume che sia la struct SList che il campo 
stringa sono stati allocati dinamicamente. Il prototipo della funzione è   SList *RipulisciStr(SList *). 



//funzione ricorsiva:
//considera sempre il primo elemento della lista passata
//e verifica se nei rimanenti elementi ci sono duplicati

SList *RipulisciStr(SList *vSLista)
 {
 SList *temp, //mi punta ad un elemento
       *suc;  //ed al successivo
 
 //lista vuota
 if (vSLista == NULL )
  return vSLista;
 //o composta da 1 elemento
 if (vSLista->next == NULL )
  return vSLista;
 
 //punto il primo elemento
 temp = vSLista;
 //e il successivo
 suc=temp->next;
    
 //scorro la lista mettendo a confronto il primo elemento con gli altri
 while (suc != NULL)
  {
  if (suc->num == vSLista->num) // se e' uguale
    {temp->next = temp->next->next;                   //la salto
    free(suc);}                                       //la libero  
  else  
    temp=temp->next;                                  //punto al successivo
 
  suc=temp->next;                                     //punto al succesivo di temp             
  }
 
 //considero l'elemento successivo a quello appena verificatp
 vSLista->next=RipulisciStr(vSLista->next);
 return vSLista;
         
 }
</verbatim>


   * *Esame4*
<verbatim>
Scrivere una funzione che presi in input tre interi non negativi nA, nB, nC, restituisce una stringa allocata dinamicamente 
che consiste di nA caratteri A seguiti da nB caratteri B seguiti da nC caratteri C. Il prototipo della funzione è 
char *ABCStringa(unsigned short nA, unsigned short nB, unsigned short nC). 
Ad esempio se nA = 2, nB = 1 e nC = 4 la funzione deve restituire la stringa "AABCCCC". 



char *ABCStringa(unsigned short nA, unsigned short nB, unsigned short nC)
    {
    char *myStringa;
    char lett[]="ABC";
    int quan[]={nA,nB,nC}; 
    int i;
    unsigned int tot = nA+nB+nC + 1 ;
    
    myStringa= malloc(sizeof(char) * (tot));
    
    for (i=0;i<3;i++) 
        while (quan[i]--)
              *(myStringa++)=lett[i];
      
    *(myStringa)='\0';
   
    return myStringa-= tot-1;

    }
</verbatim>

   * *Esame5*
<verbatim>

Scrivere una funzione che presa in input una lista di interi, crea una nuova lista dello stesso tipo che contiene gli stessi 
elementi della lista di input ma in ordine inverso. Il tipo degli elementi è il seguente: 
typedef struct IntList { 
    int             data; 
    struct IntList *next; 
} IntList; 
Il prototipo della funzione è   IntList *CreaInversa(const IntList *). 
Ad esempio se la lista di input è 2 -> 5 -> 2 -> 9 -> 13 la lista restituita dalla 
funzione è 13 -> 9 -> 2 -> 5 -> 2. 

IntList *CreaInversa(const IntList *v) 
{ 
IntList *newv =NULL,
        *temp =NULL;
        
    
    while (v!=NULL)
      { 
      temp =malloc(sizeof(IntList));
      temp->data=v->data;    
      temp->next=newv;
      newv=temp;
      v=v->next;
      } 

return newv;

} 
</verbatim>

   * *ESAME6*
<verbatim>
Scrivere una funzione che preso in input una stringa nomeFile, legge dal file di nome nomeFile gli interi contenuti in esso, 
crea una lista contenente tali interi (non necessariamente nello stesso ordine) e ritorna il puntatore al primo elemento della lista 
creata. Il tipo degli elementi della lista è così definito: 
typedef struct Elem { 
    int          intero; 
    struct Elem *pross; 
} Elem, *Lista; 
Il file si assume essere di tipo testo. Il prototipo della funzione è  Lista File2Lista(const char *nomeFile). 
Ad esempio se il file contiene 13 -6 45 897 allora la funzione restituisce la lista 13 -> -6 -> 45 -> 897 (l'ordine 
non ha importanza). 

Lista File2Lista(const char *nomeFile)
{
  //apre il file e inserisce in testa

  FILE *myFile;
  int valore;
  Lista temp=NULL;
  Lista newl=NULL;
  if ((myFile = fopen(nomeFile,"r")) != NULL)
    {while (fscanf(myFile,"%d",&valore)==1)
        {
        temp=malloc(sizeof(Elem));
        temp->intero=valore;
        temp->pross=newl;
        newl=temp;
        }
    fclose(myFile);}                
  else
    printf("errore di accesso");  
    
    return newl;
    
}


Lista File1Lista(const char *nomeFile)
{
  //apre il file e inserisce in coda

  FILE *myFile;
  int valore;
  Lista temp=NULL;
  Lista newl=NULL;
  Lista coda=NULL;

  if ((myFile = fopen(nomeFile,"r")) != NULL)
    {while (fscanf(myFile,"%d",&valore)==1)
        {
        temp=malloc(sizeof(Elem));
        temp->intero=valore;
        temp->pross=NULL;
        if (coda==NULL)
           newl=temp;
        else
           coda->pross = temp;
        coda=temp;
        }
    fclose(myFile);}                
  else
    printf("errore di accesso");  
    
    return newl;
    
} 

</verbatim>


   * *ESAME7*
<verbatim>
Scrivere una funzione che preso in input un vettore di interi e la sua dimensione, riordina gli elementi del vettore in senso inverso. 
Il prototipo della funzione è   void Inverti(int V[], int dim). Ad esempio se V = [2, -7, 5, 2, 76], 
la funzione lo inverte così V = [76, 2, 5, -7, 2]. 

void Inverti(int V[], int dim)
    {
    int i,app;
    
    for ( i=0 ; i < dim/2 ; i++ )
       {
       app = V[i];
       V[i] = V[dim-1-i];
       V[dim-1-i] = app;
       }   
       
    }
</verbatim>


   * *ESAME8*
<verbatim>
Diciamo che un vettore V di n interi è palindromose la sequenza di interi V[0], V[1], ..., V[n - 1] è  uguale alla 
sequenza inversa V[n - 1], V[n - 2], ..., v[0]. Scrivere una funzione che preso in input un vettore di interi e la 
sua dimensione ritorna 1 se il vettore è palindromo e 0 altrimenti. Il prototipo della funzione è 
                short Palindromo(int V[], int dim). 

short Palindromo(int V[], int dim)
    {
    int i,app;
    
    for ( i=0 ; i < dim/2 ; i++ )
       if (V[i] != V[dim-1-i])
          return 0;      
    
    return 1;
       
    }
</verbatim>


   * *ESAME9*
<verbatim>
Scrivere una funzione che preso in input un vettore di interi ordinato in senso non decrescente e la sua dimensione, elimina 
dal vettore tutti i duplicati compattandolo e ritorna il numero di elementi eliminati. Il prototipo della funzione è 
                long EliminaDuplicati(int V[], long dim). 
Ad esempio se V = [2, 4, 4, 5, 7, 7, 7] la funzione modifica il vettore in modo tale che i primi 4 elementi del 
vettore siano [2, 4, 5, 7] e ritorna 3. 

long EliminaDuplicati2(int v[], long dim)
    {
    long scorri,i=0;
    
    for ( scorri=0 ; scorri < dim ; scorri++)
       if (v[scorri] != v[i])
          v[++i]= v[scorri];
    return dim - ++i;
             
    }        

</verbatim>

   * *ESAME10*
<verbatim>

Scrivere una funzione che preso in input una lista di interi, per ogni elemento della lista modifica l'intero in esso contenuto in 
modo tale che contenga la somma di tutti gli interi contenuti nella lista a partire da quel elemento. Il tipo degli elementi 
della lista è: 
typedef struct IntElem { 
    int             intero; 
    struct IntElem *next; 
} IntElem, *IntList; 
Il prototipo della funzione è    void SomList(IntList). Ad esempio se la lista è 2 -> 5 -> 3 -> 13 allora 
la funzione modifica la lista così 23 -> 21 -> 16 -> 13. 

void SomList(IntLista myLista)
    {
    IntLista temp=NULL;
    int somma=0;
    if (myLista==NULL)
        return;
    
    temp=myLista;
    while (temp != NULL)        
        {somma += temp->data;
        temp=temp->next;
        }    
    myLista->data = somma; 
    SomList(myLista->next);   
    }

</verbatim>

  
   * *ESAME11*
*SOLUZIONE ERRATA* : non prende in considerazione i numeri già visti
<verbatim>
Scrivere una funzione che presi in input una lista di interi e una stringa nomeF crea un file di tipo testo di nome nomeF e 
vi scrive gli interi che nella lista compaiono un numero dispari di volte. Il tipo degli elementi della lista è: 
typedef struct Elem { 
    int          valore; 
    struct Elem *succ; 
} Elem, *List; 
Il prototipo della funzione è    void FileDispari(const List L, const char *nomeF). Ad esempio se 
la lista è 3 -> 2 -> 3 -> 5 -> 4 -> 5 -> 5 il file deve contenere 2 5 4 (l'ordine non ha importanza)

void FileDispari(const IntLista L,const   char *nomeF)
    {
    IntLista temp=NULL;
    int num=1;
    FILE *myFile;
    
    if (L==NULL)
        return;
    
    temp=L;
    
    while (temp != NULL)        
        {
        if (temp->data==L->data)
         num *= -1;
         temp=temp->next;       
        }    
    
    if (num<0)
        {
        myFile=fopen(nomeF,"a");
        fprintf(myFile,"%d\n",L->data);
        fclose(myFile);
        }
    
    FileDispari(L->next,nomeF);   
    
    }

</verbatim>