01-vocali.c 1/7

[
top][prev][next]
/* Si scriva un programma che legga una serie di caratteri da tastiera
   (uno alla volta), li inserisca in una stringa e stampi solamente le
   vocali */

#include <stdio.h>

/* dichiaro una costante di 10 caratteri */
#define N 10

void main() {


  char frase[N];
  int i = 0;
  char ch;

  /* leggo un carattere scartando il carattere di invio */
  scanf("%c%*c", &ch);

  /* continuo a leggere caratteri fin quando l'utente non inserisce
     uno spazio o fin quando l'array è pieno. NB: la condizione è
     i<N-1 e non i<N perchè devo sempre lasciare almeno uno spazio
     vuoto per inseririci il tappo, cioè '\0' */
  while(i < N-1 && ch !=' ') {
    frase[i] = ch;
    scanf("%c%*c", &ch);
    i = i + 1;
  }

  /* inserisco il tappo immediatamente dopo l'ultimo carattere letto */
  frase[i] = '\0';

  i = 0;
  printf("\nLe vocali sono: ");

  /* scorro tutta la lista fino ad incontrare il tappo e per ogni
     carattere verifico se è una vocale o meno */
  while(frase[i] !='\0') {
    if(frase[i] == 'a' || frase[i] == 'e' || frase[i] == 'i' || frase[i] == 'o'  || frase[i] == 'u') {
      printf("%c ", frase[i]);
    }
    i = i + 1;
  }
  printf("\n");

}

02-search.c 2/7

[
top][prev][next]
/* Si scriva un programma che acquisica 10 interi da tastiera, quindi
   chieda all'utente l'inserimento di un ulteriore numero e verifichi
   se questo è presente o meno nella sequenza dei numeri inseriti */

#include <stdio.h>

void main() {

  int array[10];
  int i, daCercare, trovato;

  for(i = 0; i < 10; i = i + 1) {
    printf("Inserisci un numero ");
    scanf("%d", &array[i]);
  }
  printf("Inserisci il numero che vuoi cercare ");
  scanf("%d", &daCercare);
  
  i = 0;
  /* la variabile trovato mi serve per rendermi conto se il numero
     richiesto è presente nell'array. La variabile infatti assume
     valore 1 solamente quando viene trovato il numero e quindi
     inserendola nella condizione del while posso interrompere il
     ciclo se trovo l'elemento */
  trovato = 0;
  while(i < 10 && trovato == 0) {
    if(array[i] == daCercare) {
      trovato = 1;
      }
    i = i + 1;
  }
  /* questo if è necessario per capire se sono uscito dal ciclo perchè
     ho trovato l'elemento (e quindi trovato = 1) oppure perchè ho
     scandito tutta la lista senza trovare l'elemento (e quindi
     trovato è rimasto a 0) */
  if(trovato) {
    printf("trovato");
    }
  else {
    printf("NON trovato");
    }
  
  printf("\n");
    
}

03-sort.c 3/7

[
top][prev][next]
/* Il programma dopo aver acquisito 10 interi li ordina e stampa il risultato. */

#include <stdio.h>

#define N 10



void main() {

  int i = 0, j = 0;
  int temp;


  int array[N];

  for(i=0; i < N; i = i + 1) {
    printf("Inserisci un valore ");
    scanf("%d", &array[i]);
  }


  /* L'algoritmo utilizzato prende il nome di Swap Sort. Il
     funzionamento è il seguente: alla prima iterazione si calcola il
     minimo valore presente nell'array e lo si inserisce nella prima
     posizione, quindi alla successiva iterazione si calcola il minimo
     del nuovo array che si ottiene considerando tutte le celle dell'array
     esclusa la prima. Il valore minimo trovato viene inserito in
     seconda posizione, quindi si considera il minimo dell' array
     ottenuto escludendo le prime due celle e lo si inserisce in terza
     posizione e così via */
  for(i=0; i < N; i = i + 1) {
    /*Si noti che questo secondo ciclo inizia sempre dalla posizione
      succesiva a 1 restringendo così l'array su cui viene ricercato
      il minimo */
    for(j= i+ 1; j < N; j = j+1) {
      if(array[i] > array[j]) {
	temp = array[i];
	array[i] = array[j];
	array[j] = temp;
      }
    }
  }

  printf("L'array ordinato è ");
  for(i= 0; i < N; i = i + 1) {
    printf("%d ", array[i]);
  }
  
  printf("\n");

}

04-palindroma.c 4/7

[
top][prev][next]
/* Si scriva un programma che acquisica da tastiera una parola e
   determini se tale parola è palindroma, ossia leggibile nello stesso
   modo da destra a sinistra e viceversa (es. OSSESSO) */

#include <stdio.h>

#define MAX 100

/* definisco un nuovo tipo di dato boolean che può assumere i valori
   falso o vero. NB: falso e vero non vanno scritti tra virgolette
   perchè non sono stringhe ma rappresentano i possibili valori che
   possono essere assegnati alle variabili di tipo boolean */
typedef enum {
  falso, vero
} boolean;

void main() {

  char stringa[100];
  int size, mid, i;
  boolean flag = vero;


  printf("Inserisci una stringa ");
  gets(stringa);

  /* Questo ciclo serve per determinare la lunghezza della
     stringa. Alla fine del ciclo size sarà l'indice del carattere
     '\0' e quindi rapprensenta il numero di caratteri inseriti
     dall'utente escluso il '\0' (si ricordi che gli indici negli
     array partono da zero !!) */
  size = 0;
  while(stringa[size] != '\0') {
    size = size + 1;
  }

  mid = size/2;

  i = 0;
  /* Continuo a scandire la stringa fin quando non arrivo a metà o fin
     quando trovo un carattere diverso dal suo corrispettivo
     (primo-ultimo, secondo-penultimo, terzo-terzultimo, ecc). Infatti
     in tal caso la parola non sarebbe più palindroma e la variabile
     palindroma diventa pari a falso e il ciclo si interrompe */
  while(i < mid && flag == vero) {
    if(stringa[i] != stringa[size-1-i]) {
      flag = falso;
    }
    i = i + 1;
  }


/* Questo test mi serve per capire il motivo per cui sono uscito dal
   ciclo, analizzando il valore della variabile palindroma */   
  if(flag == vero) { 
    printf("Palindroma"); 
  } 
  else { 
    printf("Non palindroma");
  }
  
  printf("\n");
    
}
    

05-vector.c 5/7

[
top][prev][next]
/* Scrivere un programma nel quale viene lette progressivamente una
   sequenza di interi e memorizzata nell'array mano a mano. La
   quantità di dati letta non è nota a priori ma è al massimo 100 e se
   il numero letto è -1 questo viene interpretato come non valido e
   segnala la fine immissione dati. Quindi viene letto un ulteriore
   numero da tastiera e successivamente vengono stampati solo gli
   elementi dell'array che sono maggiori di questo numero. Si utlizzi
   una struct per contenere l'array */

#include <stdio.h>

#define MAX 10


/* Il campo dati rappresenta l'array vero e proprio mentre il campo
   dim rappresena la dimensione effettiva dell'array, ossia il numero
   di interi letti da tastiera */
typedef struct  {
  int dati[MAX];
  int dim;
} vector;



void main() {

  vector v;
  int num, i, cont;

  /* Questa inizializzazione è fondamentale perchè sta ad indicare che
     l'array è vuoto, ovvero la sua dimensione effettiva è pari a
     zero. */
  v.dim = 0;
  i = 0;
  cont = 0;

  printf("Inserisci un numero ");
  scanf("%d", &num);

  while(i < MAX && num !=-1) {
    /* NB: ogni qualvolta inserisco un elemento in un'array devo
       ricordarmi di incrementare anche la sua dimensione effettiva
       (v.dim) */
    v.dati[i] = num;
    v.dim = v.dim + 1;
    printf("Inserisci un numero ");
    scanf("%d", &num);
    i = i + 1;
  }

  printf("Inserisci il valore di filtro ");

  scanf("%d", &num);

  /*L'array non viene scandito fino a MAX ma solamente fino a v.dim,
    cioè fino alla sua dimensione effettiva */
  for(i=0; i < v.dim; i = i + 1) {
    if(v.dati[i] > num) {
      printf("%d ", v.dati[i]);
    }
  }
}

06-calciatore.c 6/7

[
top][prev][next]
/* Scrivere un programma per gestire una base dati di calciatori. In
   particolare si dovrà memorizzare il nome del calciatore, la squadra
   di appartenenza, il ruolo e il numero di reti segnati. Una volta
   inseriti i dati si deve visualizzare il nome del difensore che ha
   segnato più reti */

#include <stdio.h>

#define MAX 100

typedef enum {
  portiere, difensore, centrocampista, attaccante
} tipoRuolo;

typedef struct {
  char nome[MAX];
  char squadra[MAX];
  tipoRuolo ruolo;
  int reti;
} calciatore;

void main() {

  calciatore lista[10];
  int i, max_num, max_index;
  tipoRuolo r;

  printf("Inserisci i calciatori ");

  for(i=0; i < 2; i = i + 1) {
    printf("Nome ");
    gets(lista[i].nome);

    printf("Squadra ");
    gets(lista[i].squadra);

    /* La scanf gestisce solo i tipi di dato primitivio (int, float,
       char), quindi per leggere un tipo di dato enum bisogna leggere
       un numero e poi tramite una serie di if assegnare alla
       variabile lista[i].ruolo il valore corretto */
    printf("Inserisci il ruolo (0) portiere (1) difensore (2) cantrocampista (3) attaccante ");
    scanf("%d", &r);

    if(r==0) {
      lista[i].ruolo = portiere;
    }
    else if(r==1) {
      lista[i].ruolo = difensore;
    }
    else if(r==2) {
      lista[i].ruolo = centrocampista;
    }
    else if(r==3) {
      lista[i].ruolo = attaccante;
    }

    printf("Reti ");
    /* NB occorre usare %c perchè altrimenti la gets all'iterazione
       successiva prende il carattere invio come stringa */
    scanf("%d%*c", &lista[i].reti);

  }

  /* max_num conterrà il valore massimo di reti segnate da un
     difensore mentre max_index conterrà la posizione nell'array del
     calciatore che ha segnato il numero massimo di reti. max_num
     viene inizializzato a -1 perchè sono sicuro che -1 verrà
     sicuramente superato */
  max_num = -1;
  max_index = -1; /*l'inizializzazione di max_index non è strettamente
		    necessaria */

  for(i=0; i < 2; i = i +1) {
    /* Verifico se si tratta di un difensore */
    if(lista[i].ruolo == difensore) {
      if(lista[i].reti > max_num) {
	max_num = lista[i].reti;
	max_index = i;
      }
    }   
  }
  
  printf("Il difensore che ha segnato di più è %s, gioca nel %s e ha segnato %d reti\n", lista[max_index].nome, lista[max_index].squadra, lista[max_index].reti);

}

07-media.c 7/7

[
top][prev][next]
/* Scrivere un programma che legga da tastiera una sequenza di 10
   interi e che a partire dal primo numero introdotto stampi ogni
   volta la media di tutti i numeri introdotti. Si usi la struttura
   data vector introdotto nell'esercizio 5 */

#include <stdio.h>

#define MAX 10


/* Il campo dati rappresenta l'array vero e proprio mentre il campo
   dim rappresena la dimensione effettiva dell'array, ossia il numero
   di interi letti da tastiera */
typedef struct  {
  int dati[MAX];
  int dim;
} vector;

void main() {

  vector v;
  int i;
  float somma;

  v.dim = 0;
  somma = 0;

  /* Leggo i dati (uso un ciclo for perchè devo leggere un numero
     fisso di interi */
  for(i=0; i < MAX; i = i + 1) {
    printf("Inserisci un numero ");
    scanf("%d", &v.dati[i]);
    v.dim = v.dim + 1;
    somma = somma + v.dati[i];
    printf("\nLa media progressiva è %f\n", somma/v.dim);

  }

}


Generated by GNU enscript 1.6.3.