JOGO DA VELHA - USUÁRIO X COMPUTADOR

Este jogo da velha feito em linguagem C impressiona pelo
seu excelente desempenho, não deixando nada a desejar
em relação a um profissional.
As diversas funções criadas trabalham em conjunto, para que
o programa atinja seu objetivo.
Um dos destaque do programa é o placar em tempo real
exibindo os resultados enquanto se joga, e o deslocamento
do mesmo em outra posição da tela, graças a função movetext();
da conio.h, que move uma determinada área de texto e posiciona
onde bem queremos, na verdade parece mesmo uma cópia, já que
o texto original se mantém no lugar.
O programa permite até nove jogos por vez, sendo sempre iniciado
pelo jogador, e quando termina, á máquina começa jogando o segundo,
e assim vai alternando até que chegue o final das nove partidas,
más dando a opção de começar tudo de novo.
O programa está capacitado para atacar e se defender, em todas
as jogadas, está praticamente impossível vencê-lo,más resolvi
deixar umas duas brechas que se for descoberta o usuário poderá
ganhar.

WORLD CUP 2018

Uma matriz de string de 32 posições contendo em cada posição
o nome de uma seleção que participou da copa do mundo de 2014
no Brasil, é o ponto principal deste programa.
Tudo começa com a impressão da matriz seleções [ ] [ ];
na tela do dos, que está  carregada com os nomes de cada seleção em suas posições,
más o chamado é aleatório, e tem de ser, pra que o programa atinja seu objetivo
que é formar 8 grupos de quatro seleções a partir da original de 32.
Então está claro que 8 matrizes de string foram declaradas para
que recebam a cópia de quatro seleções em ordem aleatória cada uma.
Veja agora como funciona no vídeo, e o código será liberado logo mais.
Veja abaixo o vídeo do programa em execução:

Vetores aleatórios - Pares e ímpares

Encontrar números pares e ímpares num vetor de inteiros
não é tarefa difícil para estudantes de linguagem C, más
fazê-lo como fiz neste exemplo não é tão simples.
O programa aqui proposto, chama um número por vez dentro
de um vetor mestre, e vai copiando cada número no vetor
correspondente, que são dois vetores dinâmicos declarados,
um para números pares e outro para números ímpares.
Terminando a sequência comandada por um laço for(); já temos
dois vetores que foram preenchidos automaticamente com os
números pares e ímpares.

Veja o vídeo do programa abaixo:

Vetores Aleatórios - Primos e não Primos

Encontrar números primos e não primos num vetor de inteiros
não é tarefa difícil para estudantes de linguagem C, más
fazê-lo como fiz neste exemplo não é tão simples.
O programa aqui proposto, chama um número por vez dentro
de um vetor mestre, e vai copiando cada número no vetor
correspondente, que são dois vetores dinâmicos declarados,
um para números primos e outro para números não primos.
Terminando a sequência comandada por um laço for(); já temos
dois vetores que foram preenchidos automaticamente com os
números primos e não primos.

Veja o vídeo do programa abaixo:

Vetores aleatórios

Na importante função Sorteia ( int *vet ); que cria um vetor de inteiros com 32 elementos, e embaralha, temos também a função srand (); da biblioteca stdlib.h do C, garantindo que
as sequências não seja sempre as mesmas, já que o programa opera em três rodadas.
A impressão destes valores aleatórios vem de uma forma bem organizada em duas linhas, com os elementos lado a lado e um em baixo do outro.
Os números são chamados aleatoriamente e são copiados um por um
nos vetores de 8 posições começando pelo primeiro, e quando termina passa para o segundo, e segue até que o quarto vetor também já esteja completo.
Então vem as impressões dos mesmos, antes que mais uma rodada seja chamada,
vindo o término na terceira, invocando o final do programa.

Operadores aritiméticos de atribuição

Primeiro analise os seguintes comandos abaixo:

int a = 10, b = 20, c = 30, d = 40, e = 50;

        a = a + 7;  ==>  a +=    7;
b = b - 4;  ==>   b -=    4;
        c = c * 5;  ==>   c *=     5;
        d = d / 3;  ==>   d /=     3;
e = e % 9; ==>   e %=   9;

É muito comum quando estamos programando atribuir um determinado valor
a uma variável, aliás, isto é fato, uma variável sem valor pode exibir lixo
na saída, bons compiladores detectam quando uma variável precisa ser inicializada.
Más o que ocorre é que muitas vêzes temos que atribuir o resultado de uma
expressão a uma variável, e se ela já possui um valor será atualizado com o
novo valor da expressão.
O que quero mostrar aqui é uma técnica adotada por C usando uma forma abreviada,
estas abreviações estão do lado direito das atribuições mostrada no exemplo acima.
Estas operações são equivalentes e cabe ao bom programador utilizá-las.
Os operadores +=, -=, *=, /=, e %= chamam-se operadores aritiméticos de atribuição
e o seu uso é fácil e recomendável.

Veja abaixo uma imagem exemplo do programa em execução:

Veja abaixo o código do programa:

#include <stdio.h>

#include <conio.h>

void got_color ( int tam_lin_ini, int tam_lin_fim, int tam_ini_col,

         int tam_fim_col, int a, int b ) {

     int i, c;

     if ( a <= 16 ) {

         textcolor ( a );

     }

     if ( b <= 16 ) {

         textbackground ( b );

     }

     for ( i = tam_lin_ini; i < tam_lin_fim; i++ ) {

         for ( c = tam_ini_col; c < tam_fim_col; c++ ) {

              gotoxy ( c, i );

              printf ( " " );

         }

     }

}

int main ( ) {

     system ( "title OPERADORES ARITIMÉTICOS DE ATRIBUIÇÃO" );

     got_color ( 2, 25, 3, 79, 0, 15 );

     textcolor ( LIGHTRED );

     gotoxy ( 22, 3 );

     printf ( "OPERADORES ARITIMÉTICOS DE ATRIBUIÇÃO" );

    int a = 10, b = 20, c = 30, d = 40, e = 50;

     a += 7;

     //a = a + 7 ;

     b -= 4;

     //b = b - 4 ;

     c *= 5;

     //c = c * 5 ;

     d /= 3;

     //d = d / 3 ;

     e %= 9;

     //e = e % 9 ;

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 5 );

     printf ( "Declaramos as variáveis e atribuímos um valor a cada uma" );

     textcolor ( BLACK );

     gotoxy ( 12, 7 );

     printf ( "int a = 10, b = 20, c = 30, d = 40, e = 50;" );

     textcolor ( LIGHTRED );

     gotoxy ( 12, 9 );

     printf ( "Atribuição normal%19sAtribuição abreviada", " ");//Formatação de saída com printf

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 11 );

     printf ( "a = a + 7;%14s==>%12sa += 7;", " ", " " );//Formatação de saída com printf

     textcolor ( LIGHTRED );

     printf ( " %d", a );

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 12 );

     printf ( "b = b - 4;%14s==>%12sb -= 4;", " ", " " );//Formatação de saída com printf

     textcolor ( LIGHTRED );

     printf ( " %d", b );

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 13 );

     printf ( "c = c * 5;%14s==>%12sc *= 5;", " ", " " );//Formatação de saída com printf

     textcolor ( LIGHTRED );

     printf ( " %d", c );

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 14 );

     printf ( "d = d / 3;%14s==>%12sd /= 3;", " ", " " );//Formatação de saída com printf

     textcolor ( LIGHTRED );

     printf ( " %d", d );

     textcolor ( LIGHTBLUE );

     gotoxy ( 12, 15 );

     printf ( "e = e %% 9;%14s==>%12se %%= 9;", " ", " " );//Formatação de saída com printf

     textcolor ( LIGHTRED );

     printf ( " %d", e );

     Sleep ( 1800 );

     textcolor ( LIGHTBLUE );

     gotoxy ( 26, 19 );

     printf ( "Por: " );

     textcolor ( LIGHTMAGENTA );

     printf ( "Samuel Lima" );

     textcolor ( BLACK );

     gotoxy ( 26, 20 );

     printf ( "sa_sp10@hotmail.com" );

     Sleep ( 1800 );

     textcolor ( LIGHTRED );

     gotoxy ( 37, 23 );

     printf ( "MUITO OBRIGADO" );

     getche ( );

}

Operadores aritiméticos - Incremento e decremento de Sufixo

Estes operadores são tão comuns que as vêzes até esquecemos que são operadores aritiméticos.
Para incrementar o valor de uma variável primeiro ela é declarada depois atribuímos à
variável o valor + 1, veja abaixo:
int a;
a = a + 1;
Más esta prática pode ser resumida já que temos uma abreviação simples pra isto,
que é utilizando o operador de incremento ++, veja abaixo:
a++;//Este é o operador de incremento de sufixo de C.
++a;//Este é o operador de incremento de prefixo de C.
Estes dois comandos acima incrementam a variável a por 1.
Só que temos que observar o modo como o C trata estes operadores de incremento
sufixo e prefixo, não são do mesmo modo.
Quando estamos usando o operador de incremento de sufixo, O C por padrão, usa
primeiro o valor da variável, em seguida vem a operação de incremento.
E quando estamos usando o operador de incremento de prefixo, o valor da variável
é incrementado primeiro, depois que vem o uso da variável.
Quando estamos programando, em algumas situações ocorre a necessidade de retirarmos
uma unidade de um determinado valor, e isto é perfeitamente possível usando o
operador de Decremento de C.
Para decrementar o valor de uma variável primeiro ela é declarada depois diminuímos à
variável o valor - 1, veja abaixo:
int a;
a = a - 1;
Más esta prática pode ser resumida já que temos uma abreviação simples pra isto,
que é utilizando o operador de decremento --, veja abaixo:
a--;//Este é o operador de Decremento de sufixo de C.
--a;//Este é o operador de Decremento de prefixo de C.
Estes dois comandos acima decrementam a variável a em menos 1.
Temos que observar o modo como o C trata estes operadores de decremento
sufixo e prefixo, não são do mesmo modo.
Quando estamos usando o operador de decremento de sufixo, O C por padrão, usa
primeiro o valor da variável, em seguida vem a operação de decremento.
E quando estamos usando o operador de decremento de prefixo, o valor da variável
é decrementado primeiro, depois que vem o uso da variável.

Para mostrar como funciona os operadores aritiméticos de incremento e decremento,
de sufixo criei este programa, que conta o número de ciclo dentro de um laço while();
No primeiro bloco a variável x é inicializada em zero, más a cada entrada dentro do
laço while(); é incrementada em  1 até que seu valor se iguale a macro tam.
No segundo bloco, à cada entrada dentro do laço while(); a variável x que é
inicializada pela macro tam é decrementada em 1, começando pelo valor da macro
e indo até 0 de onde vem a saída do programa.
Esta cadeia de ifs(); utilizadas nos dois blocos servem para posicionar junto com
gotoxy(); as impressões na tela do dos.

Veja abaixo uma imagem do programa em execução:

Veja abaixo o código do programa:

#include <stdio.h>

#include <conio.h>

#define tam 9

void got_color ( int tam_lin_ini, int tam_lin_fim, int tam_ini_col,

         int tam_fim_col, int a, int b ) {

     int i, c;

     if ( a <= 16 ) {

         textcolor ( a );

     }

     if ( b <= 16 ) {

         textbackground ( b );

     }

     for ( i = tam_lin_ini; i < tam_lin_fim; i++ ) {

         for ( c = tam_ini_col; c < tam_fim_col; c++ ) {

              gotoxy ( c, i );

              printf ( " " );

         }

     }

}

int main ( ) {

     system ( "title OPERADORES ARITIMÉTICOS - INCREMENTO E DECREMENTO DE SUFIXO" );

     got_color ( 2, 25, 3, 79, 0, 15 );

     int i, x;

     textcolor ( LIGHTRED );

     gotoxy ( 12, 3 );

     printf ( "OPERADORES ARITIMÉTICOS - INCREMENTO E DECREMENTO DE SUFIXO" );

     textcolor ( LIGHTBLUE );

     gotoxy ( 22, 5 );

     printf ( "INCREMENTO" );

     x = 0;

     for ( i = 0; i < tam; i++ ) {

         do {

              x++;

              textcolor ( LIGHTRED );

              if ( x == 1 )

                   gotoxy ( 23, 7 );

              if ( x == 2 )

                   gotoxy ( 23, 8 );

              if ( x == 3 )

                   gotoxy ( 23, 9 );

              if ( x == 4 )

                   gotoxy ( 23, 10 );

              if ( x == 5 )

                   gotoxy ( 23, 11 );

              if ( x == 6 )

                   gotoxy ( 23, 12 );

              if ( x == 7 )

                   gotoxy ( 23, 13 );

              if ( x == 8 )

                   gotoxy ( 23, 14 );

              if ( x == 9 )

                   gotoxy ( 23, 15 );

              printf ( "%dº", x + 0 );

              textcolor ( BLACK );

              printf ( " Ciclo" );

              getche ( );

              break;

         } while ( 1 );

     }

     textcolor ( LIGHTBLUE );

     gotoxy ( 49, 5 );

     printf ( "DECREMENTO" );

     x = tam;

     for ( i = 0; i < tam; i++ ) {

         do {

              x--;

              textcolor ( LIGHTRED );

              if ( x == 0 )

                   gotoxy ( 50, 15 );

              if ( x == 1 )

                   gotoxy ( 50, 14 );

              if ( x == 2 )

                   gotoxy ( 50, 13 );

              if ( x == 3 )

                   gotoxy ( 50, 12 );

              if ( x == 4 )

                   gotoxy ( 50, 11 );

              if ( x == 5 )

                   gotoxy ( 50, 10 );

              if ( x == 6 )

                   gotoxy ( 50, 9 );

              if ( x == 7 )

                   gotoxy ( 50, 8 );

              if ( x == 8 )

                   gotoxy ( 50, 7 );

              if ( x == 9 )

                   gotoxy ( 50, 6 );

              printf ( "%dº", x + 1 );

              textcolor ( BLACK );

              printf ( " Ciclo" );

              getche ( );

              if ( x == 0 ) {

                   textcolor ( LIGHTBLUE );

                   gotoxy ( 31, 17 );

                   printf ( "Imprimido corretamente" );

                   Sleep ( 1800 );

                   textcolor ( LIGHTBLUE );

                   gotoxy ( 26, 19 );

                   printf ( "Por: " );

                   textcolor ( LIGHTMAGENTA );

                   printf ( "Samuel Lima" );

                   textcolor ( BLACK );

                   gotoxy ( 26, 20 );

                   printf ( "sa_sp10@hotmail.com" );

                   Sleep ( 1800 );

                   textcolor ( LIGHTRED );

                   gotoxy ( 37, 23 );

                   printf ( "MUITO OBRIGADO" );

                   getche ( );

              }

              break;

         } while ( 1 );

     }

     return 0;

}