ricorsione1.c 1/7

[
top][prev][next]
#include <stdio.h>

int RIC(int x) {
  int y;

  if(x <=0) {
    return x;
  }
  else {
    y = RIC(x - 2);
    printf("%d\n", y + 1);
    return y;
  }
}

void main() {
  int n;

  printf("inserisci un intero: ");
  scanf("%d", &n);
  printf("%d\n", RIC(n));

}

ricorsione2.c 2/7

[
top][prev][next]
#include <stdio.h>

int fun(int n) {
  int result = 0;
  if(n == 1) {
    return 1;
  }
  else {
    if(n % 2 == 0) {
      result = fun(n - 1);
    }
    else {
      result = n + fun(n - 1);
    }
    return result;
  }
}

void main() {
  printf("%d\n", fun(10));
}

ricorsione3.c 3/7

[
top][prev][next]
#include <stdio.h>

int s(int a[], int b) {
  if (b < 1) {
    return 0;
  }
  if(b == 1) {
    return a[0];
  }
  return a[b - 1] + s(a, b - 1);
}

void main() {

  /* Inizializzo l'array con i valori 1,2,5,4,10 */
  int v[] = {1, 2, 5, 4, 10};

  printf("%d\n", s(v, 4));
}

ricorsione4.c 4/7

[
top][prev][next]
#include <stdio.h>

int funz(int dim, int s[]) {
  int n;
  printf("chiamata la funzione funz\n");
  if(dim < 0) {
    return 0;
  }
  n = s[dim] + funz(dim - 1, s);
  return n;
}

void main() {
  int i, j, tot;
  int s[100];

  printf("Inserisci un numero intero positivo: ");
  scanf("%d%*c", &i);

  if(i < 99) {
    for(j = 0; j < i; j = j + 1) {
       printf("Inserisci un numero intero: ");
       scanf("%d%*c", &s[j]);
    }
    tot = funz(j - 1, s);
    printf("%d\n", tot);
  }
}

set.c 5/7

[
top][prev][next]
#include <stdio.h>
#include <malloc.h>

typedef struct elem_set {
  int dato;
  struct elem_set* next;
} elem_set;


elem_set* creaInsieme() {
  return NULL;
}

/* la funzione inserisciElemento inserisce el in coda dopo aver
   verificato che non esiste già un altro elemento col medesimo
   valore */
elem_set* inserisciElemento(elem_set* s, int el){
  elem_set* corr, *nuovo;
  int trovato;

  nuovo = (elem_set*)malloc(sizeof(elem_set));
  nuovo->dato = el;

  /* inserisco in coda quindi next sarà NULL */
  nuovo->next = NULL;

  if(s == NULL) {
    s = nuovo;
    return s;
  }
  else {
    /* all'inzio corr punta al primo elemento della lista cioè s */
    corr = s;
    trovato = 0;
    /* scorro la lista fin quando arrivo in fondo oppure trovo l'elemento */
    while(corr->next != NULL && trovato == 0) {
      if(corr->dato == el) {
	trovato = 1;
      }
      else {
	corr = corr->next;
      }
    }

    /* se non ho trovato l'elemento (cioè trovato vale zero) vuol dire
       che sono arrivato all'ultimo elemento. Se anche questo è diverso da el, posso inserire
       l'elemento, altrimenti non faccio nulla */
    if(trovato == 0 && corr->dato != el) {
      corr->next = nuovo;
    }
    return s;

  }
}

elem_set* cancellaElemento(elem_set* s, int el) {

  elem_set* corr, *prec;
  int trovato;

  /* se la lista è vuota, non faccio nulla e restituisco s */
  if(s == NULL) {
    return s;
  }
  else {
    /* Scorro la lista fin quando non trovo l'elemento oppure arrivo in fondo*/
    corr = s;
    trovato = 0;
    while(corr->next != NULL && trovato == 0) {
      if(corr->dato == el) {
	trovato = 1;
      }
      else {
	prec = corr;
	corr = corr->next;
      }
    }
    /* Se ho trovato l'elemento lo cancello */
    if(trovato == 1) {
      /* controllo se è il primo elemento della lista (cioè se corr è pari a s) */
      if(corr == s) {
	s = s->next;
	free(corr);
      }
      else {
	/* Se sono arrivato fin qui vuol dire che ho trovato
	   l'elemento e che non si trova in prima posizione (e quindi
	   prec ha un valore sensato) e quindi mi comporto come al
	   solito (vedi esercitazione precedente sulle liste) */
	prec->next = corr->next;
	free(corr);
      }
    }
    else {
      /* se non l'ho trovato, potrebbe essere in ultima posizione (che
	 non ho ancora esaminato) e quindi mi comporto come sopra */
      if(corr->dato == el) {
	prec->next = corr->next;
	free(corr);
      }
    }
    return s;
  }
}

/* La funzione appartiene restituisce 1 se l'elemento el è presente
   nell'insieme, 0 altrimenti */
int appartiene(elem_set *s, int el) {
  elem_set *corr;
  corr = s;

  while(corr != NULL) {
    if(corr->dato == el) {
      /* Se ho trovato l'elemento restituisco 1 e termino la funzione */
      return 1;
    } 
    else {
      /* incremento corr */
      corr = corr->next;
    }
  }
  /* se sono arrivato fin qui vuol dire che ho esaminato tutto
     l'insieme senza trovare l'elemento desiderato quindi
     restituisco 0 */
  return 0;
}

elem_set *unione(elem_set *s1, elem_set *s2) {
  elem_set *temp, *corr;

  temp = creaInsieme();
  corr = s1;

  /* Per realizzare correttamente l'operazione di unione è sufficiente
     inserire nell'insieme temp, tutti gli elementi di s1 e tutti
     quelli di s2. Infatti la procedura inserisciElemento esegue già
     il controllo per evitare doppioni */

  while(corr != NULL){
    temp = inserisciElemento(temp, corr->dato);
    corr = corr->next;
  }

  corr = s2;
  while(corr != NULL){
    temp = inserisciElemento(temp, corr->dato);
    corr = corr->next;
  }
  return temp;
}

elem_set* intersezione(elem_set* s1, elem_set* s2) {
  elem_set * corr, *temp;

  temp = creaInsieme();

  corr = s1;
  /*scorro tutto l'insieme s1 e per ogni suo elemento qualora fosse
    presente anche in s2 lo inserisco in temp */
  while(corr != NULL) {
    if(appartiene(s2, corr->dato) == 1) {
      temp = inserisciElemento(temp, corr->dato);
    }
    corr = corr->next;
  }
  return temp;
}


void stampaInsieme(elem_set* s) {
  elem_set *corr;

  corr = s;
  while(corr != NULL) {
    printf("%d ", corr->dato);
    corr = corr->next;
  }

}


void main() {

  elem_set* insieme1, *insieme2;
  int num;


  insieme1 = creaInsieme();
  insieme2 = creaInsieme(); 

  printf("Inserisci gli elementi del primo insieme (0 per terminare): ");
  scanf("%d", &num);

  while(num != 0) {
    insieme1 = inserisciElemento(insieme1, num);
    printf("Inserisci gli elementi del primo insieme (0 per terminare): ");
    scanf("%d", &num);
  }

  printf("Inserisci gli elementi del secondo insieme (0 per terminare): ");
  scanf("%d", &num);

  while(num != 0) {
    insieme2 = inserisciElemento(insieme2, num);
    printf("Inserisci gli elementi del secondo insieme (0 per terminare): ");
    scanf("%d", &num);
  }

  printf("Insieme 1: ");
  stampaInsieme(insieme1);
  printf("\nInsieme 2: ");
  stampaInsieme(insieme2);
  printf("\n");

  printf("Inserisci un elemento da cancellare nel primo insieme: ");
  scanf("%d", &num);
  insieme1 = cancellaElemento(insieme1, num);
  printf("Insieme 1: ");
  stampaInsieme(insieme1);
  printf("\nInsieme 2: ");
  stampaInsieme(insieme2);
  printf("\n");

  printf("Unione: ");
  stampaInsieme(unione(insieme1, insieme2));
  printf("\n");

  printf("Intersezione: ");
  stampaInsieme(intersezione(insieme1, insieme2));
  printf("\n");


}

polinomio.c 6/7

[
top][prev][next]
/* Si utilizza una lista collegata a puntatori per rappresentare un
   polinomio a coefficienti interi di una variabile intera. Definire
   mediante un'opportuna dichiarazione di tipo, una struttura di nome
   ELEM_POLINOMIO con tre campi di nome co, exp (di tipo intero) e
   next (di tipo puntatore) che corrisponda agli elementi della lista.

   Si implementi una funzione per il calcolo delle potenze intere
   positive di numeri interi e una funzione che ricevendo come
   parametri un puntatore al primo elemento della lista e un valore
   per la variabile x, calcoli e restituisca il valore del
   polinomio */

#include <stdio.h>

typedef struct elem_polinomio {
  int co;
  int exp;
  struct elem_polinomio* next;
} elem_polinomio;

int potenza(int base, int exp) {
  int risultato = 1;

  while(exp > 0) {
    risultato = risultato * base;
    exp = exp - 1; /* NB: siccome exp è passato per copia, ogni
		      modifica all'interno della funzione rimane
		      confinata alla funzione stessa */
  }

  return risultato;
}

int valutaPol(elem_polinomio* p, int x) {
  elem_polinomio* corr;
  int valore = 0;

  while(corr != NULL) {
    valore = valore + corr->co * potenza(x, corr->exp);
    corr = corr->next;
  }
  return valore;
}


occorrenze.c 7/7

[
top][prev][next]
/*
  Scrivere un programma che conta le occorrenze di una stringa x in un
  testo t, ponendo il codice che effettua il conteggio in una funzione

*/


#include <stdio.h>

#define MAX 200

typedef enum {false, true} boolean;

/* Definizione della funzione di conteggio */
int conta (char *stringa, char *testo) {
  int ris = 0;
  int uguali = 1;
  int i, j;
  printf(testo);
  for (i = 0; testo[i] != '\0'; i = i + 1) {
    uguali = 1;
    if (testo[i] == stringa[0]) { 
      /* confronto tutti i caratteri della stringa dal secondo in poi */
      j = 1; 
      while(stringa[j] != '\0' && uguali){
        if (testo[i + j] != stringa[j]) 
          uguali = 0;
	j = j + 1;
      }   
      /* se sono uguali, aumento il totale */
      if (uguali == 1) {
	ris = ris + 1;
      }
    }  
  }
  /* ritorna il risultato */
  return ris;
}


void main() {
  char x[MAX], t[MAX];
  int tot;

  printf("Programma ricerca stringa. Dammi il testo:");
  gets(t);
  printf("\nDammi la stringa da cercare nel testo:");
  gets(x);

  /* ricerca e conteggio */
  tot = conta(x,t);

  /* stampa risultato */
  printf("\nIl numero totale di occorrenze e': %d\n", tot);
}


Generated by GNU enscript 1.6.4.