Uma competição entre duas IAs em um jogo simples. Vou fazer o exemplo mais claro possível usando Jogo da Velha (Tic-Tac-Toe), onde IA X e IA O jogam uma contra a outra automaticamente.

🎮 Competição IA vs IA — Jogo da Velha

Aqui está um código completo em Python que cria:

Um tabuleiro
Funções para jogadas
Duas IAs que escolhem suas jogadas
Partida automática até alguém vencer

As IAs usam decisões simples (aleatórias).
Se quiser, posso melhorar para IA “inteligente”.

🧠 Código (IA X vs IA O)

import random

# Cria tabuleiro
def novo_tabuleiro():
    return [" "]*9

# Mostra tabuleiro
def mostrar(t):
    print(f"{t[0]} | {t[1]} | {t[2]}")
    print("--+---+--")
    print(f"{t[3]} | {t[4]} | {t[5]}")
    print("--+---+--")
    print(f"{t[6]} | {t[7]} | {t[8]}")
    print()

# Verifica vitória
def venceu(t, jogador):
    combinacoes = [
        [0,1,2],[3,4,5],[6,7,8],  # linhas
        [0,3,6],[1,4,7],[2,5,8],  # colunas
        [0,4,8],[2,4,6]           # diagonais
    ]
    return any(all(t[i] == jogador for i in c) for c in combinacoes)

# IA: escolhe jogada aleatória válida
def jogada_ia(t, jogador):
    opcoes = [i for i in range(9) if t[i] == " "]
    escolha = random.choice(opcoes)
    t[escolha] = jogador

# Execução da partida
tab = novo_tabuleiro()
jogador = "X"  # IA X começa

while " " in tab:
    jogada_ia(tab, jogador)
    print(f"IA {jogador} jogou:")
    mostrar(tab)
    
    if venceu(tab, jogador):
        print(f"IA {jogador} VENCEU! 🎉")
        break
    
    jogador = "O" if jogador == "X" else "X"  # troca turno

if " " not in tab and not venceu(tab, "X") and not venceu(tab, "O"):
    print("Empate! 🤝")

🚀 O que fazer agora?

Posso criar para você:

✔️ versão melhorada, onde as IAs pensam (minimax)
✔️ versão com interface gráfica
✔️ outra competição: corrida, batalha de números, adivinhação
✔️ colocar estratégias diferentes para ver qual IA vence mais

Qual tipo de jogo você quer que as IAs disputem? 🎮🤖

Excelente pedido! Vamos criar uma **competição épica entre IAs** com estratégias diferentes. Aqui está uma versão **melhorada e analítica** do Jogo da Velha:

```python
import random
from collections import defaultdict
import time

class JogoDaVelhaCompetitivo:
def __init__(self):
self.tabuleiro = [" "] * 9
self.estatisticas = {
'X': {'vitorias': 0, 'derrotas': 0, 'empates': 0},
'O': {'vitorias': 0, 'derrotas': 0, 'empates': 0}
}
self.historico_partidas = []

def mostrar_tabuleiro(self):
"""Mostra o tabuleiro de forma visual"""
print("\n" + "="*30)
for i in range(0, 9, 3):
print(f" {self.tabuleiro[i]} | {self.tabuleiro[i+1]} | {self.tabuleiro[i+2]} ")
if i < 6:
print("---+---+---")
print()

def jogadas_disponiveis(self):
"""Retorna lista de posições vazias"""
return [i for i in range(9) if self.tabuleiro[i] == " "]

def verificar_vitoria(self, jogador):
"""Verifica se o jogador venceu"""
vitorias = [
[0,1,2], [3,4,5], [6,7,8], # Linhas
[0,3,6], [1,4,7], [2,5,8], # Colunas
[0,4,8], [2,4,6] # Diagonais
]
return any(all(self.tabuleiro[pos] == jogador for pos in comb) for comb in vitorias)

def tabuleiro_cheio(self):
"""Verifica se o tabuleiro está completo"""
return " " not in self.tabuleiro

# ===========================================
# ESTRATÉGIAS DAS IAs (Diferentes personalidades)
# ===========================================

class IA_Aleatoria:
"""IA que joga de forma completamente aleatória"""
def __init__(self, nome):
self.nome = nome

def jogar(self, tabuleiro):
return random.choice([i for i in range(9) if tabuleiro[i] == " "])

class IA_CentroPrimeiro:
"""IA que prioriza o centro, depois cantos, depois laterais"""
def __init__(self, nome):
self.nome = nome

def jogar(self, tabuleiro):
disponiveis = [i for i in range(9) if tabuleiro[i] == " "]
prioridades = [4, 0, 2, 6, 8, 1, 3, 5, 7] # Centro, cantos, laterais

for pos in prioridades:
if pos in disponiveis:
return pos

return random.choice(disponiveis) # Fallback

class IA_Defensiva:
"""IA que tenta bloquear o adversário e vencer"""
def __init__(self, nome):
self.nome = nome

def jogar(self, tabuleiro, meu_simbolo):
adversario = "O" if meu_simbolo == "X" else "X"

# 1. Tenta vencer
for pos in [i for i in range(9) if tabuleiro[i] == " "]:
tabuleiro_teste = tabuleiro.copy()
tabuleiro_teste[pos] = meu_simbolo
vitorias = [
[0,1,2], [3,4,5], [6,7,8],
[0,3,6], [1,4,7], [2,5,8],
[0,4,8], [2,4,6]
]
if any(all(tabuleiro_teste[p] == meu_simbolo for p in comb) for comb in vitorias):
return pos

# 2. Tenta bloquear adversário
for pos in [i for i in range(9) if tabuleiro[i] == " "]:
tabuleiro_teste = tabuleiro.copy()
tabuleiro_teste[pos] = adversario
vitorias = [
[0,1,2], [3,4,5], [6,7,8],
[0,3,6], [1,4,7], [2,5,8],
[0,4,8], [2,4,6]
]
if any(all(tabuleiro_teste[p] == adversario for p in comb) for comb in vitorias):
return pos

# 3. Joga no centro se disponível
if tabuleiro[4] == " ":
return 4

# 4. Joga em um canto
cantos = [0, 2, 6, 8]
cantos_disponiveis = [c for c in cantos if tabuleiro[c] == " "]
if cantos_disponiveis:
return random.choice(cantos_disponiveis)

# 5. Qualquer posição disponível
disponiveis = [i for i in range(9) if tabuleiro[i] == " "]
return random.choice(disponiveis)

class IA_MiniMax:
"""IA usando algoritmo MiniMax (mais inteligente)"""
def __init__(self, nome):
self.nome = nome

def minimax(self, tabuleiro, profundidade, maximizando, simbolo):
adversario = "O" if simbolo == "X" else "X"

# Verifica estado final
if any(all(tabuleiro[p] == simbolo for p in comb) for comb in [
[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]
]):
return 10 - profundidade
if any(all(tabuleiro[p] == adversario for p in comb) for comb in [
[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]
]):
return profundidade - 10
if " " not in tabuleiro:
return 0

if maximizando:
melhor = -float('inf')
for i in range(9):
if tabuleiro[i] == " ":
tabuleiro[i] = simbolo
score = self.minimax(tabuleiro, profundidade + 1, False, simbolo)
tabuleiro[i] = " "
melhor = max(melhor, score)
return melhor
else:
melhor = float('inf')
for i in range(9):
if tabuleiro[i] == " ":
tabuleiro[i] = adversario
score = self.minimax(tabuleiro, profundidade + 1, True, simbolo)
tabuleiro[i] = " "
melhor = min(melhor, score)
return melhor

def jogar(self, tabuleiro, meu_simbolo):
melhor_score = -float('inf')
melhor_jogada = None

for i in range(9):
if tabuleiro[i] == " ":
tabuleiro[i] = meu_simbolo
score = self.minimax(tabuleiro, 0, False, meu_simbolo)
tabuleiro[i] = " "

if score > melhor_score:
melhor_score = score
melhor_jogada = i

return melhor_jogada

# ===========================================
# TORNEIO ENTRE IAs
# ===========================================

def realizar_torneio(num_partidas=100):
"""Realiza um torneio entre diferentes IAs"""
print("🏆 TORNEIO DE IAs - JOGO DA VELHA 🏆")
print("="*50)

# Cria IAs com diferentes estratégias
estrategias = {
"Aleatória": IA_Aleatoria("Aleatória"),
"Centro 1º": IA_CentroPrimeiro("Centro 1º"),
"Defensiva": IA_Defensiva("Defensiva"),
"MiniMax": IA_MiniMax("MiniMax")
}

resultados = defaultdict(lambda: {'vit': 0, 'der': 0, 'emp': 0})

# Testa todos os pares de IAs
estrategias_lista = list(estrategias.items())

for (nome1, ia1), (nome2, ia2) in [(estrategias_lista[i], estrategias_lista[j])
for i in range(len(estrategias_lista))
for j in range(i+1, len(estrategias_lista))]:

print(f"\n⚔️ {nome1} (X) vs {nome2} (O) ⚔️")
print("-"*30)

vitorias_ia1 = 0
vitorias_ia2 = 0
empates = 0

for partida in range(num_partidas):
jogo = JogoDaVelhaCompetitivo()
turno = "X"

while True:
# IA 1 joga como X
if turno == "X":
if isinstance(ia1, IA_Defensiva) or isinstance(ia1, IA_MiniMax):
jogada = ia1.jogar(jogo.tabuleiro.copy(), "X")
else:
jogada = ia1.jogar(jogo.tabuleiro.copy())
# IA 2 joga como O
else:
if isinstance(ia2, IA_Defensiva) or isinstance(ia2, IA_MiniMax):
jogada = ia2.jogar(jogo.tabuleiro.copy(), "O")
else:
jogada = ia2.jogar(jogo.tabuleiro.copy())

jogo.tabuleiro[jogada] = turno

# Verifica vitória
if jogo.verificar_vitoria(turno):
if turno == "X":
vitorias_ia1 += 1
else:
vitorias_ia2 += 1
break

# Verifica empate
if jogo.tabuleiro_cheio():
empates += 1
break

# Alterna turno
turno = "O" if turno == "X" else "X"

# Reinicia tabuleiro
jogo.tabuleiro = [" "] * 9

# Atualiza estatísticas
resultados[nome1]['vit'] += vitorias_ia1
resultados[nome1]['der'] += vitorias_ia2
resultados[nome1]['emp'] += empates

resultados[nome2]['vit'] += vitorias_ia2
resultados[nome2]['der'] += vitorias_ia1
resultados[nome2]['emp'] += empates

print(f"Resultados após {num_partidas} partidas:")
print(f"{nome1}: {vitorias_ia1} vitórias")
print(f"{nome2}: {vitorias_ia2} vitórias")
print(f"Empates: {empates}")
print(f"Taxa de vitória {nome1}: {vitorias_ia1/num_partidas*100:.1f}%")
print(f"Taxa de vitória {nome2}: {vitorias_ia2/num_partidas*100:.1f}%")

# Mostra classificação final
print("\n" + "="*50)
print("🏁 CLASSIFICAÇÃO FINAL DO TORNEIO 🏁")
print("="*50)

# Calcula pontos (3 por vitória, 1 por empate)
classificacao = []
for nome, stats in resultados.items():
pontos = stats['vit'] * 3 + stats['emp']
classificacao.append((nome, pontos, stats['vit'], stats['der'], stats['emp']))

# Ordena por pontos
classificacao.sort(key=lambda x: x[1], reverse=True)

print("\nPosição | IA | Pontos | Vitórias | Derrotas | Empates")
print("-"*60)
for i, (nome, pontos, vit, der, emp) in enumerate(classificacao, 1):
print(f"{i:^8}| {nome:<12}| {pontos:^7}| {vit:^9}| {der:^9}| {emp:^7}")

# Mostra IA vencedora
vencedor = classificacao[0]
print(f"\n🎉 CAMPEÃ: {vencedor[0]} com {vencedor[1]} pontos! 🎉")

return classificacao

# ===========================================
# EXECUTAR PARTIDA INDIVIDUAL (para visualização)
# ===========================================

def partida_individual(ia1, ia2, mostrar_jogo=True):
"""Executa uma partida individual entre duas IAs"""
print(f"\n🎮 PARTIDA: {ia1.nome} (X) vs {ia2.nome} (O)")
print("="*40)

jogo = JogoDaVelhaCompetitivo()
turno = "X"
movimentos = []

while True:
# IA 1 joga
if turno == "X":
if isinstance(ia1, IA_Defensiva) or isinstance(ia1, IA_MiniMax):
jogada = ia1.jogar(jogo.tabuleiro.copy(), "X")
else:
jogada = ia1.jogar(jogo.tabuleiro.copy())
jogador_nome = ia1.nome
# IA 2 joga
else:
if isinstance(ia2, IA_Defensiva) or isinstance(ia2, IA_MiniMax):
jogada = ia2.jogar(jogo.tabuleiro.copy(), "O")
else:
jogada = ia2.jogar(jogo.tabuleiro.copy())
jogador_nome = ia2.nome

jogo.tabuleiro[jogada] = turno
movimentos.append((jogador_nome, jogada))

if mostrar_jogo:
print(f"\n{turno} ({jogador_nome}) jogou na posição {jogada}")
jogo.mostrar_tabuleiro()
time.sleep(0.5) # Pausa para visualização

# Verifica vitória
if jogo.verificar_vitoria(turno):
print(f"🎯 VITÓRIA DO {turno} ({jogador_nome})!")
return turno, movimentos

# Verifica empate
if jogo.tabuleiro_cheio():
print("🤝 EMPATE!")
return None, movimentos

# Alterna turno
turno = "O" if turno == "X" else "X"

# ===========================================
# MENU PRINCIPAL
# ===========================================

def main():
print("🤖 ARENA DE IAs - JOGO DA VELHA COMPETITIVO 🤖")
print("="*60)

while True:
print("\nOpções:")
print("1. 🎯 Ver partida individual (MiniMax vs Defensiva)")
print("2. ⚔️ Ver partida aleatória (Aleatória vs Centro 1º)")
print("3. 🏆 Realizar torneio completo (todas as IAs)")
print("4. 📊 Ver estatísticas avançadas")
print("5. 🚪 Sair")

opcao = input("\nEscolha uma opção (1-5): ")

if opcao == "1":
ia_minimax = IA_MiniMax("MiniMax Avançado")
ia_defensiva = IA_Defensiva("Defensiva")
partida_individual(ia_minimax, ia_defensiva, mostrar_jogo=True)

elif opcao == "2":
ia_aleatoria = IA_Aleatoria("Aleatória Pura")
ia_centro = IA_CentroPrimeiro("Centro Primeiro")
partida_individual(ia_aleatoria, ia_centro, mostrar_jogo=True)

elif opcao == "3":
print("\nIniciando torneio...")
resultados = realizar_torneio(num_partidas=50) # 50 partidas por confronto

elif opcao == "4":
print("\n📈 ANÁLISE DE ESTRATÉGIAS:")
print("-"*40)
print("1. Aleatória: Simples, imprevisível")
print("2. Centro 1º: Estratégia básica eficiente")
print("3. Defensiva: Tenta bloquear e vencer")
print("4. MiniMax: Algoritmo ótimo (nunca perde se jogar primeiro)")
print("\nDica: MiniMax é invencível no Jogo da Velha!")

elif opcao == "5":
print("Até a próxima! 👋")
break

else:
print("Opção inválida. Tente novamente.")

# Executar o programa
if __name__ == "__main__":
main()
```

## 🎯 **O que este código oferece:**

### **4 Tipos de IA:**
1. **Aleatória** - Joga em qualquer posição vazia
2. **Centro Primeiro** - Estratégia básica humana
3. **Defensiva** - Tenta bloquear vitórias adversárias
4. **MiniMax** - Algoritmo ótimo (quase invencível)

### **Recursos:**
- ✅ **Torneio completo** entre todas as IAs
- ✅ **Partidas individuais** com visualização
- ✅ **Estatísticas detalhadas**
- ✅ **Sistema de pontuação**
- ✅ **Histórico de movimentos**

### **Como executar:**
```bash
python jogo_velha_ia.py
```

### **Próximas melhorias possíveis:**
1. **Interface gráfica com PyGame**
2. **Machine Learning** (IA que aprende com as partidas)
3. **Jogo da Velha 4x4** ou **5x5**
4. **Outros jogos**: Damas, Xadrez simplificado, Connect-4

**Quer que eu implemente alguma dessas melhorias ou prefere focar em outro tipo de competição entre IAs?** 🚀

Pesquisa neste blog

Info%%¢informática

Uma competição entre duas IAs em um jogo simples. Vou fazer o exemplo mais claro possível usando Jogo da Velha (Tic-Tac-Toe), onde IA X e IA O jogam uma contra a outra automaticamente.

🎮 Competição IA vs IA — Jogo da Velha

🧠 Código (IA X vs IA O)

🚀 O que fazer agora?