stringa.c 1/5

[
top][prev][next]
/* Realizzare le implementazioni delle seguenti funzioni per
   manipolare le stringhe (disponibili nella libreria standard del C:
   
   - int mystrlen(char s[]);

     Restituisce la lunghezza della stringa s (per lunghezza si
     intendono i caratteri effettivi, quindi '\0' escluso)

   - int mystrcmp(char s1[], char s2[]); 

     Restituisce -1 se s1 è "minore" (ovvero precede nell'ordine
     alfabetico) s2, 0 se sono uguali e 1 se s1 è "maggiore" di s2

   - void mystrcpy(char dest[], char src[]); 

     Copia il contenuto della stringa src nella string dest. La
     stringa dest deve essere sufficientemente grande per contenere
     i caratteri di src

*/

#include <stdio.h>

#define MAX_DIM 80

int mystrlen(char s[]) {

  int i;

  i = 0;

  /* Incremento i fino a quando raggiungo il carattere "tappo". A quel
     punto i mi indica la dimensione della stringa, ovvero il numero
     di caratteri validi */
  while(s[i] != '\0') {
    i = i + 1;
  }

  return i;

}

int mystrcmp(char s1[], char s2[]) {
  
  int dim1, dim2, i, dimMinima;

  /* Trovo la lunghezza delle due stringhe e determino la minore */
  dim1 = mystrlen(s1);
  dim2 = mystrlen(s2);

  if(dim1 < dim2) {
    dimMinima = dim1;
  }
  else {
    dimMinima = dim2;
  }

  /* Adesso scandisco tutte le stringhe (fermandomi quando ho scandito
     la stringa più piccola e carattere per carattere la confronto con
     l'altra: se i caratteri sono uguali proseguo al carattere
     successivo, altrimenti li confronto e restituisco 1 o -1 a
     seconda se il carattere di s1 sia maggiore o minore del carattere
     di s2 */
  for(i = 0; i < dimMinima; i = i + 1) {
    if(s1[i] > s2[i]) {
      /* Il return interrompe l'esecuzione della funzione e ritorna il
	 valore 1 al programma chiamante */
      return 1;
    }
    else if(s1[i] < s2[i]) {
      return -1;
    }
  }

  /* Se ho terminato il for vuol dire che tutti i caratteri letti
     erano identici altrimenti sarebbe stato eseguito un return. Se le
     due stringhe hanno la stesso lunghezza, questo vuol dire che sono
     uguali e quindi restituisco 0, altrimenti scopro qual è la
     stringa più corta */
  if(dim1 == dim2) {
    return 0;
  }
  else if(dim1 < dim2) { /* Ad esempio se s1="CASA" e s2="CASALE", s1
			    è "minore" (cioè viene prima in ordine
			    alfabetico di s2 */
    return -1;
  }
  else { /* cioè dim1 > dim2 */
    return 1;

  }

}

void mystrcpy (char dest[], char src[]) {
  int dim, i;

  /* calcolo la lunghezza di src */
  dim = mystrlen(src);

  /* Carattere per carattere copio il contenuto di src in dest */
  for(i = 0; i < dim; i = i + 1) {
    dest[i] = src[i];
  }

  /* Inserisco il "tappo" */
  dest[i] = '\0';

  /* Siccome gli array vengono passati automaticamente per indirizzo,
     le modifiche effettuate su dest non rimangono confinate alla
     funzione perchè ho operato direttamente sulla variabile del
     progromma chiamante e non su una sua copia */

}

void main() {

  char a[MAX_DIM];
  char b[MAX_DIM];
  int compare;

  printf("Inserisci la prima stringa ");
  gets(a);

  printf("Inserisci la second stringa ");
  gets(b);

  printf("La prima stringa è lunga %d caratteri\n", mystrlen(a));
  printf("La seconda stringa è lunga %d caratteri\n", mystrlen(b));
 
  compare = mystrcmp(a, b);

  if(compare == 0) {
    printf("Le due stringhe sono uguali\n");
  }
  else if(compare == -1) {
    printf("La prima stringa viene prima in ordine alfabetico\n");
  }
  else {
    printf("La prima stringa viene dopo in ordine alfabetico\n");
  }

  mystrcpy(b, a);

  printf("La prima stringa è %s\n", a);
  printf("La seconda stringa è %s\n", b);

}

scomposizione.c 2/5

[
top][prev][next]
/* Scrivere un programma, definendo le opportune funzioni, per
   scomporre un numero in fattori primi */

#include <stdio.h>

#define NUMMAX 50

/* La funzione divisibile restituisce 1 se dividendo è divisibile per
   divisiore, 0 altrimenti*/
int divisibile (int dividendo, int divisore) {
  /* L'operatore modulo (%) restituisce il resto della divisione
     intera, pertanto se il resto è 0 vuol dire che il numero è
     divisibile */
  if ((dividendo % divisore) == 0) {
    return 1;
  }
  else {
    return 0;
  }
}


/* La funzione restituisce 1 se il numero è primo, 0 altrimenti */
int primo(int numero) {

  int div = 2;  

  if((numero == 1) || (numero == 0)) {
    return 1;
  }

  while(div < numero) {
    /* Se numero è divisibile per qualche numero diverso da 1 e da
       numero, vuol dire che numero NON è primo */
    if(divisibile(numero, div) == 1) {
      return 0;
    }
    else {
      div = div + 1;
    }
  }
  
  /* Se sono arrivato fin qui, vuol dire che numero non è divisibile
     per nessun div minore di numero e quindi numero è primo */
  return 1;

}

void scomponi (int numero) {
  int div = 2;
 
  while (numero != 1)  {
    /* se div è primo, controllo se numero è divisibile per div */
    if(primo(div) == 1) {
      /* Se numero è divisibile per div, vuol dire che div è un
	 fattore primo */
      if (divisibile (numero, div) == 1) {
	printf ("%d ",div);
	numero = numero / div;	
      }
      else {
	/* se non è divisibile incremento div */
	div = div + 1;
      }
    }
    else {
      /* se il numero non è primo, incremento div */
      div = div + 1;
    }
  }

  printf("\n");
}


void main()
{
  /* Dichiarazione delle variabili */
  int numero;
  int i,j;

  /* Inserimento Dati */
  printf("\n** Programma per calcolare la scomposizione in numeri primi **\n");
  printf("\nInserisci il numero da scomporre: ");
  scanf("%d",&numero);

  /* Determino la sua scomposizione in numeri primi*/
  if ( primo(numero) == 1 )
    printf("\nIl numero %d e'primo\n",numero);
  else
    {
      printf("\nLa scomposizione in numeri primi di %d e':\n\n",numero);

      scomponi (numero);  // questa chiamata si occupa di stampare i fattori primi
    }

}












pow_ricorsiva.c 3/5

[
top][prev][next]
/* Scrivere una funzione ricorsiva per calcolare la potenza intera di
   un numero */

/* L'algoritmo:

Come tutte le funzioni ricorsive, l'algoritmo si basa
sull'individuazione di un'istanza banale del problema (in questo caso
se exp è pari a 0, la potenza è 1) e la possibilità di risolvere il
problema tramite la risoluzione di problemi più semplici (base elevato
a exp può essere visto come base moltiplcato base elevato a (exp - 1)
e così via fino ad arrivare all'istanza banale */

float pow (float base, int exp) {

  /* istanza banale */
  if(exp == 0) {
    return 1;
  }
  else {
    return base * pow(base, exp - 1);
  }

}

void main() {

  float x;
  int y;

  printf("Inserisci la base: ");
  scanf("%f", &x);

  printf("Inserisci l'esponente: ");
  scanf("%d", &y);

  printf("%f elevato a %d è pari a %f\n", x, y, pow(x, y));

}

minimo_ricorsivo.c 4/5

[
top][prev][next]
/* Scrivere una funzione ricorsiva per calcolare il numero col valore
   minore tra gli elementi dell'array */

#include <stdio.h>
#define MAX_DIM 100

typedef struct {
  int dati[MAX_DIM];
  int dim;
} vettore;

/* L'algoritmo:

   L'algoritmo di risoluzione si basa sulla constatazione che il
   minimo di un array è pari al valore più basso tra il primo elemento
   dell'array e il valore più basso della coda (ovvero l'array senza il
   primo elemento). A sua volta il valore più basso della coda dell'array
   può essere visto come il minimo tra il secondo elemento dell'array
   (ovvero il primo elemento della coda dell'array) e il valore più basso
   della coda della coda (ovvero la coda senza il suo primo elemento) e
   così via, fino ad arrivare al caso banale in cui la coda è composta da
   un solo elemento e quindi il minimo della coda è quell'elemento */

/* La funzione prende come primo parametro il vettore v e come secondo
   parametro l'indice da cui inziare a scandire l'array, questo
   permette di volta in volta di indicare il punto in cui comincia la
   "coda" dell'array */
int trovaMin(vettore v, int inizio) {
  
  int minimoCoda;

  /* gestisco subito il caso banale, ovvero quando il vettore da
     scandire contiene un solo elemento, cioè inizio è pari a (v.dim -
     1), cioè è l'ultimo elemento dell'array */
  if(inizio == (v.dim - 1)) {
    /* Siccome l'array da scandire contiene un solo elemento, il
       minimo è proprio quell'elemento */
    return v.dati[inizio];
  }
  else {
    /* trovo il minimo della coda. NB: il secondo parametro è inizio +
       1 perchè inizio a scandire dalla cella successiva */
    minimoCoda = trovaMin(v, inizio + 1);
    
    /* restituisco il valore più basso tra il primo elemento della
       porzione di array che sto scandendo oppure il valore più basso
       trovato nella coda dell'array */
    if(minimoCoda < v.dati[inizio]) {
      return minimoCoda;
    }
    else {
      return v.dati[inizio];
    }
  }

}

void main() {

  vettore serie;
  int numero, i;

  serie.dim = 0;
  i = 0;

  printf("Inserisci i valori nell'array, 0 per terminare\n");

  scanf("%d%*c", &numero);

  while(numero != 0 && i < MAX_DIM) {
    serie.dati[i] = numero;
    serie.dim = serie.dim + 1;
    scanf("%d%*c", &numero);
    i = i + 1;
  }

  /* passo 0 come secondo parametro, perchè voglio scandire tutto
     l'array, quindi parto dalla cella di indice 0 */
  printf("Il valore più basso inserito è %d\n", trovaMin(serie, 0));

}

lista.c 5/5

[
top][prev][next]
/* Descrizione del tipo di dato astratto Lista con le funzioni
   principali (per maggiori informazioni si rimanda alle pagine
   198-200 del libro di testo) */

#define MAX_LUNG 100


typedef struct {
  int cont[MAX_LUNG];
  int lung;
} Lista;

/* la funzione coda restituisce una copia di l senza il primo elemento */
Lista coda(Lista l) {
  Lista temp;
  int i;

  for(i = 0; i < l.lung - 1; i = i + 1) {

    /* In pratica prendo tutti gli elementi di l e gli sposto di uno
       verso sinistra eleminando il primo elemento. Quindi il primo
       elemento di temp sarà il secondo elemento di l, il secondo
       elemento di temp sarà il terzo di l e così via */
    temp.cont[i] = l.cont[i + 1];
    temp.lung = temp.lung + 1;
  }

  return temp;

}

/* la funzione InserElem restituisce una copia di con l'elemento el
   inserito in prima posizione */
Lista InserElem(int el, Lista l) {
  Lista temp;
  int i;

  if(l.lung < MAX_LUNG) {

    for(i = 1; i < l.lung; i = i + 1) {
      /* qui mi faccio l'operazione inversa rispetto alla funzione
	 precedente ovvero sposto gli elementi di l tutti a destra,
	 ovvero il secondo elemento di temp sarà il primo di l, il
	 terzo elemento di temp sarà il secondo di l e così via */
      temp.cont[i] = l.cont[i - 1];
      temp.lung = temp.lung + 1;
    }
    /* nella prima posizione di temp che è rimasta libera posiziono
       l'elemento el */
    temp.cont[0] = el;
    temp.lung = temp.lung + 1;

  } else {
    printf ("Lista piena");
    return l;
  }
}

/* la funzione CancellaElem restituisce una copia di l in priva di
   tutte le occorrenze di el */
Lista CancellaElem(int el, Lista l) {

  Lista temp;
  if(l.lung > 0) {
    if(l.cont[0] == el) {

      /* se l'elemento da cancellare è il primo della lista, richiamo
	 la funzione CancellaElem sul resto della lista ovvero la
	 lista da restituire sarà una copia del resto della lista da
	 cui sono state cancellate tutte le occorrenze di el */
      return CancellaElem(el, coda(l)); // In origine c'erano due cancellaElem
    } else {

      /* se il primo elemento è diverso da el, allora richiamo la
	 funzione CancellaElem sul resto della lista ma a differenza
	 di prima, restituisco subito la copia di coda a cui sono
	 state cancellate tutte le occorrenze di el, ma vi aggiungo il
	 primo elemento. Prima questo non veniva aggiunto perchè
	 essendo uguale a el non doveva essere presente nella lista
	 restituita */
      return InserElem(l.cont[0], CancellaElem(el, coda(l)));
    }
  }
  return l;
}

/* la funzione RicercaElemento restituisce 1 se el è presente nella lista, 0 altrimenti */
int RicercaElemento(int el, Lista l) {

  if(l.lung > 0) {
    if(l.cont[0] == el) {
      /* se l'elemento è il primo della lista restituisco true */
      return 1;
    } else {
      /* altrimenti richiamo la funzione sul resto della lista ovvero
	 su coda(l) */
      return RicercaElemento(el, coda(l));
    }
  } else {
    /* se la lista ha lunghezza 0, vuol dire che l'elemento non
       esiste */
    return 0;
  }

}

/* la funzione Ordina restituisce una copia ordinata della lista,
   priva di tutti i doppioni. NB: si suppone di avere a disposizione
   la funzione min, definita nel precedente esercizio */
Lista Ordina(Lista l) {

  int minimo;

  if(l.lung > 1) {
    /* trovo l'elemento più piccolo della lista e lo inserisco in
       testa e poi richiamo la funzione Ordina sul resto della lista,
       inserendo in testa di volta in volta i minimi trovati */
    minimo = min(l);
    return InserElem(minimo, Ordina(CancellaElem(minimo, l)));
  }
  return l;

}

Generated by GNU enscript 1.6.4.