Patrocínio Natura

Resolvendo uma Questão do Big Brother Brasil

13 de abril de 2009

Após três meses de confinamento o brother Max Porto ganhou a nona edição do programa, o BBB9, ou seja, ao final só restou ele, restou um. Inclusive o jogo milenar foi objeto da vinheta do programa que fazia alusão ao objetivo do programa, que tinha 18 “pinos” e com o andamento do jogo levou ao resta um. Muito criativo por parte da produção, mas deixando o papo mole de lado, a pergunta é : O que tudo isso tem haver com informática? 

Pois bem, motivado pelo jogo fiquei pensando como era possível fazer um algoritmo para resolvê-lo, não o BBB9, mas o resta um no seu objetivo principal. Como não gosto de inventar a roda, fui buscar na internet alguém que tivesse desenvolvido para estudar e saber se desenvolveria de outro modo, muito interessante, a solução completa, tanto no algoritmo quanto na programação. Parabéns ao pessoal do “Fundão da Computação“, confira:

Nota: Abaixo mostramos a função que retorna a prioridade para determinada jogada para um determinado buraco do tabuleiro.

O programa principal deve empilhar todas as jogadas e executá-las na sua ordem correta e quando uma determinada sequência de jogadas não der futuro deve desfazê-la e executar a que vier em seguida;

O buraco é mandado para a função na forma xy. Se a coordenada x é 2 e a coordenada y é 3 o valor 23 é mandado para a função;

A jogada segue a seguinte seqüência:
Comer de cima para baixo corresponde ao valor 1;
Comer da esquerda para a direita corresponde ao valor 2;
Comer de baixo para cima corresponde ao valor 3;
Comer da direita para a esquerda corresponde ao valor 4;
E o tabuleiro é uma matriz 7×7, com os índices variando de 0 à 6.

Pegue aqui o código completo do resta um.

Ou se preferir pegue o executável e os arquivos graficos necessários para que ele execute corretamente caso você não tenha o compilador Borland C++ 3.11.

Obs.: Este programa foi feito utilizando o Compilador Borland C++ 3.11 que possui bibliotecas gráficas para o modo DOS. Este código não funcionará em um compilador de 32 bits, devido à sua interface, mas as funções para resolução do problema podem ser aproveitadas para construir uma nova versão para Windows.

/*******************************************************
Funcao: Pegapriori 
Entrada: buraco, jogada, tabuleiro 
Saida:  O valor da prioridade da jogada 
*******************************************************/ 
int pegapriori(int lc,int j,tabuleiro tab)
{
  int l,c;
  l=lc/10;   // linha do buraco   Linha 0: 1ª linha
  c=lc%10;   // coluna do buraco do Tabuleiro
  if(l==0)
  {
    if(j==3)   //joga de baixo para cima
      return 0;
    return 5;   //joga p/ direita ou para esquerda
  }
  if(l==6)   //linha 0, 1, 5, 6
  {
    if(j==1)
      return 0;
    return 5;
  }
  if(l==1||l==5)
  {
    if(j==2||j==4)
      return 4;
    if((l==1&&tab[l-1][c]==1)||(l==5&&tab[l+1][c]==1))
      return 4;
    return 1;
  }
  if(c==0)   //linha 0, 1, 5, 6
  {
  if(j==4)
    return 0;
  return 5;
  }
  if(c==6)   //linha 0, 1, 5, 6
  {
    if(j==2)
      return 0;
    return 5;
  }
  if(c==1||c==5)
  {
    if(j==1||j==3)
      return 4;
    if((c==1&&tab[l][c-1]==1)||(c==5&&tab[l][c+1]==1))
      return 4;
    return 1;
  }
  if(l==2)
  {
    if(j==1)
      return 6;
    if(j==3)
      return 2;
    if(c==3)
      return 3;
    if((c==2&&j==2)||(c==4&&j==4))
      return 6;
    return 2;
  }
  if(l==4)
  {
    if(j==3)
      return 6;
    if(j==1)
      return 2;
    if(c==3)
      return 2;
    if((c==2&&j==2)||(c==4&&j==4))
      return 6;
    return 2;
  }
  else /*(l==3)*/
  {
    if(c==3)
      return 2;
    if(c==2&&j==2)||(c==4&&j==4))
      return 6;
    return 2;
  }
}

Compatilhe esse artigo!

Nenhum Comentário

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

This site uses Akismet to reduce spam. Learn how your comment data is processed.