mastermind.c 1/2

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

// **************************************************************************
// STRUTTURE DATI
// **************************************************************************

// Dimensione massima dell'array di cifre
#define MAX 10

// Struttura Numero.  Contiene un array di cifre ed un contatore che
// indica quante cifre sono contenute nell'array
typedef struct {
  int cifre[MAX];
  int numcifre;
} Numero;

// Definiesce il tipo boolean
typedef enum {true, false} boolean;


// **************************************************************************
// FUNZIONI
// **************************************************************************

/*
  Genera un numero casuale con tutte le cifre diverse fra loro.
  Riceve come parametro il numero di cifre che dovra' avere il numero
*/
Numero generaNumero(int cifre)
{
  int i,j;   // Contatori usati per i cicli
  int temp;   // Contiene la nuova cifra sorteggiata
  boolean valido; // E' true se la cifra appena sorteggiata e' valida,
		  // cioe' se e' diversa da tutte le altre
  Numero n;   // Conterra' il numero che viene generato

  // Inizializza tutte le cifre a -1
  for(i=0; i<cifre; i++) n.cifre[i]=-1;

  // Il numero di cifre e' pari al valore passato come parametro
  n.numcifre = cifre;

  // Fornisce il seme al generatore di numeri casuali
  srand(time(NULL));

  // Sorteggia le cifre
  i=0;
  while(i<cifre)
    {
      // Genera un numero casuale tra 0 e 9
      temp = rand()%10;

      // Cerca se esiste una cifra uguale
      valido = true;
      for(j=i; j>=0; j--)
	{
	  if(temp == n.cifre[j]) valido = false;
	}
      // Se non ne trova di uguali...
      if(valido==true)
	{
	  // Memorizza la cifra nel numero
	  n.cifre[i]=temp;
	  // Incrementa il contatore
	  i++;
	}
    }

  // Ritorna il numero appena generato
  return n;
}

/*
  Legge un numero da console e lo ritorna la chiamante Riceve come
  parametro il numero di cifre da leggere
*/
Numero leggiNumero(int cifre)
{
  int i;
  Numero temp;

  // Il numero di cifre e' pari al valore passato come parametro
  temp.numcifre = cifre;

  // Legge le cifre
  printf("\n");
  for(i=0; i<cifre; i++)
    {
      printf("Inserisci la cifra num. %d = ",i+1);
      scanf("%d",&temp.cifre[i]);
    }

  // Ritorna il numero letto al chiamante
  return temp;
}

/*
  Calcola qunante cifre sono state indovinate.  Parametri: segreto -
  numero segreto che deve essere indovinato tentativo - contiene il
  tentativo del giocatore ok - al termine della funzione conterra' il
  numero di cifre indovinate quasi - conterra' le cifre indovinate ma
  nella posizione sbagliata
*/
void calcola(Numero segreto, Numero tentativo, int* ok, int* quasi)
{
  int i,j;

  // Azzera i contatori
  *ok = 0;
  *quasi = 0;

  // Scorre le cifre del tentativo
  for(i=0; i<tentativo.numcifre; i++)
    {
      // Scorre le cifre del numero segreto
      for(j=0; j<segreto.numcifre; j++)
	{
	  // Se le due cifre coincidono...
	  if(tentativo.cifre[i]==segreto.cifre[j])
	    {
	      //...e sono nella stessa posizione allora incrementa ok
	      if(i==j) (*ok)++;
	      //...e sonon in posizioni diverse allora incrementa
	      //quasi
	      else (*quasi)++;
	    }
	}
    }
}

// **************************************************************************
// MAIN
// **************************************************************************

void main()
{
  int i,j,o,q;
  int cifre;
  int ntent;
  boolean indovinato;
  Numero segreto;
  Numero tentativo;

  // Chiede all'utente quante cifre deve avere il numero segreto
  do{
    printf("Di quante cifre deve essere composto il numero (2-6)?");
    scanf("%d",&cifre);
  }while(cifre<2 || cifre>6);

  // Chiede all'utente quanti tentativi vuole avere per indovinarlo
  do{
    printf("Quanti tentativi vuoi avere a disposizione (4-20)?");
    scanf("%d",&ntent);
  }while(ntent<4 || ntent>20);

  // Genera il numero segreto
  segreto = generaNumero(cifre);

  // Visualizza il numero segreto (da usare nei test)
  //   printf("\n");
  //   for(j=0; j<segreto.numcifre;j++) printf("%d",segreto.cifre[j]);
  //   printf("\n");

  // Ciclo principale Termina quando il giocatore indovina il numero o
  // quando sono finiti i tentativi
  indovinato = false;
  for(i=0; (i<ntent) && (indovinato==false); i++)
    {
      // Legge il tentativo del giocatore
      printf("\nTentativo n. %d",i);
      tentativo = leggiNumero(cifre);

      // Calcola quante cifre ha indovinato
      calcola(segreto,tentativo,&o,&q);
      // Se le ha indovinate tutte il giocatore ha vinto
      if(o==cifre)
	{
	  printf("\nComplimenti hai indovinato");
	  indovinato = true;
	}
      // .. altrimenti stampa i risultati del tentativo
      else{
	while(o>0){
	  printf("+");
	  o--;
	}
	while(q>0){
	  printf("O");
	  q--;
	}
      }

      printf("\n");
    }


  // Se il ciclo e' finito perche sono terminati i tentativi dice al
  // giocatore che ha perso e visualizza il numero segreto.
  if(i==ntent) {
    printf("\nMi dispiace, hai perso.\nIl numero era : ");
    for(j=0; j<segreto.numcifre;j++) printf("%d",segreto.cifre[j]);
  }
}


impiccato.c 2/2

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

//********************************************************************
//STRUTTURE DATI
//********************************************************************

// Lunghezza massima della parola da indovinare
#define MAX 28

// Numero di tentativi
#define TENTATIVI 7

typedef struct
{
	char caratteri[MAX];
	int num_caratteri;
} stringa;

typedef enum {false, true} boolean;

//********************************************************************
//FUNZIONI
//********************************************************************

/*
	Riceve la stringa segreta, la stringa parziale e la lettera scelta dal giocatore
	Aggiunge alla stringa parziale la lettera nelle posizioni corrette
	Ritorna il numero di caratteri presenti nella stringa segreta uguali
	alla lettera
*/
int calcola(stringa segreta, stringa* parziale, char lettera)
{
	int i;
	int risultato = 0;

	// Scorre tutti i caratteri della stringa segreta
	for(i=0; i<segreta.num_caratteri; i++)
	{
		// Se un carattera e' uguale alla lettera scelta dall'utente...
		if(segreta.caratteri[i]==lettera){
			// e il carattere non era gia stato indovinato
			if(parziale->caratteri[i]=='_'){
				// Aggiunge il carattere alla stringa parziale
				parziale->caratteri[i]=lettera;
				// Aumenta il contatore delle lettere trovate
				risultato++;
			}
		}
	}

	// Ritorna il numero di caratteri in segreta uguali a lettera
	return risultato;
}

//********************************************************************
//MAIN
//********************************************************************

void main()
{
	int i;					// Contatore per i cicli
	int indovinati = 0;		// Numero di caratteri indovinati fino a questo momento
	int trovati    = 0;		// Usato per memorizzare il risultato della funzione calcola
	int errori     = 0;		// Numero di errori commessi fino a questo momento

	stringa segreta;		// Parola da indovinare
	stringa parziale;		// Parola con le lettere indovinate fino a questo momento

	boolean fine = false;
	char nuova;

	// Chiede all'utente la parola da indovinare
	printf("Inserisci la parola da indovinare: ");
	scanf("%s%*c",&segreta.caratteri);
	segreta.num_caratteri = strlen(segreta.caratteri);

	// Inizializza il parziale con tutti i caratteri vuoti  (_ _ _ _ _ _ _)
	parziale.num_caratteri = segreta.num_caratteri;
	for(i=0; i<parziale.num_caratteri; i++)
		parziale.caratteri[i] = '_';
	// Aggiunge il tappo alla stringa parziale
	parziale.caratteri[i]='\0';


	// Ciclo principale del programma
	while(!fine)
	{
		// Stampa la stringa parziale
		printf("\n    %s",parziale.caratteri);
		printf("\nErrori: %d",errori);
		// Chiede al giocatore di scegliere una lettera
		printf("\nChe lettera vuoi ? ");
		scanf("%c%*c",&nuova);
		// Calcola se la lettere e' presente nella parola segreta
		trovati = calcola(segreta,&parziale,nuova);
		indovinati = indovinati + trovati;
		// Se non e' presente incrementa gli errori
		if(trovati == 0) errori++;
		// Se tutte le lettere sono state indovinate o se sono finiti i
		// tentativi esce dal ciclo
		if(indovinati == segreta.num_caratteri) fine = true;
		if(errori==TENTATIVI) fine = true;
	}

	// Stampa il messaggio di vittoria o di sconfitta
	if(indovinati == segreta.num_caratteri)
		printf("Bravo, hai indovinato");
	else
		printf("Mi spiace, hai perso");

}

Generated by GNU enscript 1.6.4.