Uma brincadeira utilizada como exemplo em uma tutoria de introdução a programação a jovens que estão inciando nesse universo. A linguagem escolhida foi Java. :)

jogoDaVelhaNoTerminal.java

package com.company;

import java.util.Scanner;

public class Main {

//    OBS: comentários em um código podem ser feitos com // (que comenta uma linha) ou usando o /* para abrir e o */ para fechar o escopo do comentário

    public static void main (String[] args) {
        int jogador = 1;
        int linha, coluna;
        Scanner leitor = new Scanner(System.in);

        int quantidadeLinhasNoTabuleiro = 3;
        int quantidadeColunasNoTabuleiro = 3;
        int[][] jogo = inicializarJogo(quantidadeLinhasNoTabuleiro, quantidadeColunasNoTabuleiro);

        imprimirTabuleiro(jogo);

        System.out.println("O tabuleiro possue " + quantidadeLinhasNoTabuleiro + " linhas, e " + quantidadeColunasNoTabuleiro + " colunas.");

        do {
            System.out.println("Jogador " + jogador + " escolha a LINHA de 1 a " + quantidadeLinhasNoTabuleiro);
            linha = leitor.nextInt();
            System.out.println("Jogador " + jogador + " escolha a COLUNA de 1 a " + quantidadeColunasNoTabuleiro);
            coluna = leitor.nextInt();

            /*
              Um bom método de deixar um código fácil de ler é usar de uma técnica chamada FAILS FIRST (primeiro o erro).
              Que significa que o condicional deve sempre tratar daquilo que não queremos primeiro.
              Nesse caso, queremos números dentro que caibam no nosso tabuleiro, a exemplo, entre 1 e 3.
              Então, vamos procurar dizer que é errado qualquer número fora das opções.
            */
            if (linha < 1 || linha > quantidadeLinhasNoTabuleiro || coluna < 1 || coluna > quantidadeColunasNoTabuleiro) {
                System.out.println("Jogador " + jogador + " escolha novamente um número válido. Seu troll.");
                continue; // Lembrem-se do continue e do break; Continue faz o laço (loop) passar para próxima interação, não executando as linhas abaixo do continue. O break interrompe o laço e sai fora (vlw flw)
            }

            /*
            Estamos aceitando númeor de 1 a 3.
            Mas, lembrem-se que no array (matriz, lista) o primeiro ponto que podemos inserir um dado é no 0.
            Então, precisamos tratar do dado inserido reduzindo em 1 (decrementando) para que corresponda com o nosso tabuleiro
            */
            linha--;
            coluna--;

            /*
            Agora vamos verificar se alguém já jogoou na opção escolhida;
             */
            if (jogo[linha][coluna] != 0) {
                System.out.println("Deixe de sacanagem! Alguém já jogou aí, escolha um local onde ninguém tenha jogado.");
                continue;
            }

            jogo[linha][coluna] = jogador;


            /*
            Aqui usaremos um condicional em uma linha usando o ?
            É uma maneira mais bonita de fazer o if else, quando a condição eo resultado são pequenos.
            Assim se o jogodor é igual a 1, o jogador vai receber 2. Quando o jogador for igual a 2, o jogador vai receber 1. Trocando assim os jogadores.
             */
            jogador = jogador == 1 ? 2 : 1;

            imprimirTabuleiro(jogo);
        } while (verificarSeOJogoContinua(jogo));
        System.out.println("O JOGO SE ACABOOOU-SE.");
    }

    private static boolean verificarSeOJogoContinua (int[][] jogo) {
        /*
        Aqui mudei o nome da função para fazer sentido o condicional.
        O laço do {} while() vai continuar se o jogo ainda não estiver acabado.
        Então, devemos verificar as possibilidades do jogo acabar.

        Retonaremos falso (false) quando o jogo acabar, indicando que o jogo não deve continuer.
        Logo, retornaremos verdadeiro (true) enquanto o jogo não tiver vencedor.

        Lembrando que nosso jogo(3x3), no plano casteriano significa o seguinte.
                |
                | (0, 2)  (1, 2)  (2, 2)
                | (0, 1)  (1, 1)  (2, 1)
                | (0, 0)  (1, 0)  (2, 0)
              Y +---------------------------
          (X, Y) X
          [Y][X] na matriz do tabuleiro
              Onde, nesse caso,
              O X representa a coluna e
              o Y representa a linha.
         */

        int diagonal1 = 1, diagonal2 = 1; // Elemento neutro da multiplicação é o 1. Exemplo de incializar várias variáveis em uma mesma linha para um mesmo tipo
        diagonal1 = diagonal1 * jogo[0][0] * jogo[1][1] * jogo[2][2];
        diagonal2 = diagonal2 * jogo[0][2] * jogo[1][1] * jogo[2][0];

        if (diagonal1 == 1 || diagonal2 == 1) {
            System.out.println("Jogador 1 venceu na diagonal");
            return false;
        } else if (diagonal1 == 8 || diagonal2 == 8) {
            System.out.println("Jogando 2 venceu na diagonal");
            return false;
        }

        for (int variavelTrava = 0; variavelTrava < jogo.length; variavelTrava++) {
            int vitoriaEmLinha = 1; // Elemento neutro da multiplicação é o 1
            int vitoriaEmColuna = 1; // Elemento neutro da multiplicação é o 1

            /*
            Vamos andar na nossa matriz utilizando o laço abaixo.
            Em um primeiro laço da variávelTrava = 0 acontecerá assim:
            Para verificar a linha (0, X):
                jogo[0][0] depois jogo[0][1] e depois jogo[0][2]
            Para verificar a coluna (Y, 0):
                jogo[0][0] depois jogo[1][0] e depois jogo[2][0]
             */
            for (int variavelMovel = 0; variavelMovel < jogo[0].length; variavelMovel++) {
                /*
                Lembrem-se da lógica nesse cado. Vamos travar uma linha e depois uma coluna.
                A nossa variável que irá servir para travar será a variavelTrava e a que irá pecorrer será a variavelMovel.
                 */
                vitoriaEmLinha = vitoriaEmLinha * jogo[variavelTrava][variavelMovel];
                vitoriaEmColuna = vitoriaEmColuna * jogo[variavelMovel][variavelTrava];
            }

            /*
            Agora verificamos quem ganhou, se ganhou retornaremos false, para que a condição do laço while não seja verdadeira e saia do loop.
             */
            if (vitoriaEmLinha == 1) {
                /*
                Devemos somar mais 1 pelo menos motivo que subtraimos anteriormente.
                Para o usuário, não faz muito sentido linha 0 e coluna 0.
                Então fazemos uma mágina para que o usuário não se procupe. "O cliente em primeiro lugar" ou quase isso :D

                Nota-se que não usaremos variavelTrava++, porque essa expressão significa variavelTrava = variavelTrava + 1;
                E nós não queremos alterar o valor da variavelTrava aqui, isso acontece já na iteração do laço FOR
                 */
                System.out.println("Jogador 1 ganhou na linha " + (variavelTrava + 1));
                return false;
            } else if (vitoriaEmLinha == 8) {
                System.out.println("Jogador 2 ganhou na linha " + (variavelTrava + 1));
                return false;
            } else if (vitoriaEmColuna == 1) {
                System.out.println("Jogador 1 ganhou na coluna " + (variavelTrava + 1));
                return false;
            } else if (vitoriaEmColuna == 8) {
                System.out.println("Jogador 2 ganhou na coluna " + (variavelTrava + 1));
                return false;
            }
        }

        return true; // O JOGO CONTINUA
    }

    private static void imprimirTabuleiro (int[][] jogo) {
        /*
        jogo.length é uma função que as listas/matrizes (arrays) possuem.
        Ela retorna o tamanho, ou a quantidade de espaços, que podemos usar no array
        */
        for (int x = 0; x < jogo.length; x++) {
            /*
            jogo[0].length é a forma que podemos utilizar para saber o tamanho do nosso segundo nível na matriz.
            Assim deixamos nossa função de imprimir genérica, independente do tamanho do nosso tabuleiro.
            */
            for (int y = 0; y < jogo[0].length; y++) {
                System.out.printf(" %d ", jogo[x][y]);
            }
            System.out.printf("%n");
        }
    }

    private static int[][] inicializarJogo (int numLinhas, int numColunas) {
        int[][] novoJogo = new int[numLinhas][numColunas];
        for (int x = 0; x < numColunas; x++) {
            for (int y = 0; y < numLinhas; y++) {
                novoJogo[y][x] = 0;
            }
        }
        return novoJogo;
    }
}