Elabore os seguintes algoritmos:
8 Dado um tabuleiro de xadrez, com a partida iniciada, indique a quantidade de peças de cada tipo. A saída deverá ser por exemplo: 3 peões brancos, 1 Rei branco, 1 torre branca, 4 peões pretos, 1 rei preto, etc…
  • Para facilitar, considere cada peça como um número (1 - PEÕES,2 - CAVALOS,3 TORRES, 4 - BISPOS, 5 - REIS, 6 - RAINHAS e 0 - AUSÊNCIA DE PEÇAS)

Passo 1

Vamos começar entendendo o que o exercício pede. Precisamos criar um algoritmo que, dado um tabuleiro de xadrez no início da partida, conte quantas peças de cada tipo existem para os dois jogadores (brancos e pretos). Para isso, vamos usar conceitos de estruturas de dados, como matrizes, e estruturas de repetição e condicionais para percorrer o tabuleiro e contar as peças.

Passo 2

Primeiro, vamos representar o tabuleiro de xadrez como uma matriz de 8 linhas por 8 colunas. Cada posição da matriz vai conter um número que representa o tipo da peça, conforme o mapeamento fornecido:
  • 1 - Peões
  • 2 - Cavalos
  • 3 - Torres
  • 4 - Bispos
  • 5 - Reis
  • 6 - Rainhas
  • 0 - Ausência de peças
Para distinguir entre peças brancas e pretas, vamos usar números positivos para as brancas e negativos para as pretas. Por exemplo, 1 será um peão branco e -1 será um peão preto.

Passo 3

Agora, precisamos criar variáveis para contar cada tipo de peça tanto para os brancos quanto para os pretos. Vamos inicializar todas as contagens com zero:
peoes_brancos = 0
cavalos_brancos = 0
torres_brancos = 0
bispos_brancos = 0
reis_brancos = 0
rainhas_brancas = 0

peoes_pretos = 0
cavalos_pretos = 0
torres_pretas = 0
bispos_pretos = 0
reis_pretos = 0
rainhas_pretas = 0

Passo 4

Vamos percorrer cada posição do tabuleiro usando dois laços de repetição: um para as linhas e outro para as colunas. Em cada posição, verificamos se há uma peça (número diferente de 0). Se houver, identificamos se a peça é branca ou preta e qual o tipo dela.

Passo 5

Dentro dos laços, para cada peça encontrada, usamos a função valor absoluto para identificar o tipo da peça, ignorando o sinal que indica a cor. Com base no tipo e na cor, incrementamos o contador correspondente. Por exemplo, se encontrarmos 1, incrementamos peoes_brancos; se encontrarmos -3, incrementamos torres_pretas.

Passo 6

Após percorrer todo o tabuleiro e contar todas as peças, exibimos os resultados no formato solicitado, indicando a quantidade de cada tipo de peça para os brancos e para os pretos.

Resposta

Aqui está um exemplo de como o algoritmo pode ser implementado em pseudocódigo:
# Representação do tabuleiro (posição inicial)
tabuleiro = [
    [3, 2, 4, 6, 5, 4, 2, 3],
    [1, 1, 1, 1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [-1,-1,-1,-1,-1,-1,-1,-1],
    [-3,-2,-4,-6,-5,-4,-2,-3]
]

# Inicialização dos contadores
peoes_brancos = 0
cavalos_brancos = 0
torres_brancos = 0
bispos_brancos = 0
reis_brancos = 0
rainhas_brancas = 0

peoes_pretos = 0
cavalos_pretos = 0
torres_pretas = 0
bispos_pretos = 0
reis_pretos = 0
rainhas_pretas = 0

# Percorrendo o tabuleiro
para cada linha em tabuleiro:
    para cada peça em linha:
        se peça == 0:
            continue  # Sem peça, passa para a próxima posição
        se peça > 0:
            cor = "branco"
            tipo = peça
        senão:
            cor = "preto"
            tipo = abs(peça)  # Tira o sinal para identificar o tipo
        
        se tipo == 1:
            se cor == "branco":
                peoes_brancos += 1
            senão:
                peoes_pretos += 1
        elif tipo == 2:
            se cor == "branco":
                cavalos_brancos += 1
            senão:
                cavalos_pretos += 1
        elif tipo == 3:
            se cor == "branco":
                torres_brancos += 1
            senão:
                torres_pretas += 1
        elif tipo == 4:
            se cor == "branco":
                bispos_brancos += 1
            senão:
                bispos_pretos += 1
        elif tipo == 5:
            se cor == "branco":
                reis_brancos += 1
            senão:
                reis_pretos += 1
        elif tipo == 6:
            se cor == "branco":
                rainhas_brancas += 1
            senão:
                rainhas_pretas += 1

# Exibindo os resultados
print(peoes_brancos, "peões brancos")
print(cavalos_brancos, "cavalos brancos")
print(torres_brancos, "torres brancas")
print(bispos_brancos, "bispos brancos")
print(reis_brancos, "reis brancos")
print(rainhas_brancas, "rainhas brancas")

print(peoes_pretos, "peões pretos")
print(cavalos_pretos, "cavalos pretos")
print(torres_pretas, "torres pretas")
print(bispos_pretos, "bispos pretos")
print(reis_pretos, "reis pretos")
print(rainhas_pretas, "rainhas pretas")
Explicação do Algoritmo:
  1. Representação do Tabuleiro: O tabuleiro é representado como uma matriz 8x8 onde cada número corresponde a um tipo específico de peça, sendo números positivos para peças brancas e negativos para pretas.
  2. Inicialização dos Contadores: Criamos variáveis para contar cada tipo de peça para ambas as cores, todas iniciadas com zero.
  3. Percorrendo o Tabuleiro: Usamos dois laços para para iterar por cada linha e, dentro dela, por cada peça.
  4. Identificando Peças e Cores: Se o número for maior que zero, a peça é branca; se for menor, preta. O tipo da peça é obtido pelo valor absoluto do número.
  5. Contando as Peças: Com base no tipo e na cor, incrementamos o contador correspondente.
  6. Exibindo os Resultados: Após percorrer todo o tabuleiro, imprimimos a quantidade de cada tipo de peça para os brancos e pretos no formato solicitado.
Saída Esperada:
8 peões brancos
2 cavalos brancos
2 torres brancas
2 bispos brancos
1 rei branco
1 rainha branca
8 peões pretos
2 cavalos pretos
2 torres pretas
2 bispos pretos
1 rei preto
1 rainha preta
Esse resultado reflete a configuração inicial de um tabuleiro de xadrez, onde cada jogador começa com 8 peões, 2 cavalos, 2 torres, 2 bispos, 1 rei e 1 rainha.

Exercícios relacionados