Enviar um café pro programador

Jogo da Velha em Python: Como Programar

Neste tutorial de Python, vamos te mostrar como criar e programar o jogo da velha em Python, para dois usuários jogarem.

Jogo da Velha em Python


Faça um script em Python que permite que dois jogadores joguem o jogo da velha.


Lógica do jogo da velha

Vamos usar uma matriz (lista dentro de lista) de tamanho 3x3 de inteiros.
Um jogador vai escolher a linha e a coluna no tabuleiro, para jogar.

Se for o jogador 1, vai assinalar um X.
Se for o jogador 2, vai assinalar um O.

Porém, só pode inserir um X ou O se aquela posição estiver vazia.
Cada vez que o jogador joga, deve verificar se alguma linha, coluna ou diagonal foi preenchida, terminando o jogo, avisando quem ganhou e em quantas rodadas.

O Tabuleiro

Inicializamos o tabuleiro com valores iguais a 0:

board= [ [0,0,0],
         [0,0,0],
         [0,0,0] ]

Também podemos inicializar fazendo:
board = [ [0 for i in range(3)] for j in range(3)]

Em seguida, o código chama a função menu().




O menu

Criamos uma variável chamada continuar, com valor inicial 1.
Enquanto esse valor não for nulo, um laço while vai continuar perguntando se o jogador deseja jogar novamente, novamente e novamente.


Exibindo o tabuleiro do jogo da velha


Na função exibe() vamos imprimir o tabuleiro.

Quando o jogador 1 joga, insere o número inteiro 1 em um local do tabuleiro.
Se o jogador 2 joga, insere o número inteiro -1 em um local do tabuleiro.

Para exibirmos, vamos usar dois laços for aninhados.
O primeiro 'cuida' da linha e o segundo cuida das colunas.

Quando nos deparamos com o valor 0 no tabuleiros, mostramos: __
Para simbolizar que está vazio.

Se encontrar o número 1, printamos o caractere X.
Se encontrar o número -1, printamos o caractere O.

O jogo

A variável jogada é que vai contabilizar o número de rodadas. Obviamente, inicia com zero.
Essa variável vai ser incrementada de um em um, a cada rodada.

Se pegarmos o resto dessa divisão dessa variável por 2, teremos valor 0 e 1 alternando.
Se somarmos 1, teremos valores 1 e 2 alternando. Vamos avisar ao usuário se é o jogador 1 ou jogador 2 através dessa lógica.

Ou seja, cada jogador é simbolizado por: (jogada%2 + 1)

Primeiro, exibimos o tabuleiro, chamando a função exibe().

A seguir, pede uma linha e uma coluna.
Detalhe: o usuário vai digitar 1, 2 ou 3, mas nosso tabuleiro tem as posições 0, 1 e 2. Ou seja, quando o usuário fornecer esses números, temos que subtrair o valor de 1.

Em seguida, testamos se o valor que ele assinalou está vazio, ou seja, se tem um 0 naquela posição do tabuleiro.

Se sim, insere um 1 caso seja vez do jogador um ou -1 se for o jogador dois.

Se não for 0 a posição do tabuleiro, cai no ELSE, avisamos que não pode e subtraímos 1 da variável jogada, pois lá embaixo essa variável é sempre incrementada.

Após cada jogada, chamamos a função ganhou() dentro de um teste condicional.
Essa função checa se alguma linha, coluna ou diagonal está completa.
Se sim, termina o jogo e mostra quem ganhou, em quantas rodadas, se foi linha, coluna ou diagonal que se completou, e exibimos o tabuleiro final.

Caso a função ganhou() retorne 0, é porque ninguém ganhou, incrementamos a variável jogada e o loop while roda novamente uma outra rodada com o outro jogador.

Quem ganha o jogo da velha

Dentro da função ganhou(), fazemos três checagens.

Primeiro, se alguma linha tem soma de valor 3 ou -3, alguém ganhou e retornamos o valor 1.
Se alguma coluna tem soma 3 ou -3, alguém ganhou e retornamos o valor 2.
Por fim, somamos as diagonais, se alguma tiver valor 3 ou -3, retornamos o valor 3.

Se passar batido por esses testes, retornamos o valor 0, pra simbolizar que ninguém ganhou.




Código Python do Jogo da Velha



def menu():
    continuar=1
    while continuar:
        continuar = int(input("0. Sair \n"+
                              "1. Jogar novamente\n"))
        if continuar:
            game()
        else:
            print("Saindo...")

def game():
    jogada=0

    while ganhou() == 0:
        print("\nJogador ", jogada%2 + 1)
        exibe()
        linha  = int(input("\nLinha :"))
        coluna = int(input("Coluna:"))

        if board[linha-1][coluna-1] == 0:
            if(jogada%2+1)==1:
                board[linha-1][coluna-1]=1
            else:
                board[linha-1][coluna-1]=-1
        else:
            print("Nao esta vazio")
            jogada -=1

        if ganhou():
            print("Jogador ",jogada%2 + 1," ganhou apos ", jogada+1," rodadas")

        jogada +=1
    
def ganhou():
    #checando linhas
    for i in range(3):
        soma = board[i][0]+board[i][1]+board[i][2]
        if soma==3 or soma ==-3:
            return 1

     #checando colunas
    for i in range(3):
        soma = board[0][i]+board[1][i]+board[2][i]
        if soma==3 or soma ==-3:
            return 1

    #checando diagonais
    diagonal1 = board[0][0]+board[1][1]+board[2][2]
    diagonal2 = board[0][2]+board[1][1]+board[2][0]
    if diagonal1==3 or diagonal1==-3 or diagonal2==3 or diagonal2==-3:
        return 1

    return 0

def exibe():
    for i in range(3):
        for j in range(3):
            if board[i][j] == 0:
                print(" _ ", end=' ')
            elif board[i][j] == 1:
                print(" X ", end=' ')
            elif board[i][j] == -1:
                print(" O ", end=' ')

        print()
                

board= [ [0,0,0],
         [0,0,0],
         [0,0,0] ]

menu()

24 comentários:

  1. Seu código está bem enxuto, o meu deu 300 linhas. Só a parte de verificar quem ganhou ficou cheio de if e else

    ResponderExcluir
  2. Respostas
    1. Faz uma função que verifique se há movimento disponível. Se não há e ninguém ganhou então é empate.

      Excluir
    2. a gente sabe que são possiveis 9 jogadas por jogo. se todas as jogadas foram executadas e não ocorreram somas 3 ou -3, foi empate

      Excluir
  3. #Mostra a matriz do argumento
    def mostra (matriz):

    print (" 1 2 3")

    for i in range (3):
    print ("%d. "%(i+1), end=' ')
    for j in range (3):
    print("%2s "%matriz[i][j], end=' ')
    print()

    #Muda a matriz do primeiro argumento de acordo com a vez do jogador
    def muda(matriz,vez):
    print ("Jogador %d"%vez)
    linha=int(input ("Digite a linha: "))
    coluna=int(input("Digite a coluna: "))
    if vez==1:
    matriz[linha-1][coluna-1]='X'
    if vez==2:
    matriz[linha-1][coluna-1]='O'

    #Retorna a matriz modificada
    return matriz

    #Verifica o ganhador
    def ganhador(matriz):
    #Checando linhas
    for i in range (3):
    if ((matriz[i][0]+matriz[i][1]+matriz[i][2])=='XXX'):
    print("Jogador 1 é o vencedor")
    return True
    if ((matriz[i][0]+matriz[i][1]+matriz[i][2])=='OOO'):
    print("Jogador 2 é o vencedor")
    return True

    #Checando colunas
    for j in range(3):
    if ((matriz[0][j]+matriz[1][j]+matriz[2][j])=='XXX'):
    print("Jogador 1 é o vancedor")
    return True
    if ((matriz[0][j]+matriz[1][j]+matriz[2][j])=='OOO'):
    print("Jogador 2 é o vancedor")
    return True

    #Checando diagonais
    principal=''
    for d in range(3):
    principal+=(matriz[i][i])

    if (principal=='XXX' or (matriz[0][2]+matriz[1][1]+matriz[2][0])=='XXX'):
    print("Jogador 1 é o vencedor")
    return True
    if (principal=='XXX' or (matriz[0][2]+matriz[1][1]+matriz[2][0])=='OOO'):
    pritn("Jogador 2 é o vencedor")
    return True

    return False

    #Inicia a matriz
    matriz=[['#' for i in range (3)] for j in range (4)]

    #Mostra a o jogo todo zerado
    mostra(matriz)

    #Inicia as vezes dos jogadores
    while 1:
    mostra(muda(matriz,1))
    if ganhador(matriz):
    break
    mostra(muda(matriz,2))
    if ganhador(matriz):
    break

    print("Saindo...")

    ResponderExcluir
  4. Meu codigo com javascript no // Tabuleiro e Construção
    let construcao_Tabu = [ " "," "," ",
    " "," "," ",
    " "," "," "];

    // Desenho do Tabuleiro
    function exibir_tabuleiro(tab) {
    console.log(" " + tab[0] + " | " + tab[1] + " | " + tab[2]);
    console.log("=====================");
    console.log(" " + tab[3] + " | " + tab[4] + " | " + tab[5]);
    console.log("=====================");
    console.log(" " + tab[6] + " | " + tab[7] + " | " + tab[8]);
    }

    let jogador1= "X";
    let jogador2 = "O";
    exibir_tabuleiro(construcao_Tabu);

    // Tratamento de erro
    function erro_Digitacao(posi, t, jogador) {
    let c = 0;
    if(t[posi] == " ") {
    t[posi] = jogador;
    } else if(t[posi] != " ") {
    console.log("Erro esta posição esta ocupada");
    while(c <= 0) {
    let posi_n = parseInt(prompt("Digite a posição novamente " + jogador));
    if(t[posi_n] == " ") {
    t[posi_n] = jogador;
    break;
    }

    }
    }
    }

    // Jogador X e O

    var jogadas = 0;
    function jogadorX(JoX, tabu) {
    let posicao = parseInt(prompt("V_e_z d_o [ " + JoX + "]"));
    jogadas = jogadas + 1;
    erro_Digitacao(posicao, tabu, JoX);
    }

    function jogadorO(JoO, tabu) {
    let posicao = parseInt(prompt("V_e_z d_o [ " + JoO + "]"));
    jogadas = jogadas + 1;
    erro_Digitacao(posicao, tabu, JoO);
    }




    function Vencedor(tabu) {
    if ( tabu[0] == "X" && tabu[1] == "X" && tabu[2] == "X" || tabu[3] == "X" && tabu[4] == "X" && tabu[5] == "X" || tabu[6] == "X" && tabu[7] == "X" && tabu[8] == "X") {
    return true;
    } else if(tabu[0] == "X" && tabu[3] == "X" && tabu[6] == "X" || tabu[1] == "X" && tabu[4] == "X" && tabu[7] == "X" || tabu[2] == "X" && tabu[5] == "X" && tabu[8] == "X") {
    return true;
    } else if(tabu[0] == "X" && tabu[4] == "X" && tabu[8] == "X" || tabu[2] == "X" && tabu[4] == "X" && tabu[6] == "X") {
    return true;
    }

    if ( tabu[0] == "O" && tabu[1] == "O" && tabu[2] == "O" || tabu[3] == "O" && tabu[4] == "O" && tabu[5] == "O" || tabu[6] == "O" && tabu[7] == "O" && tabu[8] == "O") {
    return true;
    } else if(tabu[0] == "O" && tabu[3] == "O" && tabu[6] == "O" || tabu[1] == "O" && tabu[4] == "O" && tabu[7] == "O" || tabu[2] == "O" && tabu[5] == "O" && tabu[8] == "O") {
    return true;
    } else if(tabu[0] == "O" && tabu[4] == "O" && tabu[8] == "O" || tabu[2] == "O" && tabu[4] == "O" && tabu[6] == "O") {
    return true;
    }
    }


    var cont = 0;

    while(cont <= 4) {

    jogadorX(jogador1, construcao_Tabu);
    exibir_tabuleiro(construcao_Tabu);

    if(cont == 4) {
    console.log("X_O =--------------= E_M_P_A_T_E");
    break;
    }


    if( Vencedor(construcao_Tabu) == true){
    console.log("P+A+R+A+B+E+N+S..j..o..g..a..d..o..r [ X ] GANHOU");
    break;
    }

    jogadorO(jogador2, construcao_Tabu);
    exibir_tabuleiro(construcao_Tabu);

    Vencedor(construcao_Tabu);

    if( Vencedor(construcao_Tabu) == true){
    console.log("P+A+R+A+B+E+N+S..j..o..g..a..d..o..r [ O ] GANHOU");
    break;
    }
    cont++;
    }terminal do navegador

    ResponderExcluir
    Respostas
    1. Não estou conseguindo fazer em python teria como fazer usando listas e sem variáveis globais e funções impuras?

      Excluir
  5. O programa exibido tem um bug... tente XXO, OOX E XXO fica sem solução obrigando o jogador abortar o processamento.

    ResponderExcluir
  6. Este comentário foi removido pelo autor.

    ResponderExcluir
  7. ola, legal o código.
    estou montando um com esse tabuleiro : print("║█████████████║\n"+
    "║██ ██║\n"+
    "║██ ██║\n"+
    "║██ ██║\n"+
    "║██ ██║\n"+
    "║██ ██║\n"+
    "║██ ██║\n"+
    "║█████████████║", end="")

    porem estou com dificuldade de por em linhas e colunas esse desenho.
    alguem poderia me ajudar?

    ResponderExcluir
  8. o meu eu fiz assim

    matriz = [[0,0,0],[0,0,0],[0,0,0]]
    acerto1 = 0
    colunas = []
    ganhou = False
    while ganhou != True:
    print('Jogador 1')
    for valor in matriz:
    print(valor)
    linha = int(input('Escolha uma linha de 1 a 3'))
    coluna = int(input('Escolha uma coluna de 1 a 3'))
    matriz[linha-1][coluna-1] = 'x'
    for valor in matriz:
    print(f'{valor}')
    if valor.count('x') == 3:
    print('Ganhou')
    ganhou = True
    for i in range(0,3):
    colunas.append(matriz[0][i])
    colunas.append(matriz[1][i])
    colunas.append(matriz[2][i])
    if colunas.count('x') == 3:
    print('ganhou')
    ganhou = True
    else:
    colunas.clear()
    diagonal1 = []
    diagonal1.append(matriz[0][0])
    diagonal1.append(matriz[1][1])
    diagonal1.append(matriz[2][2])
    diagonal2 = []
    diagonal2.append(matriz[0][2])
    diagonal2.append(matriz[1][1])
    diagonal2.append(matriz[2][0])
    if diagonal1.count('x') == 3 or diagonal2.count('x') == 3:
    print('ganhou')
    ganhou = True
    diagonal1.clear()
    diagonal2.clear()
    if ganhou == True:
    break
    print('-'*30)
    print('Jogador 2')
    for valor in matriz:
    print(valor)
    linha = int(input('Escolha uma linha de 1 a 3'))
    coluna = int(input('Escolha uma coluna de 1 a 3'))
    matriz[linha-1][coluna-1] = 'o'
    for valor in matriz:
    print(f'{valor}')
    if valor.count('o') == 3:
    print('Ganhou')
    ganhou = True
    for i in range(0,3):
    colunas.append(matriz[0][i])
    colunas.append(matriz[1][i])
    colunas.append(matriz[2][i])
    if colunas.count('o') == 3:
    print('ganhou')
    ganhou = True
    else:
    colunas.clear()
    diagonal1 = []
    diagonal1.append(matriz[0][0])
    diagonal1.append(matriz[1][1])
    diagonal1.append(matriz[2][2])
    diagonal2 = []
    diagonal2.append(matriz[0][2])
    diagonal2.append(matriz[1][1])
    diagonal2.append(matriz[2][0])
    if diagonal1.count('x') == 3 or diagonal2.count('x') == 3:
    print('ganhou')
    ganhou = True
    diagonal1.clear()
    diagonal2.clear()

    ResponderExcluir
  9. como é que eu poderia adicionar a opção de singleplayer ao código

    ResponderExcluir
  10. import random
    import os
    import time
    def tela():
    global v
    global cpu
    global jog
    os.system('clear')
    print(' JOGADOR: ',jog, ' VS ', cpu, 'Maquina')
    print()
    print(' ',v[0]+' | '+v[1]+' | '+v[2])
    print(' ---+---+---')
    print(' ',v[3]+' | '+v[4]+' | '+v[5])
    print(' ---+---+---')
    print(' ',v[6]+' | '+v[7]+' | '+v[8])
    print()
    c_c =[]
    j=0
    c=0
    jog=0
    cpu=0
    v = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
    while True:
    tela()
    c_c =[]
    j=0
    c=0
    v = [' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ']
    while True:
    tela()
    # print("Jogadas: ",c_c)
    # jogadas do P1
    j = int(input('jogador joga: '))
    j-=1
    while v[j] != " ":
    if v[j] != " " :
    os.system('clear')
    tela()
    print('Pos Ocupado!')
    j = int(input('jogador joga:'))
    j-=1
    else:
    break
    v[j]='X'
    tela()
    time.sleep(0.3)
    c_c.append(j)
    c_c.copy()
    #verifica vitoria P1 ou Empate
    #Verifica linhas
    if v[0] ==v[1] ==v[2] == 'X' or v[3] ==v[4] ==v[5] == 'X' or v[6] ==v[7] ==v[8]== 'X':
    jog+=1
    tela()
    print(" Voce Venceu!")
    break
    #verifica colunas jogador
    elif v[0] ==v[3] == v[6] =='X' or v[1]== v[4]==v[7] == 'X' or v[2] ==v[5] ==v[8]== 'X':
    jog+=1
    tela()
    print(" Voce Venceu!")
    break
    #verifica diagonais jogador
    elif v[0] ==v[4] == v[8] =='X' or v[2]== v[4]==v[6] == 'X' :
    jog+=1
    tela()
    print(" Voce Venceu!")
    break
    #verifica Emlate
    elif len(c_c) == len(v):
    tela()
    print(' Velha...')
    break
    #Jogadas da Maquina
    c= random.randint(1,9)
    c-=1
    while v[c]!= " ":
    if v[c] != " " :
    os.system('clear')
    print(' Pos Ocupado!')
    c= random.randint(1,9)
    c-=1
    else:
    break
    v[c]='O'
    c_c.append(c)
    c_c.copy()




    ResponderExcluir
  11. # Verifica condição de vitoria da Maquina
    #verifica linhas da maquina
    if v[0] ==v[1] == v[2] =='O' or v[3]== v[4]==v[5] == 'O' or v[6] ==v[7] ==v[8]== 'O':
    cpu+=1
    tela()
    print(" Voce Perdeu!")
    break
    #verifica colunas da maquina
    elif v[0] ==v[3] == v[6] =='O' or v[1]== v[4]==v[7] == 'O' or v[2] ==v[5] ==v[8]== 'O':
    cpu+=1
    tela()
    print(" Voce Perdeu!")
    break
    #verifica diagonais da maquina
    elif v[0] ==v[4] == v[8] =='O' or v[2]== v[4]==v[6] == 'O' :
    cpu+=1
    tela()
    print(" Voce Perdeu!")
    break
    continuar= input('Continuar Jogando[S/N]? ')
    while continuar not in 'snsimnaoSNSimNao':
    print('Tente digitar [Sim ou Não].....')
    continuar= input('Continuar Jogando[S/N]? ')
    if continuar in 'ssimSSim':
    continue

    elif continuar in 'nNNaonao':
    break

    print( 'fim.....')

    ResponderExcluir
  12. Esse código foi feito usando o Pydroid3, está faltando a inteligência da maquina...

    ResponderExcluir
  13. meu codigo ficou com mais caracteres que o comentario daqui suporta hahah, isso porque eu coloquei muitas cores rsrsrs, mas esse é o link do meu git, se quiserem ver:
    https://github.com/MarcosSx/Jogo_da_velha/tree/master

    ResponderExcluir


  14. o meu ficou assim


    from random import randint
    from time import sleep
    lista = [[1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]]
    listadeJogadas = []
    vitoria = False
    sinais = ' X '


    def tela():
    for l in range(0, 3):
    for c in range(0, 3):
    if c < 2:
    print(f'{lista[l][c]:^5}|', end='')
    else:
    print(f'{lista[l][c]:^5}', end='')
    print()
    if l < 2:
    print('-' * 18)


    def jogadorJoga():
    global sinais
    global lista
    global listadeJogadas
    ok = False
    while True:
    n = int(input('Vez do jogador, Digite um numero para posição X : '))
    if n not in listadeJogadas:
    if 0 < n < 10:
    listadeJogadas.append(n)
    ok = True
    break
    else:
    print('Jogada invalida. ')
    if ok:
    for l in range(0, 3):
    for c in range(0, 3):
    if lista[l][c] == n:
    lista[l][c] = ' X '
    sinais = ' X '


    def computadorJoga():
    global sinais
    global lista
    global listadeJogadas
    global pergunta
    ok = False
    while True:
    if len(listadeJogadas) == 9:
    break
    n = randint(1, 9)
    if n not in listadeJogadas:
    if 0 < n < 10:
    listadeJogadas.append(n)
    ok = True
    break
    else:
    print('Jogada invalida. ')
    if ok:
    for l in range(0, 3):
    for c in range(0, 3):
    if lista[l][c] == n:
    lista[l][c] = ' O '
    if pergunta == 2:
    sinais = ' O '
    else:
    sinais = ' O '


    def verificarVitoria():
    global vitoria
    # Horizontal
    if lista[0][0] == lista[0][1] and lista[0][1] == lista[0][2]:
    vitoria = True
    if lista[1][0] == lista[1][1] and lista[1][1] == lista[1][2]:
    vitoria = True
    if lista[2][0] == lista[2][1] and lista[2][1] == lista[2][2]:
    vitoria = True
    # Diagonal
    if lista[0][0] == lista[1][1] and lista[1][1] == lista[2][2]:
    vitoria = True
    if lista[0][2] == lista[1][1] and lista[1][1] == lista[2][0]:
    vitoria = True

    # Vertical
    if lista[0][0] == lista[1][0] and lista[1][0] == lista[2][0]:
    vitoria = True
    if lista[0][1] == lista[1][1] and lista[1][1] == lista[2][1]:
    vitoria = True
    if lista[0][2] == lista[1][2] and lista[1][2] == lista[2][2]:
    vitoria = True


    maxJogadas = 0
    pergunta = input('Pronta para começar? (S/N): ')

    if pergunta == 's':
    while maxJogadas < 9:
    print('VOCÊ INICIA!')
    tela()
    jogadorJoga()
    tela()
    verificarVitoria()
    maxJogadas += 1
    if vitoria:
    print('Jogador Ganhou!')
    break
    print(f'Computador esta penssando em qual posição vai jogar {lista}...')
    sleep(2)
    computadorJoga()
    tela()
    verificarVitoria()
    maxJogadas += 1
    if vitoria:
    print('Computador Ganhou!')
    break

    if maxJogadas == 10:
    print('Deu velha!!!, NIGUEM GANHOU.')

    if maxJogadas == 10:
    print('Deu velha!!!, NIGUEM GANHOU.')

    ResponderExcluir
  15. fiz desse jeito também mas não esta funcionando direito
    import os
    import random


    jogarn='s'
    jogadas= 0
    quemjoga= 2 #1-maquina 2-usuariio
    mjogadas= 9
    vito= 'n'
    velha=[
    [' ',' ',' '],
    [' ',' ',' '],
    [' ',' ',' ']
    ]

    def limpa():
    global velha
    global jogadas
    os.system('cls')#para limpar a tela
    print(' 0 1 2')
    print('0: ' + velha[0][0] + ' | ' + velha[0][1] + ' | ' + velha[0][2])
    print(' -------------')
    print('1: ' + velha[1][0] + ' | ' + velha[1][1] + ' | ' + velha[1][2])
    print(' -------------')
    print('2: ' + velha[2][0] + ' | ' + velha[2][1] + ' | ' + velha[2][2])
    print(' -------------')
    print('jogadas: ' + str(jogadas))
    def jogador_joga():
    global jogadas
    global quemjoga
    global mjogadas
    if quemjoga == 2 and jogadasmjogadas):
    break

    print('fim de jogo')
    if(vito == 'x' or vito == 'o'):
    print('resultados' + vito + 'venceu')
    else:
    print('resultado: Empate')
    jogarnovamente = input('jogar novamente? [s/n]')
    redefinir()

    ResponderExcluir
  16. como eu faco para adicionar a opcao de o jogador 1 poder escolher entre X ou O

    ResponderExcluir
  17. qual melhor programa para se criar um jogo de terror com um grande espaço tipo granny, pp, evil nun?

    ResponderExcluir
  18. ratos imundos do caar,lgl
    ]

    ResponderExcluir
  19. desculpa foi sem querer

    ResponderExcluir