C Jogo da memória em C

Michel De Lima · 28 de outubro de 2021

Olá a todos!, estou desenvolvendo um programa em C de "jogo da memória", em uma matriz 8x8 que gera letras aleatória a cada execução do programa, as letras são armazenadas nesse vetor:

vetor[C]= 'A' + (char)(rand()%26*2);

Preciso que gere um par de cada letra dentro da matriz 8x8 e dessa forma só esta embaralhando "as cartas" com 3 e até 4 das mesmas.

Como faço para sair apenas pares de letras?

devair1010 · 28 de outubro de 2021

@Michel De Lima você Quer dizer que vai gerar duas letras iguais ? ?
se for assim , então esse vetor , que na verdade é uma Matriz , precisa ser do tipo string , que em C é um vetor de char ,
assim :

#include   <string.h>
char matriz[8][8][2];    // Linha Coluna qtd de caracteres
char          str[3];    // dois caracteres e um '\0' finalizador de string
int       Linha  = 0;    // posicao da Linha  na matriz
int       coluna = 0;    // posicao da coluna na matriz

e na geração pode ser assim :

str[0] = 'A'  +  (char)(rand() % 26;
str[1] =                     str[0];
str[2] =                       '\0';                      
strcpy(matriz[Linha][coluna] , str);

Michel De Lima · 28 de outubro de 2021

@devair1010 Isso, exatamente, é um jogo da memoria da faculdade, então preciso preencher essa matriz 8x8 com um vetor aleatório. Fiz o teste com meu algoritmo e ele está gerando a mesma letra algumas letras 3 vezes ou 4 vezes, preciso que todas sejam pares, tipo AA, BB, CC,

segue meu codigo...

#include <stdio.h> //funções de entrada/saída
#include <stdlib.h> //funções de uso geral
#include <time.h> //funções que pega a hora do PC como base
#include <locale.h> //funções de idiomas
#define N 8 //número de linhas e colunas
#define C 64 //número de cartas

int main()
{
	//variáveis
	char mat[N][N], vet[C];
    int i, j, n;
	setlocale(LC_ALL, "Portuguese");
    fflush(stdin);

    printf("\n---------------------------------------------\n");
    
    //Preenchendo a matriz com as cartas
    for(i=0; i<7; i++)
    {
        for(j=0; j<7; j++)
        {
			vet[C]= 'A' + (char)(rand()%26);
            mat[i][j] = vet[C];
            printf("%2c | ", mat[i][j]);
        }
        printf("\n");
								    }
    printf("---------------------------------------------\n");

system("Pause");
return 0;
}

devair1010 · 28 de outubro de 2021

@Michel De Lima veja se é assim que pretende fazer :

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>                 //  funções de entrada/saída
#include <stdlib.h>                //  funções de uso geral
#include <time.h>                  //  funções que pega a hora do PC como base
#include <locale.h>                //  funções de idiomas
#define N 8                        //  número de linhas e colunas
#define C 64                       //  número de cartas
#include   <string.h>
int main()
{
                                   //  variáveis
    char matriz[N][N][3];          //  Linha Coluna qtd de caracteres
    char          str[3];          //  dois caracteres e um '\0' finalizador de string
    int        Linha = 0;          //  posicao da Linha  na matriz
    int       coluna = 0;          //  posicao da coluna na matriz

    char mat[N][N], vet[C];        //  essa matriz só pode armazenar hum caract em cada 
                                   //  posicao dela e o vetor vet pode armazenar mais de um 
                                   //  caract , pois tem mais de uma posicao
    int i, j, n,pos=0;             //  pos serve para incrementar as posições no vetor
    setlocale(LC_ALL, "Portuguese");

    printf("\n---------------------------------------------\n");

                                   //  Preenchendo a matriz com as cartas
    for (i = 0; i < 8; i++)
    {
        for (j = 0; j < 8; j++)
        {
            str[0] = 'A' + (char)(rand() % 26);
            str[1] = str[0];
            str[2] = '\0';
            strcpy(matriz[i][j], str);
            printf("%s | ", matriz[i][j]);
                                   //  armazena uma letras em cada uma das posições de vet
                                   //  pois em vet[C] não existe a posicao 64 , só vai de zero ate 63
            vet[pos] = str[0];     //  para que colocar primeiro no vetor
                                   //  mat[i][j] = vet[pos];
                                   //  printf("%2c | ", mat[i][j]);
            pos++;
        }
        printf("\n");
    }
    printf("---------------------------------------------\n");

    system("Pause");
    return 0;
}

Michel De Lima · 28 de outubro de 2021

@devair1010 Quase isso, é apenas uma letra em cada célula, o usuario escolhe 2 celulas, se forem iguais ele marca um ponto e por ai vaii...

O tabuleiro precisa ter 64 caracteres, e 32 pares de caracteres (char).

Matriz 8x8.

devair1010 · 28 de outubro de 2021

@Michel De Lima o usuario escolhe duas células da matriz e se essas duas células escolhidas tiver a mesma letra , marca um ponto na matriz que é o tabuleiro . ? , entao as letras não vão aparecer na tela , e no lugar das letras vai aparecer um espaço vazio em branco ? ,

entao para gera duas letras ?

Michel De Lima · 29 de outubro de 2021

@devair1010 Exatamente isso.

A letras não podem aparecer também no começo.

arfneto · 29 de outubro de 2021

Eu postei um programa completo em C em

que faz isso. Talvez deva olhar lá e ver a discussão toda.

Michel De Lima · 29 de outubro de 2021

@arfneto obrigado!

arfneto · 29 de outubro de 2021

@Michel De Lima não me lembro mais do programa mas se não entender me avise e eu olho de novo

Michel De Lima · 29 de outubro de 2021

@arfneto @devair1010 fiz aqui meu algoritmo, meu jogo esta quase pronto se quiserem dar um feedback :)..

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#include <conio.h>
#define N 8
#define C 64

int main()
{
    char mat[N][N], nome[50], vet[C], jogada[2][2];
    int i, j, c, n, opcao, pts=0, t=10;
    system("title JOGO DA MEMÓRIA 1.0 BY MICHEL");
    setlocale(LC_ALL, "Portuguese");
    fflush(stdin);
    system("color 0B");
    srand(time(NULL));

    printf(" #############################################\n");
    printf(" ###### Bem vindo (a) ao jogo da memória #####\n");
    printf(" #############################################\n");
    printf(" ---------------------------------------------\n");
    printf(" [1] JOGAR\n");
    printf(" [2] SAIR\n");
    printf(" ---------------------------------------------\n");
    printf(" Escolha uma opção: ");
    scanf("%d", &opcao);
    printf(" #############################################\n");

    system("cls");

    switch (opcao)
    {
    case 1:
        // usuário digita seu nome para jogar e vê os objetivos do jogo
        printf("\n--------------------------------------\n");
        printf(" Nome do jogador? ");
        scanf("%s", &nome);
        printf("--------------------------------------\n\n");
        printf(" Olá %s!\n O objetivo do jogo é achar duas cartas iguais a cada rodada.\n E alcançar os mil pts :)\n\n Boa sorte!!! ;)\n\n",nome);
        system("Pause");
        printf("\n");

        //limpa a tela
        system("cls");

        printf("--------------------------------------\n");
        printf("        TABULEIRO DO JOGO\n");
        printf("--------------------------------------\n");
        printf(" JOGADOR: %s\n", nome);
        printf(" PONTOS : %d pts\n", pts);
        printf("--------------------------------------\n");
        // gera os letras aleatórias e imprime a matriz

        printf(" # ");
        //esconde a matriz
        for(i=0; i<8; i++)
        {
            printf("  %d ", i);
        }
        printf("\n-------------------------------------\n");
        for (i = 0; i < 8; i++)
        {
            printf(" %d |", i);
            for (j = 0; j < 8; j++)
            {
                mat[i][j] = 'A' + (char)(rand()%26);
                printf(" %c |", mat[i][j]);
            }
            printf("\n");
        }
        printf("---------------------------------------\n");

        //loop de contagem regressiva
        printf ("Memorize o tabuleiro...\n");
        while (t>0)
        {
            printf ("%d ", t);
            t--;
            Sleep (1000);
        }

        //limpa a tela após o loop
        system("cls");


        while(opcao == 1)

        {
            printf(" ::: Informe as posições da jogada :::\n\n");
            for(i=1; i<3; i++)
            {
                printf(" %dº Carta\n", i);
                for(j=1; j<3; j++)
                {
                    scanf("%c", &jogada[i][j]);
                }
            }

            if(jogada[i][j] == mat[i][j])
            {
                printf(" PARABÉNS! VOCÊ ACERTOU! =)\n\n GANHOU 100 PTS!\n\n");
                pts = pts + 100;
                //continue;
            }
            else if(jogada[i][j] != mat[i][j])
            {
                printf("\n ERROU! :(\n\n");
                continue;
            }
            else if(jogada[i][j] > 8 || jogada[i][j]  < 0)
            {
                printf(" JOGADA INVÁLIDA!\n\t\t\t\tA LINHA PRECISA SER VALORES DE 0 A 8\n\t\t\t\tE A COLUNA TAMBÉM!!!\n\n");
                continue;
                system("cls");
            }
            else if(pts == 1000)
            {
                printf(" PARABÉNS! VOCÊ ALCANÇOU OS MIL PONTOS!!! ;)\n\n");
                printf(" PARABÉNS! SUA MEMÓRIA É ÓTIMA!!! :)\n\n");
                printf(" Deseja jogar novamente?\n");
                printf(" [1] SIM | [2] NÃO\n");
                scanf("Opção: %d", &opcao);
                if(opcao == 1)
                {
                    pts = 0;
                }
                else if(opcao == 2)
                {
                    exit(1);
                }
                else
                {
                    printf("Opção inválida!");
                }
            }
            break;
        }

    case 2:
        exit(1);
    default:
        printf (" OPÇÃO INCORRETA!!!\n\n");
        system("Pause");
        return 0;
    }
}

Michel De Lima · 30 de outubro de 2021

Ainda não tem funções, porque não aprendemos ainda na faculdade

Ansi C · 30 de outubro de 2021

16 horas atrás, Michel De Lima disse:

for (j = 0; j < 8; j++)
            {
                mat[i][j] = 'A' + (char)(rand()%26);
                printf(" %c |", mat[i][j]);
            }

Persiste à repetição aleatória dos valores [e não].

Um par de letra na matriz[8 * 8] é 64 DIV 32 [e não 26] igual 2 símbolos.

Qual a situação [fora do escopo de programação em C]? É uma situação, que no ensino médio, por exemplo: símbolos estão nas posições do vetor [Matriz e Vetor são intercambiáveis], existem 64 posiç~, quero 32 dessas [COM REPETIÇÃO].

Em 28/10/2021 às 00:30, Michel De Lima disse:

Preciso que gere um par de cada letra dentro da matriz 8x8 e dessa forma só esta embaralhando "as cartas" com 3 e até 4 das mesmas.

Qual quer algoritmo de embaralhamento sobre um matriz [8][8] ou, sendo logicamente igual, um vetor [64] resposte essa questão.

Exitem um algoritmo de embaralhamento usual e talvez queira saber. Ele consiste no sorteio de uma posição do vetor [aleatoriamente], depois se troca o valor na posiç~ sorteada com que há na última do vetor, e reduz em 1 [logicamente] o tamanho dele. Com isso se oculta a antiga última [posição] e emparelha-se um par por ciclo.

Ex.: A B C D E F G H A B C D E F G H um vetor de valores lineares de cartas_com_tamanho = 16

Suponha que a posição sorteada no 1.º ciclo [rand() % cartas_com_tamanho] é 5 então o valor nessa posiç~ e na cartas_com_tamanho - 1 serão trocados.

Seja:

Antes    0 1  2  3  4  5  6  7   8  9  10  11  12 13   14  15

cartas = A B C D  E F  G  H  A  B  C   D   E   F    G     H



cartas [5] <> cartas [cartas_com_tamanho - 1]



Depois    0  1  2  3  4  5  6  7   8  9  10  11  12 13   14  15

cartas =  A  B  C D  E H  G  H  A  B  C   D   E   F    G     F

cartas_com_tamanho -= 1

Fim do 1.º ciclo.

[] Os recursos na linguagem c para a programação desse exercício você já demostrou.

É só "coda"

devair1010 · 30 de outubro de 2021

@Michel De Lima seu código esta funcionando bem , mas precisa melhorar , e como disse @mauro_b a geração das leras não está seguindo como esperado , ainda tem letras sem par :

precisa verificar no loop onde gera as letras . e seria melhor mostrar a matriz com a letra que está na posição quando o usuário informa-la , esperar um pouco e limpar a tela , senão será muito difícil .

Michel De Lima · 30 de outubro de 2021

@devair1010 o alfabeto so tem 26 letras, dai tem esse problema

Michel De Lima · 31 de outubro de 2021

não consegui colocar pares, alguém pode me ajudar?

            #define N 8 //número de linhas e colunas
            #define C 26 //número de cartas

            int main()
            {
                //Variáveis
                char mat[N][N], nome[50], vet[C*2], jogada[2][2];
                int i, j, c, n, opcao, pts=0, t=10, acertos = 0;

            /* Mostra o tabuleiro
            gera os letras aleatórias e imprime a matriz*/
            printf("\n-------------------------------------\n");
            printf(" # ");
            for(i=0; i<8; i++)
            {
                printf("  %d ", i);
            }
            printf("\n-------------------------------------\n");
            for (i = 0; i < 8; i++)
            {
                printf(" %d |", i);
                for (j = 0; j < 8; j++)
                {
                    vet[C] = 'A' + (char)(rand()%32);
                    mat[i][j] = vet[C];
                    printf(" %c |", mat[i][j]);
                }
                printf("\n");
            }
            printf("---------------------------------------\n");

devair1010 · 31 de outubro de 2021

@Michel De Lima sim realmente terá 32 posições na matriz para ser preenchidas e apenas 26 Letras , então não tem jeito terá Que ter mesmo letras repetidas , mas o que não pode é ter letras sem par , e creio que um modo de fazer seria escolhendo a posição onde colocar a letra escolhida aleatoriamente e verificar se a posição está vazia e então colocar a letra e fazer o mesmo para colocar o par dessa mesma letra , e repetir isso 32 vezes que é a metade de elementos da Matriz , assim no final do Loop terá preenchido toda a matriz com pares de letras :

e seu código para gerar a matriz poderia ser assim

#define _CRT_SECURE_NO_WARNINGS  /// para usar scanf oe outras funcoes no visual studio
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <locale.h>
#include <windows.h>
#include <conio.h>
#define N 8
#define C 64
#define h GetStdHandle(STD_OUTPUT_HANDLE)
void textcolor(int , int);

int main()
{
    char mat[N][N] = {0}, nome[50] = {' '},
         vet[C] = {' '}, jogada[2][2],caract = ' ';
    int  i=0, j=0, c=0, n=0, opcao=0, pts=0, t=10,
         flg=0,linha=0,coluna=0;
    system("title JOGO DA MEMÓRIA 1.0 BY MICHEL");
    setlocale(LC_ALL, "Portuguese");
    fflush(stdin);
    system("color 0B");
    srand(time(NULL));
    printf(" #############################################\n\
          \r ###### Bem vindo (a) ao jogo da memória #####\n\
          \r #############################################\n\
          \r -------------------------------------------\n\n\
          \r [1] JOGAR\n\
          \r [2] SAIR\n\
          \r ---------------------------------------------\n\
          \r Escolha uma opção: ");
    scanf("%d", &opcao);
    printf(" #############################################\n");
    system("cls");
    switch (opcao)
    {
    case 1:
        ///  usuario digita seu nome para jogar e ve os objetivos do jogo
        printf("\n--------------------------------------\n\
                \r Nome do jogador ? ");
        scanf("%s", nome);
        printf("--------------------------------------\n\n\
              \r Olá %s!\n\
              \r O objetivo do jogo é achar duas cartas iguais a cada rodada.\n\
              \r E alcançar os mil pts :\n\n\
              \r Boa sorte ! ! !\n\n",nome);
        system("Pause");
        ///  limpa a tela
        system("cls");
        ///  gera os letras aleatórias e imprime a matriz
        printf("\n--------------------------------------\n\
                \r        TABULEIRO DO JOGO\n\
                \r--------------------------------------\n\
                \r JOGADOR: %s\n\
                \r PONTOS : %d pts\n\
                \r--------------------------------------\n\
                \r # ",nome,pts);
        ///  esconde a matriz
        for(i=0; i<8; i++)
        {
            for(j=0;j<8;j++)mat[i][j]=' ';
                printf("  %d ", i);
        }
        printf("\n-------------------------------------\n");
        for(i=0; i<32; i++)
        {
            do                                         /// tres barras pois no codeblocks
            {                                          /// fica com cores mais visiveis
                flg = 0;                               /// uma flag de controle
                linha  = rand() %8;                    /// escolhe a linha  da matriz
                coluna = rand() %8;                    /// escolhe a coluna da matriz
                if(mat[linha][coluna] != ' ')flg = 1;  /// se não estiver vazia marca como ocupada
            }while( flg );                             /// se estiver ocupada repete e escolhe outra posicao
            caract = 'A' + (char)(rand()%26);          /// escolhe uma Letra que pode Ate ser repetida
            mat[linha][coluna] = caract;               /// armazena na matriz
            ///printf("\ni= %d  tecle\n",i);getch();
            do
            {
                flg = 0;
                linha  = rand() %8;                    /// escolhe a linha  da matriz
                                                       /// para colocar o par dessa letra
                coluna = rand() %8;                    /// escolhe a coluna da matriz
                if(mat[linha][coluna] != ' ')flg = 1;  /// se não estiver vazia marca como ocupada
            }while( flg );                             /// se estiver ocupada repete e escolhe outra posicao
            mat[linha][coluna] = caract;               /// coloca o para da letra na matriz
        }
        for (i = 0; i < 8; i++)
        {
            printf(" %d |", i);
            for (j = 0; j < 8; j++)
            {
                ///  mat[i][j] = 'A' + (char)(rand()%26);/// AQui já Gerou a letra
                printf(" %c |", mat[i][j]);
            }
            printf("\n");
        }
        printf("---------------------------------------\n");
        ///  loop de contagem regressiva
        printf ("Memorize o tabuleiro...\n");
        while (t>0)
        {
            printf ("%d ", t);
            t--;
            Sleep (1000);
        }
        ///  limpa a tela após o loop
        system("cls");
        while(opcao == 1)
        {
            printf(" ::: Informe as posições da jogada :::\n\n");
            for(i=1; i<3; i++)
            {
                printf(" %dº Carta\n", i);
                for(j=1; j<3; j++)
                {
                    scanf("%c", &jogada[i][j]);
                }
            }
            if(jogada[i][j] == mat[i][j])
            {
                printf(" PARABÉNS! VOCÊ ACERTOU! =)\n\n GANHOU 100 PTS!\n\n");
                pts = pts + 100;
                ///  continue;
            }
            else
            {
                if(jogada[i][j] != mat[i][j])
                {
                    printf("\n ERROU! :(\n\n");
                    continue;
                }
                else if(jogada[i][j] > 8 || jogada[i][j]  < 0)
                {
                    printf(" JOGADA INVÁLIDA!\n\
                           \r\t\t\t\tA LINHA PRECISA SER VALORES DE 0 A 8\n\
                           \r\t\t\t\tE A COLUNA TAMBÉM!!!\n\n");
                    continue;
                    system("cls");
                }
                else if(pts == 1000)
                {
                    printf(" PARABÉNS! VOCÊ ALCANÇOU OS MIL PONTOS!!! \n\n\
                    \r PARABÉNS! SUA MEMÓRIA É ÓTIMA!!!\n\n\
                    \r Deseja jogar novamente ?\n\
                    \r [1] SIM | [2] NÃO ");
                    scanf("Opção: %d", &opcao);
                    if(opcao == 1)
                    {
                        pts = 0;
                    }
                    else if(opcao == 2)
                    {
                        exit(1);
                    }
                    else
                    {
                        printf("Opção inválida!");
                    }
                }
                break;
            }
        }
    case 2:
        textcolor(12,15);
        printf("\n\n\n\t\t  Saindo do Programa . . . !  \n\n\n");
        Sleep(2000);
        textcolor(7,0);
        exit(1);
    default:
        printf (" OPÇÃO INCORRETA!!!\n\n");
        system("Pause");
        return 0;
    }
}
void textcolor(int letras , int fundo)
{
    SetConsoleTextAttribute(h , letras + (fundo << 4) );
}

Michel De Lima · 31 de outubro de 2021

@devair1010 Sim, exatamente isso, o alfabeto so tem 26 e por isso faltava 6 caracteres para alcançar os 32 para fazer todos pares, o professor disse que dava para completar com outros caracteres especiais tipo "@#$%&*", mas eu teria que fazer um vetor e chama lo na matriz para isso.

Obrigado pela ajuda, vou estudar o código agora.