Re: Problema 1 aula

[Anonymous <anony@sti.com.br>]

Oi gente,

	Andre, andei pensando tambem nesse problema. E (felismente :)
cheguei a uma conclusao semelhante `a sua, com excecao a parte de escolher
a primeira opcao da sequencia como o contrario da ultima do outro jogador.
Acho que essa parte seria realmente aleatoria. Porem, nao posso afirmar...
	Quanto ao seu programa, gostei bastante. E resolvi fazer o meu com
base na ideia de ser totalmente de representacao binaria. Acho que assim
agilizaria um pouco se escolhesse muitas partidas.
	Um abraco,

		Rodrigo Couto

Um pequeno PS: o meu programa foi feito no linux. Nao tenho windows aqui
em casa para testar no djgpp. Desculpas pessoal. Desculpas tambem pela
falta de documentacao.

/***************************************************************
 *         Programa de teste do 'desafio das moedas'           *
 *                                                             *
 * Author: Rodrigo Couto                                       *
 * Date: Sat Mar 13 19:45:33 EST 1999                          *
 ***************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>
#include <time.h>

/*
 * utilizarei numeros binarios para representar tanto cara('h') como coroa
 * ('t'):
 * h = 1
 * t = 0
 * e amarzenarei-os em short int(16bits), limitando os patterns de 4 a 15.
 */

/* funcao translation: transforma uma string contento h's e t's na forma
 *                     binaria
 * argumentos:
 *  char* string: pointer para a string a ser traduzida
 * retorna:
 *  short int contendo a sequencia. Em caso de erros retorna NULL
 */
short int translation(char* string) {
  int i, n;
  short int answer;
  char c;

  /* zerando... */
  answer = 0;

  /* checando tamanho da string */
  n = strlen(string);
  if((n > 15) || (n < 4))
    return (short int) NULL;
  
  /* parsing... */
  for(i = 0; i < n; i++) {
    switch(string[i])
      {
      case 'h':
	answer = (answer << 1) | 1;
	break;
      case 't':
	answer <<= 1;
	break;
      default:
	return (short int) NULL;
      }
  }

  return answer;
}

/*
 * funcao matches: simula n partidas
 * argumentos:
 *  int times: o numero de partidas a serem disputadas
 *  short int patt: a 1a. sequencia escolhida
 *  short int patt2: a 2a. sequencia escolhida(ou gerada)
 *  int size: o numero de elementos nas sequencias patt*
 */
void matches(int times, short int patt, short int patt2, int size) {
  short int temp, mask;
  int victories; // vitorias da seq1
  int i, j, flag;
 
  flag = 0;
  victories = 0;
  mask = 0;

  for(i = 0; i < size; i++)
    mask = (mask << 1) | 1;

  for(i = 0; i < times; i++) {
    for(j = 0; j < (size - 1); j++)
      temp = (temp << 1) | (rand() % 2);
    for(;;) {
      temp = (temp << 1) | (rand() % 2);
      temp &= mask;
      if(temp == patt) {
	victories++;
	break;
      } else if(temp == patt2) {
	break;
      }
    }
  }
  
  printf("Vitorias da Seq1: %d\n", victories);
  printf("Vitorias da Seq2: %d\n", times - victories);
}

/*
 * funcao gen_seq: gera uma sequencia de tamanho n que em tese terah maior 
 *   probabilidade de ganhar. (segundo o email do Andre)
 * argumentos:
 *  short int other: a sequencia do outro jogador
 *  int size: o tamanho da sequencia
 * retorna:
 *  short int contento a nova sequencia
 */
short int gen_seq(short int other, int size) {
  short int temp;
  int i;

  temp = 0;

  other >>=1;                          // eliminando a ultima opcao da
                                       // sequencia do 1 jogador;
  temp |= other;                       // transferindo para o temp;
  temp |= (((other | 1) ^ 1) ? 0 : 1 << size);
                                       // colocando o oposto da ultima opcao
                                       // do outro jogador como primeira opcao
                                       // nossa ;
  
  return temp;
}

int main(int argc, char* argv[]) {
  short int temp, temp2;
  int c, i, flag, flag2;
  int times, size, size2;

  /* random seed */
  srand(time(NULL));

  /* pegando argumentos */
  if(argc == 1) {
    fprintf(stderr,
	    "E necessario pelo menos um argumento. %s -h para ajuda.\n",
	    argv[0]);
    return 1;
  }

  flag = 1;
  flag2 = 1;
  times = 100;

  while((c = getopt(argc, argv, "p:s:hm:")) != -1)
    switch(c) {
    case 'p':
      flag = 0;
      if((temp = translation(optarg)) != (short int) NULL) {
	size = strlen(optarg);
	break;
      } else {
	fprintf(stderr,
		"Nao eh uma sequencia valida. %s -h para ajuda.\n",
		argv[0]);
	return 1;
      }
    case 's':
      flag2 = 0;
      if((temp2 = translation(optarg)) != (short int) NULL) {
	size2 = strlen(optarg);
	break;
      } else {
	fprintf(stderr,
		"Nao eh uma sequencia valida. %s -h para ajuda.\n",
		argv[0]);
	return 1;
      }
    case 'm':
      for(i = 0; i < strlen(optarg); i++)
	if(!isdigit(optarg[i])) {
	  fprintf(stderr, "Numero de partidas nao eh valido.\n");
	  return 1;
	}
      times = atoi(optarg);
      break;
    case 'h':
      break;
    case '?':
      if (isprint (optopt))
	fprintf (stderr, "Unknown option `-%c'.\n", optopt);
      else
	fprintf (stderr,
		 "Unknown option character `\\x%x'.\n",
		 optopt);
      return 1;
    default:
      abort ();
    }
  
  if(flag) {
    fprintf(stderr, "Sequencia nao especificada.\n");
    return 1;
  }
  else if(flag2) {
    printf("Nao ha segunda sequencia. Criando uma sequencia...\n");
    temp2 = gen_seq(temp, size);
  }
  else if(size != size2) {
    printf("Sequencias de tamanhos diferentes. Abortando.\n");
    return 1;
  }
  else if(temp == temp2) {
    printf("Sequencias identicas. Empate iminente.\n");
    return 1;
  }

  printf("Seq1\tSeq2\n0x%04X\t0x%04X\n", temp, temp2);
  
  /* iniciando partidas */
  matches(times, temp, temp2, size);

  return 0;
}