Estrutura de Dados Aplicada em Mãos de Pôquer
A downloadable tool
Estrutura de Dados Aplicada em Mãos de Pôquer
Introdução
Dados homogêneos: variáveis que abrigam dados similares ou idênticas, por exemplo, Integers(Int), que abrigam somente números inteiros (0,1,2,3). Dados heterogêneos: variáveis que abrigam dados de natureza distintas, por exemplo, uma lista de integers e strings (“0”, “JKLN”, “0123”).
Tipos Abstratos de Dados: pode ser definido como uma “classe de objetos cujo comportamento lógico é definido por um conjunto de valores e operações”(DALE; WALKER, 1996).
O propósito deste trabalho é compreender e manipular conceitos de estruturas de dados e fazer um programa que reconheça as mãos de pôquer.
Algoritmos e Estruturas
Nesse projeto utilizamos um Struct para registrar as características de uma carta, como o seu naipe e o seu valor, essas cartas são armazenadas dentro de um Histogram, um array que carrega 14 listas, separando as cartas pelo o seu valor, acessamos esse array para comparar e distinguir entre as jogadas do poker.
Pseudocódigo M1
1. Sequência Real: uma sequência de cinco cartas do mesmo naipe, sendo elas do 10 até o Às.
13,Clubs 1,Clubs 11,Clubs 12,Clubs 10,Clubs |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: contador (int), naipe (string), count_naipe (int) Início criar contador <- 1 criar existe <- false naipe <- “Clubs” count_naipe <- 0 // começa vendo se há um Ás, se houver verificamos se ha outras cartas em sequência se histogram[1].Count > 0 faça: para i de 10 até 13 faça: se histogram[i].Count > 0 faça incrementa contador fim se fim para
naipe <- histogram[1].suite //Comparamos o naipe de cada carta com a do Ás, se for igual, incrementamos ao count_nipe para i = 10 ate 13 faça: se naipe == histogram[i].suite incrementa count_nipe fim se fim para // caso haja sequencia e os naipes forem o mesmo retornamos existe como verdadeiro se contador == 5 && count_nipe == 4 faça: existe <- true retorna existe fim se
fim se retorna existe Fim | |
2. Sequência de Mesmo Naipe: Uma sequência de 5 cartas do mesmo Naipe, sem ser do 10 até o Às.
7,Diamond 8,Diamond 9,Diamond 10,Diamond 11,Diamond |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: contador (int), primeiro_naipe (string), primeira_posição (int), posições (lista int), royale (bool), contador_royale (int) Início criar contador <- 1 criar contador_royale <- 1 criar royale <- false criar existe <- false criar primeiro_naipe <- “” criar primeira_posição <- 0 criar posições[] // verificamos se há sequência royale, caso haja, no final retornamos existe como falso se histogram[1].Count > 0 faça: para i de 10 até 13 faça: se histogram[i].Count > 0 faça incrementa contador_royale fim se fim para fim se se contador_royale == 5 royale <- true fim se para i de 1 até 11 faça: se histogram[i].Value > 0 faça: posições.adicionar[histrogram[i].Value] fim se fim para // colocamos a lista do menor para o maior e então comparamos o seu naipe e a diferença entre eles, caso a diferença seja maior que dois, não há uma sequencia do mesmo naipe posições.organizar para cada i em posições: se i == 0 faça: primeiro_naipe == histogram[i].Suit primeira_posição == posições continua fim se se histogram[i].Suit != primeiro_naipe faça: quebra fim se criar diferança_de_posições <- i - primeira_posição se diferença_de_posições > 2 faça: quebra fim se adicionar contador fim para
se contador == 5 & royale == false faça: existe = true fim se retorna existe Fim | |
3. Quadra: Quatro cartas de mesmo valor mas com Naipes diferentes.
9,Hearts 9,Spades 9,Clubs 9,Diamond 3,Diamond |
|
Entrada: histogram (List<Card> [14]) Saída: existe (bool) Auxiliar: … Início criar existe <- verdadeiro // verificamos se há uma lista com 4 valores para i de 1 a 13 faça: se histogram[i].Count == 4 faça: existe = verdadeiro quebra fim se fim para retorna existe … Fim | |
4. Full House: Uma trinca (trio) e um par. Em caso de empate ganha o jogador com a trinca mais alta.
6,Diamond 3,Clubs 6,Spades 3,Spades 6,Hearts |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: cont3, cont2 (bool) Início criar cont3 <- verdadeiro criar cont2 <- verdadeiro criar existe <- verdadeiro // checa se há uma lista com 3 valores para i de 1 até 13 faça: se histogram[i].Count == 3 cont3 <- verdadeiro fim se fim para // checa se há uma lista com 2 valores para i de 1 até 13 faça: se histogram[i].Count == 2 cont2 <- verdadeiro fim se fim para // caso haja retornamos existe como verdadeiro se cont3 && cont2 existe <- verdadeiro retorna existe fim se retorna existe Fim | |
5. Flush: São 5 cartas do mesmo naipe sem serem seguidas. Caso dois jogadores possuam um flush, ganha aquele que possuir uma outra carta mais alta. Caso nenhum dos jogadores possua outras cartas, ocorre um empate.
2,Hearts 7,Hearts 11,Hearts 1,Hearts 4,Hearts |
|
Flush - 05 Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: count_naipe (int), naipe_atual (string) Início cria existe <- false // Inicializa a variável que indicará se há Flush cria count_naipe <- 0 // Contador para verificar o número de cartas de cada naipe cria naipe_atual <- "" // Armazena o naipe de cartas enquanto percorre o histograma\ // Para cada naipe (de 1 a 4) para i de 1 até 4 faça // 1 = Clubs, 2 = Diamonds, 3 = Hearts, 4 = Spades cria count_naipe <- 0 // Zera o contador de cartas para o naipe atual // Percorre todas as cartas (de 1 a 13) para verificar se há cartas do naipe atual para j de 1 até 13 faça se histogram[j].suite == i e histogram[j].Count > 0 então incrementa count_naipe // Incrementa o contador de cartas do naipe fim se fim para // Verifica se há pelo menos 5 cartas do mesmo naipe se count_naipe >= 5 então existe <- true // Encontrou um Flush retorna existe // Retorna imediatamente, pois encontrou um Flush fim se fim para
retorna existe Fim | |
6. Straight: São 5 cartas seguidas sem importar o naipe. Em caso de empate, ganha quem tiver a maior sequência.
3,Diamond 4,Clubs 5,Diamond 6,Spades 7,Hearts |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: contador (int) Início criar existe <- false // procuramos por cartas consecutivas do 13 até o 5, caso haja adicionamos o contador, caso não saímos do loop para i de 13 até 5 faça: criar contador <- 0 para j de 0 até 4 faça: se histogram[i - j].Count > 0 faça: incrementar contador se não: quebrar fim se fim para //caso achado uma sequência saímos da função retornando existe como verdadeiro se contador = 5 faça: existe <- true retornar existe fim se fim para
criar contador 0 <- // verificamos se há uma sequência do ás até o 5 para j de 1 até 5 faça: se histogram[j].Count > 0: incrementar contador se não: quebrar fim se fim para //caso achado uma sequência saímos da função retornando existe como verdadeiro se contador = 5 faça: existe <- true retornar existe
Fim | |
7. Trinca: São 3 cartas iguais, mais 2 cartas diferentes. Em caso de empate, ganha quem tiver a trinca mais alta.
8,Hearts 8,Clubs 8,Clubs 2,Clubs 10,Diamond |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar existe <- false //procuramos no histogram uma lista que haja 3 valores para i de 1 até 13 faça: //se houver retornamos existe como verdadeiro e saímos a função se histogram[i].Count maior ou igual a 3: existe <- true retornar existe fim se fim para retornar existe Fim | |
8. Dois Pares: São dois pares de cartas. Em caso de empate, ganha quem tiver o par maior mais alto. Caso tenham o mesmo valor, ganha o jogador com o par menor mais alto. Se ainda assim houver empate, ganha aquele com a carta mais alta.
12,Diamond 12,Spades 5,Hearts 2,Clubs 5,Spades |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar contador_pares criar existe // contamos do 1 até o 13 por pares para i de 1 até 13 faça: // caso já haja 2 pares saímos da função se contador_pares > 1 faça: existe <- true retornar existe fim se // se acharmos um par, somamos o contador de pares se histogram[i].Count == 2 faça: incrementar contador_pares fim se fim para retornar existe Fim | |
9. Par: São 2 cartas iguais, mais 3 cartas diferentes. Em caso de empate, ganha quem tiver o par mais alto. Caso sejam iguais, ganha o que possuir a maior carta.
12,Clubs 12,Diamond 7,Clubs 2,Spades 3,Hearts |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar existe // contamos do maior até o menor verificando se há pares para i de 13 até 1 faça: // caso haja um par logo retornamos o existe como verdadeiro para sair da função se histogram[i].Count == 2 faça: existe <- true retornar existe fim se fim para
retornar existe Fim | |
10. Carta Alta: Não havendo nenhuma combinação, ganha quem tiver a carta mais alta.
11,Diamond 7,Spades 5,Hearts 3,Clubs 10,Spades |
|
Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar mais_alta // verificamos se há um Ás na mão, caso haja retornamos o valor da carta se histogram[1].Count > 0 faça: mais_alta <- 1 retorna mais_alta // na ausência de um Ás, começamos da carta mais alta até a mais baixa, parando na primeira instância e retornamos o valor da carta para i de 13 até 2 faça: se histogram[i].Count > 0 faça: mais_alta <- i retorna mais_alta fim se fim para retorna mais_alta
Fim | |
Considerações Finais
Pedro Camargo: No geral, esse trabalho me ajudou a criar uma base no meu entendimento de estrutura de dados, e em como eu posso usar isso para resolver diversos problemas na programação.
Lucas Jordano: O conceito de Histogram se provou muito útil quando aplicado no projeto, é um recurso que facilita o trabalho do desenvolvedor.
Yasmin Fornero: Por ter entrado direto na matéria de Estrutura de Dados, sem ter a base de programação, foi rápido perceber certas dificuldades para compreender conceitos, e consequentemente, a prática acabou sendo um pouco complexa para mim. Mas em termos gerais, pude compreender o conteúdo na medida do possível.
Davi Costa: Achei muito interessante fazer um pseudocódigo, é uma excelente maneira de entender primeiro o problema e depois criar uma solução. Com o pseudocódigo, tem mais chances de se construir um código mais limpo e organizado e sem precisar voltar para editar ou rearranjar a estrutura dele.
Leonardo Guimarães:
Referências
DALE, Nell Boylan; WALKER, Henry Mackay. Abstract Data Types 3.5: specifications, implementations and applications. Lexington, Massachusetts, Toronto: Heath, 1996. 752 p.
NASCIMENTO, Amanda. Dados homogêneos x heterogêneos. Amanda Nascimento, 2024. Disponível em: <https://www.amandanascimento.com/post/dados-homog%C3%AAneos-x-heterog%C3%AAneos>. Acesso em: 05 de abr. de 2025.
Equipe
Yasmin Adria Fornero - https://mimichiii.itch.io/
Lucas Jordano - https://wanii1.itch.io/
Davi Costa Freitas - https://cat77.itch.io/
Pedro Camargo - https://nhatroncions.itch.io/
Leonardo Guimarães -
...
---------------------------------------------------------------------------------------------
Projeto desenvolvido como requisito parcial para obtenção de aprovação na disciplina: Estruturas de Dados - professor m4rc3lo
O conteúdo aqui tem direito reservado e pode conter inconsistências conceituais.
Universidade do Vale do Itajaí - UNIVALI
Cesar Albenes Zeferino | Diretor Escola Politécnica
Giorgio Gilwan | Coordenador do Curso: Design de Games
Rafael Kojiio | Coordenador Gamelab
