01-carte.c 1/4

[
top][prev][next]
/* Definire una struttura MANO che contenga il seme di briscola e le
carte giocate da quattro giocatori. Scrivere un programma che chieda
di inserire allutente tutti i dati necessari e disegni sullo schermo
la carta che vince la mano.  Ricordate che a briscola lordine delle
carte e il seguente: 1 > 3 > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 2 */

#include <stdio.h>

// Definisce una struttura che descrive una carta da gioco
typedef struct{
  char seme;    	// Prima lettera del seme della carta
  int valore;		// Valore della carta
} carta;

// Definisce una struttura che descrive una giocata a briscola
typedef struct{
  char briscola;		// Prima lettera del seme di briscola
  carta giocatore[4];	// Array che contiene le carte giocate dai 4 giocatori
} mano;


void main()
{
  mano m;
  int i = 0;			// Contatore usato per i cicli FOR

  int max = 0; // la carta col valore più alto
  int max_i;  // l'indice del giocatore che ha giocato la carta più alta

  // Chiede all'utente di inserire il seme di briscola
  // continua a richiedere l'inserimento finche' il carattere inserito e'
  // diverso dai quattro permessi (b,s,c,d)
  do
    {
      printf("Inserisci il seme della briscola (s=spade,b=bastoni,c=coppe,d=denari) :");
      scanf("%c%*c",&m.briscola);
    }while(m.briscola!='b' && m.briscola!='s' && m.briscola!='c' &&m.briscola!='d');

  // Ciclo che chiede all'utente di inserire le carte giocate dai 4 giocatori
  for(i=0; i<4; i++)
    {
      // Chiede l'inserimento del seme....
      printf("\nGiocatore n. %i\n",i);
      do
	{
	  printf("Inserisci il seme (s=spade,b=bastoni,c=coppe,d=denari) :");
	  scanf("%c%*c",&m.giocatore[i].seme);
	}while(m.giocatore[i].seme!='b' && m.giocatore[i].seme!='s' &&
	       m.giocatore[i].seme!='c' && m.giocatore[i].seme!='d');

      // Chiede l'inserimento del valore della carta e continua
      // a richiederlo fino a che non si inserisce un valore compreso fra 0 e 10
      do
	{
	  printf("Inserisci il valore della carta (1-10) :");
	  scanf("%d%*c",&m.giocatore[i].valore);

	} while(m.giocatore[i].valore > 10 || m.giocatore[i].valore < 0);

      // Se la carta e' un 1 allora imposta il valore a 15
      // (l'asso a briscola e' la carta piu alta)
      if(m.giocatore[i].valore == 1) {
	m.giocatore[i].valore = 15;
      }
      // Se la carta e' un 3 allora imposta il valore a 13
      // (il 3 a briscola e' superiore al 10)
      else if(m.giocatore[i].valore == 3) {
	m.giocatore[i].valore = 13;
      }
      // Se il seme della carta giocata e' uguale al seme della briscola
      // somma 1000 al valore fin qui calcolato
      if(m.giocatore[i].seme == m.briscola) {
	m.giocatore[i].valore = m.giocatore[i].valore + 1000;
      }
      // Se il seme della carta giocata e' uguale al primo seme
      // giocato somma 100 al valore fin qui calcolato (se nessuno
      // gioca la briscola vince la carte più alta che ha seme pari al
      // primo seme giocato)
      if(m.giocatore[i].seme == m.giocatore[0].seme) {
	m.giocatore[i].valore = m.giocatore[i].valore + 100;
      }

      // Adesso che ho opportunamente sistemato i valori, trovo il
      // massimo col solito sistema: confronto ogni valore con max e
      // se è maggiore, max diventa pari al nuovo valore
      if(m.giocatore[i].valore > max) {
	max = m.giocatore[i].valore;
	max_i = i;   // Memorizzo l'indice del giocatore
      }

    }

  // Risistemo i valori in modo da fargli assumere i valori originari
  // (l'asso vale 1 non 15)
  if(m.giocatore[max_i].seme == m.briscola) {
    m.giocatore[max_i].valore = m.giocatore[max_i].valore - 1000;
  }
  if(m.giocatore[max_i].seme == m.giocatore[0].seme) {
    m.giocatore[max_i].valore = m.giocatore[max_i].valore - 100;
  }
  if(m.giocatore[max_i].valore == 15) {
    m.giocatore[max_i].valore = 1;
  }
  else if(m.giocatore[max_i].valore == 13) {
    m.giocatore[max_i].valore = 3;
  }

  // Stampa la carta del vincitore
  printf("\n########");
  printf("\n#      #");
  printf("\n#      #");
  printf("\n#  %d%c  #",m.giocatore[max_i].valore,m.giocatore[max_i].seme);
  printf("\n#      #");
  printf("\n#      #");
  printf("\n########");
  printf("\n");

}

02-normalizza.c 2/4

[
top][prev][next]
/* Si scriva un programma per normalizzare i voti degli studenti. Per
   normalizzazione si intende il processo per cui i voti sono
   rapportati al voto massimo. Si utilizzi una struttura dati Studente
   per memorizzare matricola e voto e una struttura dati ListaStudenti per
   memorizzare un numero arbitrario di studenti (comunque minore di 200) */


#include <stdio.h>
#define MAX 200

typedef struct {
  int matricola;
  float voto; /* uso float perchè gli studenti avranno un voto normalizzato */
} Studente;

typedef struct {
  Studente lista[MAX]; /* l'array vero e proprio */
  int dim; /* la sua dimensione effettiva */
} ListaStudenti;


void main() {

  ListaStudenti corso;
  int i, m, v, max_voto;

  /* corso inizialmente è vuoto e oertanto la sua dimensione effettiva
     è pari a zero */
  corso.dim = 0;
  /* Tutti i voti sono maggiori di -1 e quindi inizializzo max_voto a -1 */
  max_voto = -1;

  printf("Inserisci la matricola ");
  scanf("%d", &m);
 
  /* Acquisico i dati degli studenti. Mi interrompo se la matricola è
     pari a -1 o se ho riempito tutto l'array */
  i = 0;
  while (i < MAX && m != -1) {
    printf("Inserisci il voto ");
    scanf("%d", &v);   
    corso.lista[i].matricola = m;
    corso.lista[i].voto = v;
    /* Trovo max_voto sempre col solito sistema: aggiorno max se
       incontro un valore che gli è superiore */
    if(corso.lista[i].voto > max_voto) {
      max_voto = corso.lista[i].voto;
    }
    corso.dim = corso.dim + 1;
    i = i + 1;
    printf("Inserisci la matricola ");
    scanf("%d", &m);
  }

  /* Adesso scandisco tutto il vettore e man mano normalizzo i voti
     rispetti a max_voto. NB: il ciclo for viene eseguito solo fino a
     corso.dim cioè fino alla dimensione effettiva del mio array */
  for(i=0; i < corso.dim; i = i + 1) {
    corso.lista[i].voto = (corso.lista[i].voto / max_voto ) * 30;
  }

  printf("I voti normalizzati sono: \n");

  for(i=0;  i < corso.dim; i = i + 1) {
    printf("Matricola %f", corso.lista[i].matricola);
    printf("      Voto: %f\n", corso.lista[i].voto);
  }
}

03-date.c 3/4

[
top][prev][next]
/* Si scriva un programma che calcoli i giorni trascorsi fra due date,
   trascurando gli anni bisestili */

#include <stdio.h>

typedef struct
{
  int giorno;
  int  mese;
  int anno;
} Data;

int main() {
  Data inizio;  
  Data fine;
  
  /* tutti i delta sono in giorni */
  int deltaAnni = 0; 
  int deltaMesi = 0;
  int deltaGiorni = 0;
  int segno = 1;
  int i;
  
  /* leggo la prima data */
  printf("Inserisci il giorno ");
  scanf("%d", &inizio.giorno);
  printf("Inserisci il mese ");
  scanf("%d", &inizio.mese);
  printf("Inserisci l'anno ");
  scanf("%d", &inizio.anno);

  /* leggo la seconda data */
  printf("Inserisci il giorno ");
  scanf("%d", &fine.giorno);
  printf("Inserisci il mese ");
  scanf("%d", &fine.mese);
  printf("Inserisci l'anno ");
  scanf("%d", &fine.anno);

  /* caclolo quanti anni sono passati */
  deltaAnni = (fine.anno - inizio.anno)*365;

  /* se fine mese è minore di inzio mese nel ciclo for dovrò
     decrementare invece di incrementare */
  if (fine.mese < inizio.mese){
    segno = -1;
  }
  
  /* calcolo quanti mesi sono passati */
  for (i=inizio.mese; i!=fine.mese; i=i+segno){
    
    if((i == 4) || (i == 6) || (i == 9) || (i == 11)) { /* Questi sono i mesi con trenta giorni */
      deltaMesi = deltaMesi + segno*30;
    }
    else if(i == 2) { /* febbraio */
      deltaMesi = deltaMesi + segno*28;
    }
    else { /* tutti gli altri mesi */
      deltaMesi = deltaMesi + segno*31;
    }

  }

  deltaGiorni = fine.giorno - inizio.giorno;
  
  printf("La differenza e` di %d giorni\n", deltaAnni+deltaMesi+deltaGiorni);
}

04-razionali.c 4/4

[
top][prev][next]
/* Moltiplicare 2 numeri razionali (definiti da numeratore e
    denominatore) semplificando il risultato

   1. assegno il valore agli operandi
  
   2. ottengo il numeratore del risultato
 
   3. ottengo il denominatore del risultato

   4. semplifico
    
      4.1 a partire dal minimo fra i valori assoluti del numeratore e
      denominatore del risultato
  
      4.2 provo ciclicamente tutti i valori per cercare il MCD

      4.3 fintanto che non arrivo a 1 e non ho trovato l'MCD

   5. comunico il risultato */

#include <stdio.h>
#include <stdlib.h> /* per la funzione abs() */

typedef struct 
{
  int numeratore;
  int denominatore;
} Razionale;

typedef enum {falso, vero} boolean;

main()
{
  Razionale p,q,r;
  int min,i;
  boolean trovato = falso;
  
  printf("\nDammi il 1°numeratore: ");
  scanf("%d", &p.numeratore);
  printf("Dammi il 1°denominatore: ");
  scanf("%d", &p.denominatore);
  
  printf("Dammi il 2°numeratore: ");
  scanf("%d", &q.numeratore);  
  printf("Dammi il 2°denominatore: ");
  scanf("%d", &q.denominatore);

  r.numeratore = p.numeratore * q.numeratore;
  r.denominatore = p.denominatore * q.denominatore;
  
  if(abs(r.numeratore) < abs(r.denominatore)){
    min = abs(r.numeratore);
  }
  else{
    min = abs(r.denominatore);
  }
  
  i = min;
  while (i > 1 && trovato == 0){
    if (r.numeratore % i == 0  /* cioè se r.numeratore è divisibile per i */
        && r.denominatore % i == 0){
      r.numeratore = r.numeratore / i;
      r.denominatore = r.denominatore / i;
      trovato = vero;
    }
    i = i - 1;
  }
  
  printf("Il risultato è %d / %d\n", r.numeratore, r.denominatore);

}

Generated by GNU enscript 1.6.3.