C++ criptografia em um texto. O algoritmo deve inverter os caracteres de cada linha

mimiarquitetura · 9 de abril de 2021

<

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>

#define MAX_LINHAS 32
#define MAX_CARACTERES 128

typedef struct

{
    char frase[MAX_LINHAS];

} dados;
int main ()
{

    char texto[MAX_LINHAS][MAX_CARACTERES];

    int i, j =0;
    printf ("Digite uma linha em branco para sair do programa.\n");

    for (int i =0; i< MAX_LINHAS ; i++) // Gera a matriz
    {
        printf ("%d",i+1);
        fgets(texto[i],MAX_CARACTERES, stdin);
        if (texto[i][0] == '\n')
        {
            break;
        }
    }

    for (j=0; j<i; j++)
    {
        printf ("%03d",j+1,texto [j]);


    }


    system("pause");
    return 0;
}

void criptografa(dados *cripto)
{
    printf("DIGITE UMA FRASE: \n");
    gets(cripto->frase);


    for(int i = 0 ; i < strlen(cripto->frase) ; i++)
    {
        if(cripto->frase[i] == 'a')
        {
            cripto->frase[i] = '@';
        }
        else  if(cripto->frase[i] == 'e')
        {
            cripto->frase[i] = '#';
        }
        else if (cripto->frase[i] == 'i')
        {
            cripto->frase[i] = '!';
        }
        else if (cripto->frase[i] == 'o')
        {
            cripto->frase[i] = '*';
        }
        else if (cripto->frase[i] == 'u')
        {
            cripto->frase[i] = '$';
        }
        else  if(cripto->frase[i] == 'A')
        {
            cripto->frase[i] = '@';
        }
        else  if(cripto->frase[i] == 'E')
        {
            cripto->frase[i] = '#';
        }
        else if (cripto->frase[i] == 'I')
        {
            cripto->frase[i] = '!';
        }
        else if (cripto->frase[i] == 'O')
        {
            cripto->frase[i] = '*';
        }
        else if (cripto->frase[i] == 'U')
        {
            cripto->frase[i] = '$';
        }
        else
        {
            cripto->frase[i] = cripto->frase[i] ;
        }

    }

    for(int i = 0 ; i< strlen(cripto->frase); i++)
    {
        putchar(cripto->frase[i]);
    }
    printf("\n\n");

     for(int i = strlen(cripto->frase) ; i>=0 ; i--)
    {
        putchar(cripto->frase[i]);
    }
    printf("\n\n");

    //IMPRIME TEXTO:

    printf("TEXTO DEPOIS DE PROCESSADO: \n");
    for(int i = 0; i< tamanho; i++)
    {
        printf("LINHA %d: %s\n", i, texto[i]);
    }

}

>

Midori · 9 de abril de 2021

@mimiarquitetura Não precisa usar struct e já que é em C++ você poderia usar string em vez de char []. Mas qual é a dúvida/dificuldade?

mimiarquitetura · 9 de abril de 2021

@Midori é q não esta funcionando, esta com erros e não atende o que o exercício pede

Em 09/04/2021 às 16:02, mimiarquitetura disse:

@Midori é q não esta funcionando, esta com erros e não atende o que o exercício pede

Expandir

consegue me ajudar? postei o código

Midori · 9 de abril de 2021

@mimiarquitetura Seu programa não está compilando e falta declaração. Acho que na função criptografa seria melhor já retornar o valor criptografado e não é preciso usar estrutura para isso. Poderia ser em C++, mas se for fazer C, veja como fica função,

char *criptografa(char *texto){
    static char invertido[128];
    int i = strlen(texto) - 2;
    int j = 0;

    while(i >= 0){
        invertido[j] = texto[i];
        j += 1;
        i -= 1;
    }
    invertido[j] = 0;

    for(i = 0; i < j; i += 1){
        char *letra = &invertido[i];
        char c = toupper(*letra);
        if(c == 'A'){*letra = '@';}
        if(c == 'E'){*letra = '#';}
        if(c == 'I'){*letra = '!';}
        if(c == 'O'){*letra = '*';}
        if(c == 'U'){*letra = '$';}
    }
    return invertido;
}

Assim poderá copiar o retorno da função para a matriz do texto, p.ex,

char texto[MAX][128];
char linha[128];
...
fgets(linha, 128, stdin);

strcpy(texto[i], criptografa(linha));
...

mimiarquitetura · 9 de abril de 2021

@Midori tenho bastante dificuldade, estou fazendo introdução a C
realmente não entendo muito como ficaria o cod inteiro, mas obrigada

Em 09/04/2021 às 16:59, mimiarquitetura disse:

@Midori tenho bastante dificuldade, estou fazendo introdução a C
realmente não entendo muito como ficaria o cod inteiro, mas obrigada

Expandir

mas se tu puder me dizer como fica o código inteiro, te agradeço muito

Midori · 9 de abril de 2021

Editado.

mimiarquitetura · 9 de abril de 2021

@Midori mas não esta criptografando nem invertendo a matriz

ZENLESSMANN · 9 de abril de 2021

Midori ajudou uns 20 alunos da turma, tu és o cara! Usemos essa resposta com responsabilidade galera, fiquem ligados nas cópias

mimiarquitetura · 9 de abril de 2021

@ZENLESSMANN tu conseguiu fechar o código? eu ainda não...

ZENLESSMANN · 9 de abril de 2021

Sim, ta fazendo exatamente o que pede

arfneto · 9 de abril de 2021

Em 09/04/2021 às 16:02, mimiarquitetura disse:

é q não esta funcionando, esta com erros e não atende o que o exercício pede

Expandir

Tem mesmo um problema então

Seu programa está escrito em C praticamente, e isso significa que vai dar muito mais trabalho. Em C++ é mais simples compor coisas.

E seu programa parece muito complicado e um pouco longe de funcionar. Em especial coisas como

void criptografa(dados *cripto)
{
    printf("DIGITE UMA FRASE: \n");
    gets(cripto->frase);

Se está testando o programa, não deve fazer coisas assim interativas. Só vai perder tempo. E é frágil. Faça o simples e escreva EM TORNO dos dados....

Para testar use algo como

	char* criptografa( char* frase );

e assim pode escrever o simples em main() para testar a tal transformação, testando uma linha conhecida. Não é vergonha usar o enunciado e não é crime escrever vários programinhas antes de montar a solução

Poste o enunciado em modo TEXTO assim se pode copiar os dados para testar...

Coloque isso em uma tabela em seu programa. É muito mais fácil.

Tem o gabarito pronto. Poste o texto e podemos te mostrar como fazer.

Tudo fica mais simples.

E coloque isso em outra tabela,

Usando a sua função

criptografia() pode testar linha a linha e comparar o resultado com a solução e saberá assim que seu programa estiver provavelmente funcionando: as 18 linhas do texto tem que gerar as 18 linhas da solução....

Nada mais. E nem precisa digitar nada

Quanto à função, está errada e longe da ideia: a transformação do texto não envolve testar as letras, apenas as vogais., conforme a tabela... 'i' vira '!' por exemplo. nada mais.

O resto é apenas inverter as posições. Pode fazer que qualquer jeito.

Para cada linha apenas monte uma string com as letras invertidas. No caminho troque as vogais. Só isso. Em geral se faria a função inversa para mostrar que pode codificar e depois RESTAURAR o texto. É o simples porque é assim que testa...

"mimi" vai gerar "!m!m" , simples assim: inverte a ordem e processa as vogais. No retorno vira "mimi" claro...

Provavelmente em C estaria melhor servida com dados assim

typedef struct
{
    int     linhas;
    char    frase[MAX_LINHAS][MAX_CARACTERES];
  
}   Dados;

Como está usando C++ pode fazer mais fácil.

?? C ou C++ ?? Postou como C++

mimiarquitetura · 9 de abril de 2021

@arfneto uso o codeblocks, acredito ser C

@arfneto

#include <float.h>
#include <locale.h>
#include <stdio.h>
#define MAX_LINHAS 32
#define MAX_CARACTERES 128

int main()
{

setlocale(LC_ALL,"");// código para aparecer simbolos e acentuação

char texto[MAX_LINHAS][MAX_CARACTERES];
char frase [MAX_CARACTERES];
int tamanho = 0;
int fim_texto = 1;
int j;

// CHAMA A FRASE A SER DIGITADA:
//LE A MATRIZ DE CARACTERES:

while(fim_texto !=0 && tamanho < MAX_LINHAS)
{
printf ("Informe a cada frase do texto e para parar o programa digite FIM_TEXTO: \n");
gets(frase);
fim_texto = strcmp(frase, "FIM_TEXTO");

if (fim_texto !=0)
{
strcpy(texto[tamanho], frase);
tamanho++;

//IMPRIME O TEXTO:

printf ("TEXTO ORIGINAL E MODIFICADO: \n");
for(int i = 0; i< tamanho; i++)
{
printf("LINHA %d: %s\n", i, texto[i]);

}

//PROCESSAMENTO PARA CRIPTO. O TEXTO :

for(int i = 0; i< tamanho; i++)
{
int tamanho_linha_i = strlen(texto[i]);

for(int j = 0; j < tamanho_linha_i ; j++)
{

if (texto[i][j] == 'a')
{
texto[i][j] = '@';

}
else if (texto[i][j] == 'A')
{
texto[i][j] = '@';

}
else if (texto[i][j] == 'E')
{
texto[i][j] = '#';

}
else if (texto[i][j] == 'e')
{
texto[i][j] = '#';

}
else if (texto[i][j] == 'i')
{
texto[i][j] = '!';

}
else if (texto[i][j] == 'e')
{
texto[i][j] = '#';

}
else if (texto[i][j] == 'i')
{
texto[i][j] = '!';

}
else if (texto[i][j] == 'I')
{
texto[i][j] = '!';

}
else if (texto[i][j] == 'o')
{
texto[i][j] = '*';

}
else if (texto[i][j] == 'O')
{
texto[i][j] = '*';

}
else if (texto[i][j] == 'u')
{
texto[i][j] = '$';

}
else if (texto[i][j] == 'U')
{
texto[i][j] = '$';

}
}
}

}

}
//IMPRIME OS TEXTOS DEPOIS DE PROCESSADOS:

printf("TEXTO DEPOIS DE PROCESSADO: \n");
for(int i = 0; i< tamanho; i++)
{
printf("LINHA %d: %s\n", i, texto[i]);

}
printf("TEXTO DEPOIS DE PROCESSADO COM AS LINHAS INVERTIDAS: \n");
tamanho = strlen(frase);
for(int i= tamanho; i>=0; i--)
{

for (j=0; j=<0; j++)
{

printf("LINHA %d: %s\n", i, texto[i][j]);
}
}
return 0;
}

@arfneto Nao quero lhe falar meu grande amor
Das coisas que aprendi nos discos
Quero lhe contar como eu vivi
E tudo o que aconteceu comigo
Viver e melhor que sonhar
Eu sei que o amor e uma coisa boa
Mas tambem sei que qualquer canto
E menor do que a vida
De qualquer pessoa
Por isso cuidado meu bem
Ha perigo na esquina
Eles venceram
E o sinal esta fechado pra nos
Que somos jovens
Para abracar seu irmão
E beijar sua menina na rua
E que se fez o seu braco
O seu labio e a sua voz
FIM_TEXTO

arfneto · 9 de abril de 2021

Em 09/04/2021 às 17:22, mimiarquitetura disse:

@arfneto uso o codeblocks, acredito ser C

Expandir

Code::Blocks trataria C e C++. MAs vejo que é um programa em C. Em C++ seria mais fácil, mas não importa.

Ao postar algo marque a linguagem certa lá. Evita distrações.

Poste o enunciado em modo TEXTO para o pessoal poder copiar, como te expliquei. É melhor para todo mundo

Evite programas interativos para testar ou mesmo para entregar. Não está claro no enunciado que o cara precisa ficar parado em frente a tela para digitar linhas e linhas de texto, e é mesmo um p0rr3 fazer isso, certo?

É muito mais fácil copiar o texto do enunciado e colar num arquivo usando o próprio editor do Code::Blocks que você diz que usa. Pode começar com uma linha só e ir testando, por exemplo.

Evite programas interativos. Não vai te ensinar nada e dá um p..@ trabalho.

Tratar arquivos é MUITO mais fácil que ler do teclado, e para usar você deve ter sua opinião: é melhor digitar as 18 linhas uma a uma sem errar ou melhor copiar a letra do enunciado ou digitar qualquer coisa no editor?

E use constantes. Veja como pode ser mais simples:

Rodando

clube$ gcc -o cri cri.c
clube$ ./cri
#1:     Nao quero lhe falar meu grande amor
#2:     Das coisas que aprendi nos discos
#3:     Quero lhe contar como eu vivi
#4:     E tudo o que aconteceu comigo
#5:     Viver e melhor que sonhar
#6:     Eu sei que o amor e uma coisa boa
#7:     Mas tambem sei que qualquer canto
#8:     E menor do que a vida
#9:     De qualquer pessoa
#10:    Por isso cuidado meu bem
#11:    Ha perigo na esquina
#12:    Eles venceram
#13:    E o sinal esta fechado pra nos
#14:    Que somos jovens
#15:    Para abracar seu irmão
#16:    E beijar sua menina na rua
#17:    E que se fez o seu braco
#18:    O seu labio e a sua voz
#19:    FIM_TEXTO
clube$

Este exemplo, de 3 linhas na prática, em

#include<stdio.h>

#define MAX_LINHAS 32
#define MAX_CARACTERES 128

typedef struct
{
    int     linhas;
    char    frase[MAX_LINHAS][MAX_CARACTERES];

}   Dados;

const int t_vogais[10][2] =
{
    {'a','@'},
    {'b','#'},
    {'c','!'},
    {'d','*'},
    {'e','$'},
    {'A','@'},
    {'B','#'},
    {'C','!'},
    {'D','*'},
    {'E','$'}  
};

int main (void)
{
    Dados teste = 
    {
        .linhas = 19,
        .frase = 
        {
            "Nao quero lhe falar meu grande amor",
            "Das coisas que aprendi nos discos",
            "Quero lhe contar como eu vivi",
            "E tudo o que aconteceu comigo",
            "Viver e melhor que sonhar",
            "Eu sei que o amor e uma coisa boa",
            "Mas tambem sei que qualquer canto",
            "E menor do que a vida",
            "De qualquer pessoa",
            "Por isso cuidado meu bem",
            "Ha perigo na esquina",
            "Eles venceram",
            "E o sinal esta fechado pra nos",
            "Que somos jovens",
            "Para abracar seu irmão",
            "E beijar sua menina na rua",
            "E que se fez o seu braco",
            "O seu labio e a sua voz",
            "FIM_TEXTO"
        }
    }; // teste

    for( int i=0; i< teste.linhas; i+=1)
    printf("#%d:\t%s\n", 1+i,teste.frase[i]);
    return 0;
}

Aí você tem a tabela para as vogais, a struct para teste, os dados do enunciado e já pode testar tudo e comparar.

Poste o enunciado no modo TEXTO. Espero que tenha entendido o porque...

Você não precisa saber a largura das linhas, porque cada uma termina por um ZERO já que são strings. O número de linhas dentro da estrutura ajuda muito, porque não precisaria claro guardar a linha final que de nada serve. E pode tratar várias no mesmo programa se precisar.

O programa vai ter uma entrada do tipo Dado e vai gerar uma saída do tipo Dado, mas antes de pensar nisso você simplesmente chama a sua função criptografia() para cada linha e vê se a coisa rola. Quando estiver ok você entra com a estrutura e pronto.

É muito mais simples escrever em torno dos dados

Em 09/04/2021 às 17:22, mimiarquitetura disse:

E beijar sua menina na rua
E que se fez o seu braco
O seu labio e a sua voz
FIM_TEXTO

Expandir

Acho que não expliquei bem...

Cadê a parte de saída?

É isso que estou tentando explicar: usando recortar e colar direto do enunciado e ja tem como conferir quase tudo...

Mas eu não vou digitar aquelas letrinhas, nem você. Por isso é importante postar TEXTO.

Eu só queria mostrar uma ideia geral do mecanismo.

  setlocale(LC_ALL,"");// código para aparecer simbolos e acentuação

    char texto[MAX_LINHAS][MAX_CARACTERES];
    char frase [MAX_CARACTERES];
    int tamanho = 0;
    int fim_texto = 1;
    int j;

Entendeu o "programa" que eu mostrei?

Que esta fazendo com setlocale() se o enunciado diz que não precisa se preocupar com isso? Só vai te dar problemas.

Que faz com esse int j global? tire isso daí e coloque nos loops.

Porque precisa de frase e texto ao mesmo tempo?

NUNCA use gets(). Isso foi condenado há décadas. Seu compilador não reclamou??? Use sempre -Wall nas opções.

    for(int j = 0; j < tamanho_linha_i ; j++)
                {

                    if (texto[i][j] == 'a')
                    {
                        texto[i][j] = '@';

                    }
                    else if (texto[i][j] == 'A')
                    {
                        texto[i][j] = '@';

                    }
                    else if (texto[i][j] == 'E')
                    {
                        texto[i][j] = '#';

                    }
                    else if (

não use isso. Use uma tabela como te mostrei...

    const int t_vogais[10][2] =
    {
        {'a','@'}, {'b','#'}, {'c','!'}, {'d','*'}, {'e','$'},
        {'A','@'}, {'B','#'}, {'C','!'}, {'D','*'}, {'E','$'}  
    };

Algo simples assim...

Exemplo

Considere essa função

// teste: recebe uma frase e inverte. se sentido for '>'
// troca as vogais pelo simbolo. Se for outra coisa
// troca o simbolo pela vogal minuscula
// isso nao tem sentido mas assim foi proposto
// a criptografia nao tem como restaurar o original
// :) :) bem besta o suposto algoritmo
char*  criptografia(char* frase, char sentido)
{
    const int t_vogais[10][2] =
    {
        {'a','@'}, {'b','#'}, {'c','!'}, {'d','*'}, {'e','$'},
        {'A','@'}, {'B','#'}, {'C','!'}, {'D','*'}, {'E','$'}  
    };
    char* teste = malloc(128); // o maximo afinal
    int origem = 0;
    int destino = 1;
    if ( sentido != '>')
    {   origem = 1;
        destino = 0; // inverte
    }
    int tam = strlen(frase);
    for( int pos = tam-1, j=0; pos >=0; pos -=1, j+=1)
    {   char vogal = 0;
        for ( int i = 0; i<10; i+= 1)
        {
            if (frase[pos] ==  t_vogais[i][origem])
            {   teste[j] = t_vogais[i][destino];
                vogal = 1;
                break; // acabou por aqui
            } 
        }
        if ( vogal == 0 ) teste[j] = frase[pos];
    };  // for()
    return teste;
}

E esse trecho de programa que pode estar no final do programa que eu mostrei

    printf( "frase 1: '%s'\n", teste.frase[0]);
    char* resultado = criptografia(teste.frase[0],'>');
    printf( "saida 1: '%s'\n", resultado);

    char* reverso = criptografia(resultado,'<');
    printf( "rev   1: '%s'\n", reverso);

    free(resultado);
    free(reverso);

E mostra

frase 1: 'Nao quero lhe falar meu grande amor'
saida 1: 'rom@ $*n@rg u$m r@l@f $hl or$uq o@N'
rev   1: 'Nao quero lhe falar meu grande amor'

Essa seria a mecânica de codificar e decodificar o texto. Claro que nesse exemplo não funciona porque o "algoritmo" não é reversível. No exemplo acima funcionou porque não tem símbolos e nem vogais maiúsculas....