#include <stdio.

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

/*
1) Fazer um programa de “criptografia” (codificação de dados visando a
privacidade
de acesso as informações), onde dada uma string (vetor de caracteres) este programa
codifique os dados através de um processo de substituição de letras. Você pode
definir
o seu próprio método de criptografia, desde que depois seja possível reverter este
processo, ou seja, um código criptografado deve poder ser convertido novamente ao
valor inicial.
Exemplo:
>> Criptografador – Codifica uma String <<
Entre como texto (string) a ser criptografado: LinguagemC
Texto criptografado: MjohvbhfnD
*/

#define TAMANHO_ALFABETO 26

char alfabeto[TAMANHO_ALFABETO] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
'z'};

char* criptografar(char* mensagem) {

int tamanho = strlen(mensagem);
char* criptografada = malloc(sizeof(char) * (tamanho + 1));
int i, j;

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

if (mensagem[i] == ' ') {
criptografada[i] = ' ';
continue;
}

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

if (mensagem[i] == alfabeto[j]) {
int indice = (j + 3) % TAMANHO_ALFABETO;
criptografada[i] = alfabeto[indice];
break;
}
}
}

criptografada[tamanho] = '\0';

return criptografada;
}

char* descriptografar(char* mensagem) {

int tamanho = strlen(mensagem);
char* descriptografada = malloc(sizeof(char) * (tamanho + 1));
int i, j;

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

if (mensagem[i] == ' ') {
descriptografada[i] = ' ';
continue;
 }

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

if (mensagem[i] == alfabeto[j]) {
int indice = (j - 3 + TAMANHO_ALFABETO) % TAMANHO_ALFABETO;
descriptografada[i] = alfabeto[indice];
break;
}
}
}

descriptografada[tamanho] = '\0';

return descriptografada;
}

int main(void) {
char mensagem[100];
printf("Criptografador - Codifica uma String\n");
printf("Entre com o texto (string) a ser criptografado: ");
fgets(mensagem, sizeof(mensagem), stdin);
mensagem[strcspn(mensagem, "\n")] = '\0'; // remove o caractere de nova linha

char* criptografada = criptografar(mensagem);

printf("Texto criptografado: %s\n", criptografada);

char* descriptografada = descriptografar(criptografada);

printf("Texto descriptografado: %s\n", descriptografada);

return 0;
}

===================================================================================
=========================================

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

/*
2) Fazer um segundo programa, complementar a este anterior, que deve ser capaz de
descriptografar a string, ou seja, deve pegar uma string codificada e retornar ao
texto
original.
Exemplo:
>> Descriptografador – Decodifica uma String <<
Entre como texto a ser descriptografado: MjohvbhfnD
Texto descriptografado: LinguagemC
Dicas:
Subtrair um do código de uma caracter implica em transformar no caracter anterior.
Exemplo:
Letra = ‘A’; Letra = Letra + 1;
*/

int main() {
char texto_codificado[100], texto_decodificado[100];
int i, tamanho;

printf("Descriptografador - Decodifica uma String\n");

 printf("Entre com o texto a ser descriptografado: ");
scanf("%s", texto_codificado);

tamanho = strlen(texto_codificado);

// Realiza a decodificação do texto

for (i = 0; i < tamanho; i++) {
texto_decodificado[i] = texto_codificado[i] - 1;
}

texto_decodificado[tamanho] = '\0';

printf("Texto descriptografado: %s\n", texto_decodificado);

return 0;
}

===================================================================================
=========================================

#include <stdio.h>
#include <ctype.h>

/*
3) Fazer um programa que leia uma string e converta todos os caracteres desta
string
para maiúsculo. Depois de convertida a string, exibir o resultado na tela.
Dicas: (1) Uma string de caracteres é um vetor do tipo char, terminado pelo
caractere
‘\0’; (2) O código ASCII da letra ‘a’ (minúsculo) é 97 e o código da letra ‘A’
(maiúsculo) é 65, o código da letra ‘z’ é 122 e o código da letra ‘Z’ é 90; (3)
Cuidado
para não acabar convertendo aquilo que não é nem texto e nem está em minúsculas!
Exemplo:
>> Converte Texto: Minusculas para Maiusculas <<
Entre um texto : Prezados Alunos da USP de Sao Carlos (2009)
Texto convertido: PREZADOS ALUNOS DA USP DE SAO CARLOS (2009)
*/

int main() {
char str[100];
int i = 0;

printf("Digite uma string: ");

scanf("%[^\n]s", str);

while (str[i]) {
str[i] = toupper(str[i]);
i++;
}

printf("String convertida para maiúsculo: %s\n", str);

return 0;
}

===================================================================================
=========================================
#include <stdio.h>
#include <string.h>

/*
4) Faça um programa que leia duas strings (de tamanho máximo 40). Após isso, o
programa deve concatenar as informações lidas e mostrar o resultado para o usuário.
Exemplo: Se a primeira string digitada for "Bom dia, " e a segunda "moçada !",
então
o resultado deverá ficar: "Bom dia, moçada !"
*/

#define MAX 40

int main() {
char str1[MAX], str2[MAX];
printf("Digite a primeira string (max %d caracteres): ", MAX);
fgets(str1, MAX, stdin);
printf("Digite a segunda string (max %d caracteres): ", MAX);
fgets(str2, MAX, stdin);

str1[strcspn(str1, "\n")] = '\0'; // remove o caractere '\n' da string 1

str2[strcspn(str2, "\n")] = '\0'; // remove o caractere '\n' da string 2

strcat(str1, str2); // concatena as duas strings

printf("Resultado: %s\n", str1);

return 0;
}

===================================================================================
=========================================

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

/*
5) Escreva uma função para ler 10 elementos inteiros, colocá-los num vetor e
retornar
um outro vetor contendo todos os números primos do vetor inicial. Na função,
imprima os valores dos dois vetores.
*/

int is_prime(int n) {
if (n < 2) {
return 0;
}
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}

int* find_primes(int arr[], int size, int* num_primes) {

int count = 0;
 for (int i = 0; i < size; i++) {
if (is_prime(arr[i])) {
count++;
}
}
int* primes = malloc(count * sizeof(int));
int j = 0;
for (int i = 0; i < size; i++) {
if (is_prime(arr[i])) {
primes[j++] = arr[i];
}
}
*num_primes = count;
return primes;
}

int main() {
int arr[10];
printf("Digite 10 números inteiros:\n");
for (int i = 0; i < 10; i++) {
scanf("%d", &arr[i]);
}
int num_primes;
int* primes = find_primes(arr, 10, &num_primes);
printf("Vetor inicial: ");
for (int i = 0; i < 10; i++) {
printf("%d ", arr[i]);
}
printf("\nVetor de primos: ");
for (int i = 0; i < num_primes; i++) {
printf("%d ", primes[i]);
}
printf("\n");
free(primes);
return 0;
}

===================================================================================
=========================================

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

/*
6) Implemente um programa que receba um nome completo e apresente apenas o
último nome e o 1º nome na seguinte forma:
último, 1º nome
Exemplo:
Rafael Paes Olivera
saída: Oliveira, Rafael
*/

int main() {
char nome_completo[100];
printf("Digite o nome completo: ");
fgets(nome_completo, 100, stdin);

int ultimo_espaco = strlen(nome_completo) - 2;

 while (ultimo_espaco >= 0 && nome_completo[ultimo_espaco] != ' ') {
ultimo_espaco--;
}

char ultimo_nome[50], primeiro_nome[50];

strcpy(ultimo_nome, &nome_completo[ultimo_espaco + 1]);
nome_completo[ultimo_espaco] = '\0';
strcpy(primeiro_nome, nome_completo);

printf("\n%s, %s\n", ultimo_nome, primeiro_nome);

return 0;
}

===================================================================================
=========================================