/* Jogo da Forca */

O jogo da forca consiste em acertar uma palavra secreta com o limite de x erros.
Para os mais iniciantes algumas funções podem parecer complexa, mas não são. A chToUpper() recebe um caractere e retorna seu equivalente em maiúsculo. A função fflush() limpa o buffer do teclado, ou seja, isso impede que o programa recolha lixo ao invés da entrada do usuário.
Nesta primeira versão, a palavra secreta já está no código-fonte. Melhorias em breve. :3

O jogo é simples e pequeno. Segue o código:

21/10/11: você pode ver a última versão com o código completo no meu repositório do GitHub: Jogo da Forca

#include <stdio.h>

char palavraSecreta[] = "OVERFLOW";
int letrasUsadas[256] = { 0 };
char palavraDescoberta[] = "--------";
int vida = 5;

void showTelaInicial(){
     printf("\t\t\t\t ------- \n");
     printf("\t\t\t\t| Forca |\n");
     printf("\t\t\t\t ------- \n");
     printf("\n\n\n\nPressione <ENTER> para continuar...");
     getchar();
}

int chToUpper(char ch){
     return ch & ~32;
}

void printLetrasUsadas(){
     int i;
     printf("\t\t\tLetras usadas: [ ");
     for(i = 65; i < 91; i++)
           if(letrasUsadas[i]) printf("%c ", i);
     printf("]\n");
}

void printPalavraDescoberta(){
     int i;
     printf("\n\t\t\t=> ");
     for(i = 0; palavraSecreta[i]; i++)
           printf("%c ", palavraDescoberta[i]);
     printf("<=\n");
}

char chutaLetra(){
     char ch;
     printf("\t\t\tNova letra: ");
     fflush(stdin);
     scanf("%c", &ch);
     return chToUpper(ch);
}

int verificaLetraUsada(int letra){
    if(letrasUsadas[letra]) return 1;
    return 0;
}

int chuteCerto(char ch){
    int i;
    int acertou = 0;
    for(i = 0; palavraSecreta[i]; i++)
          if(palavraSecreta[i] == ch){
             palavraDescoberta[i] = ch;
             acertou = 1;
          }
    return acertou;
}

int terminou(){
     int i;
     for(i = 0; palavraSecreta[i]; i++)
           if(palavraDescoberta[i] == '-') return 0;
     
     return 1;
}

void play(){
     char chute;
     while(vida){
          system("cls");
          printf("\n\n");
          
          printLetrasUsadas();
          printf("\t\t\tVidas: %d\n", vida);
          printPalavraDescoberta();
          chute = chutaLetra();
          
          if(!verificaLetraUsada(chute)){
             letrasUsadas[chute] = 1;
             if(!chuteCerto(chute)) vida--;
             else if(terminou()) break;
          }
          else{
             printf("\t\t\tLetra ja utilizada... <ENTER>");
             fflush(stdin);
             getchar();
          }
          
          
     }
     system("cls");
     if(!vida) printf("\n\n\t\t\t\tVoce perdeu...");
     else printf("\n\n\t\t\tParabens, voce ganhou");
     fflush(stdin);
     getchar();
}

int main(){
    showTelaInicial();
    play();

    return 0;
}

/* Jogo da velha */

Trago-lhes um simples jogo da velha feito em C.

O jogo consiste em você jogar contra o computador. Na função main há um loop que, analogamente, é o "coração" do jogo.

A função init_matriz inicializa a matriz 3x3 com espaços, para que assim fique melhor sua exibição. A função disp_matriz mostra o "tabuleiro" formatado na tela do console. A função move_jogador e move_cpu são, respectivamente, para a sua jogada e a jogada do computador. A função check_vencedor verifica se alguém ganhou o jogo, pela linha, coluna ou diagonal.

Como o programa foi desenvolvido apenas de forma didática, o computador não possui nenhuma "inteligência", sendo assim, na sua vez ele simplesmente procura um espaço em branco e joga nele. Para implementar algum tipo de IA, é necessário apenas modificar a função move_cpu.

12/10/11:
Você pode ver o código do jogo completo no meu repositório no GitHub: Jogo da Velha
22/10/11:
Código no repositório adaptado para rodar tanto em Windows quanto em Linux.

-----

#include <stdio.h>

char matriz[3][3];

void init_matriz(){
     int i, j;
     
     for(i = 0; i < 3; i++)
        for(j = 0; j < 3; j++) matriz[i][j] = ' ';
}

void disp_matriz(){
     int i, j;
     printf(" --- --- --- \n");
     for(i = 0; i < 3; i++){
        printf("|");
        for(j = 0; j < 3; j++) printf(" %c |", matriz[i][j]);
        printf("\n|---|---|---|\n");
     }
}

void move_jogador(){
     int x, y;
     printf("\n\nDigite em qual pos(x, y) deseja jogar: ");
     scanf("%d%d", &x, &y);
     x--;
     y--;
     
     if(matriz[x][y] != ' '){
        printf("Posicao invalida ou ja jogada, tente novamente...\n\n");
        move_jogador();
     }
     else matriz[x][y] = 'X';
}

void move_cpu(){
     int i, j;
     
     for(i = 0; i < 3; i++){
        for(j = 0; j < 3; j++)
              if(matriz[i][j] == ' ') break;
        if(matriz[i][j] == ' ') break;
     }
     
     if(i*j == 9){
            printf("\nEMPATE");
            getchar();
            exit(0);
     }
     else matriz[i][j] = 'O';
}

char check_vencedor(){
     int i;
     
     for(i = 0; i < 3; i++)
        if( (matriz[i][0] == matriz[i][1]) && (matriz[i][0] == matriz[i][2]) )
           return matriz[i][0];
           
     for(i = 0; i < 3; i++)
        if( (matriz[0][i] == matriz[1][i]) && (matriz[0][i] == matriz[2][i]) )
           return matriz[0][i];
           
     if( (matriz[0][0] == matriz[2][2]) && (matriz[1][1] == matriz[2][2]) )
        return matriz[1][1];
     if( (matriz[1][1] == matriz[0][2]) && (matriz[1][1] == matriz[2][0]) )
        return matriz[1][1];
     
     return ' ';
}

int main(){
    char terminado = ' ';
    
    printf("\t\tJogo da Velha :)\n");
    printf("Modo: vs cpu\n\n");
    init_matriz();
    do{
       disp_matriz();
       move_jogador();
       terminado = check_vencedor();
       
       if(terminado != ' ') break;
       
       move_cpu();
       terminado = check_vencedor();
    }while( terminado == ' ');
    
    if(terminado == 'X') printf("\n\nParabens, voce venceu!\n");
    else printf("\n\nQue pena, voce perdeu!\n");
    
    disp_matriz();
    fflush(stdin);
    getchar();
    return 0;
}

-----



Divirtam-se, façam modificações e code it! :)

Bubble Sort (Método da bolha)

Bubble sort é um algoritmo de ordenação de vetores. Ele é um dos mais simples de se entender e implementar. O algoritmo consiste em comparar um numero na posição n e n+1 e, caso n for maior, eles trocam de posição. Por isso é chamado de método da bolha, pois ele vai jogando o maior para o final do vetor, formando bolhas.

-----

#include "stdio.h"

void troca( int *a, int *b ){

      int aux = *a;

      *a = *b;

      *b = aux;

}

void bubbleSort( int array[], int tamanho ){

      int i, j;

            for( i = 0; i < tamanho-1; i++ )

for( j = i+1; j < tamanho; j++ )

if( array[i] > array[j] ) troca( &array[i], &array[j] );

}

int main(){

     int array[] = { 2, 7, 1, 0, 20 };

     bubbleSort( array, 5 );

     return 0;

}

-----

Este algoritmo é bem útil, tendo em vista que constantemente precisamos fazer ordenações em nossos programas :)

Para quem não entendeu o que se está passando, este vídeo inusitado pode te ajudar:

Converge()

Este é um daqueles programas aparentemente inúteis, porém divertidos.

A grande sacada deste programa é a função converge. Esta função escreve no console uma string convergindo para o meio, isto é:

- letra 0;

- letra n;

- letra 1;

- letra n-1;

...

De forma que o texto passado por parâmetro seja por fim escrito.

Let's to the code:

-----

#include "stdio.h"

#include "windows.h"

int tamanhoString(char *str){

     int tamanho = 0;

     while(*str){

        tamanho++;

        *str++;

     }

     return tamanho;

}

void gotoxy(int x, int y){

      COORD c;

      c.X = x;

      c.Y = y;

      SetConsoleCursorPosition (GetStdHandle(STD_OUTPUT_HANDLE), c);

}

void converge( int line, char *msg ){

      int i, j;

            for( i = 1, j = tamanhoString(msg); i < j; i++, j-- ){

            gotoxy(i, line);

            printf("%c", msg[i-1]);

            gotoxy(j, line);

            printf("%c", msg[j-1]);

      }

}

int main(){

     converge(10, "Testando a funcao converge()");

     getchar();

     return 0;

}

-----

Como você pôde perceber, utilizamos uma função já implementada: SetConsoleCursorPosition.

Por este motivo, incluímos a biblioteca windows.h e, obviamente, este programa só funciona em ambiente Windows. Para quem utiliza Linux, se não me engano, utilizamos a biblioteca graph.h para usar a função já implementada gotoxy();

Codificar com complemento

E o dia que você quiser codificar algum texto?

Pois bem, temos métodos simples como descolamento de x bits para direita ou esquerda, e também métodos mais bem elaborados que são utilizados no mercado, como a criptografia RSA.

Pois bem, este método que irei apresentar é super simples(e bobo), por isso não aconselho a usar-lo para situações sérias, onde necessite de um certo nível de segurança.

O operador '~' em C complementa os bits de uma variável. Por exemplo:

- Temos o caractere 'A', que vale 65 na tabela ASCII. Fazemos então o complemento a 1, ou seja, trocaremos 0 por 1 e 1 por 0 no valor de 65 em binário ( 65 = 1000001 ).

Teremos então como saída 0111110, que é um caractere desconhecido.

Para voltar ao valor original, basta complementar novamente.

Chega de explicação e vamos ao programa com a função 'encoder':

-----

#include "stdio.h"

void encoder(char *string){

      while(*string){

         *string = ~*string;

         *string++;

      }

}

int main(){

     char str[] = { "Testando o encoder" };

     printf("Texto original: %s\n", str);

     encoder(str);

     printf("Texto codificado: %s\n", str);

     encoder(str);

     printf("Texto decodificado: %s\n", str);

     getchar();

     return 0;

}

-----

O programa imprime a string original e então a codifica.

Imprime a string codifica e decodifica. E imprime novamente mostrando que a string original está de volta.