Trabalho Paradigmas de Programação MãoDePoker

Mãos de Poker

Jonatan W. Pereira da Silva1, Renilson da Silva Albuquerque 1, Lucas Sidronio Santana1 e Davi Gomes Sales1

1Departamento de Estatística e Informática – Universidade Federal Rural de Pernambuco (UFRPE)
Rua Dom Manoel de Medeiros, s/n, Dois Irmãos - CEP: 52171-900 - Recife/PE

{Jonatan.washington,renilson.albuquerque,lucas.santana,davi.sales}@ufrpe.br

Abstract. This paper refers to a work of Programming Paradigms of the full degree course in computation of the Universidade Federal Rural de Pernambuco whose purpose is to study aspects of the paradigm of descriptive programming and derivatives, through the implementation of a computational solution for The following problem: given two "Poker hands" which is the winner or if there is a tie, we will also discuss how design choices can impact the performance of the application.

Resumo. Este documento refere-se a um trabalho de Paradigmas de Programação do curso de Licenciatura plena em computação da Universidade Federal Rural de Pernambuco, que tem a finalidade de estudo dos aspectos do paradigma de programação descritivo e derivados, através da implementação de uma solução computacional para o seguinte problema: dada duas “mãos de Poker” qual é a vencedora ou se há um empate, também abordaremos como a escolhas de design podem impactar no desempenho da aplicação.

1. Solução desenvolvida

1.1. Link para download do código fonte e do executável e Instruções para download.

Ir para o link: https://github.com/RenilsonAlbuquerque/Projeto-Paradigmas.git

Clicar no botão “Clone or download” conforme mostrado na figura 1.

Clicar no botão “Download ZIP” conforme mostrado na figura 1.

Descompactar o arquivo .zip.

O arquivo contendo 100 milhões de entradas encontra-se no seguinte link:

http://bit.ly/2w34w6i

Após baixa-lo, deve-se extraí-lo na pasta src/utils junto aos outros arquivos de entrada.

[pic 1]

Figura 1. Página do repositório do projeto no Github

 

1.2. Instruções de como executar a aplicação

Ir para o link:

http://www.eclipse.org/downloads/packages/eclipse-ide-java-developers/oxygenr

Selecionar no canto superior direito o seu sistema operacional, conforme mostrado na figura 2.

Clicar no botão “DOWNLOAD”, conforme mostrado na figura 3.

Fazer a instalação do eclipse.

Importar o projeto no Eclipse.

Ir na linha 16 da classe “Arquivo.java” da versão do algoritmo desejada e alterar o valor da variável “nomeArquivo” para o nome do arquivo desejado (pokerK.txt, pokerM.txt, poker100M.txt).

Executar a classe “Main.java” da versão do algoritmo  desejada.

[pic 2]

Figura 2. Primeira página de Download do Eclipse

[pic 3]

Figura 3. Segunda página de Download do Eclipse

        

2. Como o problema foi resolvido

A linguagem de programação escolhida foi Java, pois é a linguagem mais conhecida pelos membros do grupo e tem um grande apoio da comunidade, apesar de fazer uso de objetos para instanciar as classes fundamentais para execução do processo, o algoritmo não usa conceitos de Orientação à Objetos como, polimorfismo, herança, entre outros, portanto, o paradigma de programação escolhido foi o imperativo-procedural já que o código é estruturado através de funções bem definidas, que são invocadas em uma função principal.

2.1 Estruturação do código

O código está dividido em 4 classes: Arquivo, Jogadas, Verificador e Main. A classe Arquivo é responsável por ler o arquivo selecionado entre as opções disponíveis supracitadas, a leitura é feita dinamicamente, ou seja quando o método "lerLinha" é chamado, ele lê uma linha do arquivo em String através da classe FileReader do java, divide a linha retornada em um array de Strings, chama a função "ordenar" da mesma classe que ordena as duas metades do array e retorna os dois arrays concatenados.

        A classe Jogadas é a auxiliar da classe Verificador, pois apenas contém todos os métodos que verificam se um array de Strings contém uma determinada jogada, as comparações são feitas considerando que a mão está ordenada utilizando um HashMap de Inteiros com a chave de String. Os métodos tem um retorno diferente dependendo da jogada, alguns retornam verdadeiro ou falso como por exemplo o método "straightFlush" recebe como parâmetro um vetor de Strings equivalente a uma mão e verifica se a mesma possui um Straight Flush retornando verdadeiro ou falso dependendo do resultado, mas em algumas outras jogadas o método retorna um inteiro representando o seu valor, por exemplo, o método "quadra" recebe como parâmetro um array de Strings e verifica se a mesma possui uma quadra, retornando o valor da carta que a compõe caso tenha e -1 caso não tenha, essa abordagem é conveniente para critério de desempate entre jogadas (a descrição individual dos métodos desta classe está na próxima subseção).

        Dado que temos um leitor de linha e uma classe que verifica as jogadas, finalmente temos a classe Verificador que é responsável pela estrutura principal do algoritmo, nela temos uma instância da classe Arquivo, uma da classe Jogadas e um método "verificações" que consiste em um while que se repete enquanto o método "lerLinha" retornar um vetor de Strings diferente de nulo, em cada iteração o método verifica as jogadas em cadeia para decidir qual mão foi a vencedora, a estrutura das cadeias consiste em comparar primeiro se as duas mãos possuem uma determinada jogada, caso uma das mãos possua, o código adiciona ao contador de vitórias da mão correspondente e parte para a próxima iteração, caso as duas mãos tenham a jogada é acionado um critério de desempate correspondente a função, na maioria das vezes o desempate é feito na comparação do valor da jogada empatada. Por fim ,caso nenhuma das mãos possua a jogada o algoritmo repete o processo supracitado para uma jogada de valor menor até encontrar um vencedor.