Cifrario di Cesare da file

da Cristina | Giu 14, 2019 | Tutorial C

In questa lezione implementeremo il cifrario di Cesare da file.

Nella scorsa lezione abbiamo implementato semplicemente l’algoritmo per il cifrario di Cesare inserendo un testo da tastiera lungo massimo 100 caratteri, potete consultare la lezione al link: il cifrario di Cesare in C.

Oggi ci occuperemo invece di scrivere un programma che simuli il cifrario di Cesare sia per il mittente che per il destinatario.

Il testo è salvato in un file, ad esempio di nome testo.txt. Il mittente, dopo averlo cifrato lo salva in un altro file di testo di nome testocifrato.txt.

Il destinatario legge il file testocifrato.txt, decifra il messaggio e lo salva nel file testodecifrato.txt.

Per semplicità consideriamo il messaggio senza spazi vuoti, senza accenti, senza punteggiatura, lungo 14 caratteri e tutto in maiuscolo.

Immaginiamo dunque che nel file di testo ci sia scritto CODINGCREATIVO. Questo è dunque il testo che deve essere cifrato in base alla chiave digitata in input dal mittente.

Sviluppiamo quindi le seguenti funzioni:

void stampaAlfabeto(int c);
Si occupa di stampare l’alfabeto cifrato in base alla chiave fornita in input.

void messCifrato(char testo[n],int c);
Si occupa di cifrare la frase presa in input in base alla chiave fornita in input.

void messDecifrato(char testo[n],int c);
Si occupa di decifrare la frase presa in input in base alla chiave fornita in input.

Ecco l’algoritmo per il cifrario di Cesare da file:

#include <stdio.h>

#define n 14

void stampaAlfabeto(int c);
void messCifrato(char testo[n],int c);
void messDecifrato(char testo[n],int c);

int main(int argc, char *argv[]) {
     int c,i;
     char testo[n+1];
     FILE *input;
     FILE *input2;
 	
     do {
    	printf("--> MITTENTE\n\tInserisci la chiave: ");
    	scanf("%d",&c);  
     } while(c<=0 || c>26);
    
    stampaAlfabeto(c);  //stampa il nuovo alfabeto 
     
    input=fopen("Testo.txt","r");   //apriamo il file in lettura 
    fscanf(input,"%s",testo); 
    fclose(input);
    printf("\tTesto in chiaro letto da file: %s\n", testo);
    
    messCifrato(testo,c); 

    printf("\n-->DESTINATARIO \n");  
       
    input2=fopen("TestoCifrato.txt","r");    
    fscanf(input2,"%s",testo); 
    fclose(input2);
 
    printf("\tTesto cifrato letto dal file : %s\n", testo);
    messDecifrato(testo,c);
    printf("\n");

 	return 0;
}

void stampaAlfabeto(int c) {
	int i, cont=65;
 	char cifrato[26];

        printf("\tAlfabeto cifrato con chiave %d: \n\t", c); 
 	 	
 	for(i=0;i<26-c;i++) {
	   	cifrato[i]=cont+c;
    	        printf("%c ",cifrato[i]);
    	        cont++;
	}  
 	printf("\n\n");
}     


void messCifrato(char testo[n+1],int c) {	
	int i;  
	FILE *output;
	 	
 	for(i=0;i<n;i++)
	      if(testo[i]<'Z'-c)
			testo[i]+=c;		
    		else
        		testo[i]='A'+c-('Z'-testo[i])-1;
 
 	printf("\n");
 	output=fopen("TestoCifrato.txt","w"); //apro il file 
 	fprintf(output,"%s",testo);
 	fclose(output); 
 	printf("\tTesto cifrato scritto su file: %s\n", testo);
} 

void messDecifrato(char testo[n+1],int c) {	
	int i;
	FILE *output2;

 	for(i=0;i<n;i++)
 		if(testo[i]<'A'+c)
 			testo[i] = 'Z'-(c-(testo[i]-'A')-1);
 		else
 	 		testo[i]-=c;
	               
  	output2=fopen("TestoDecifrato.txt","w");
  	fprintf(output2,"%s",testo);
  	fclose(output2);
  	
  	printf("\tTesto decifrato scritto su file: %s\n", testo); 
} 

Alcuni link utili

Indice argomenti linguaggio C

La funzione fopen

La funzione fclose

Funzione fprintf

Funzione fscanf

Allocazione dinamica della memoria con malloc

Esercitazione sulle struct in C

Realizzare un menù di scelta in C

Strutture complesse in C

Come sommare gli elementi della cornice esterna

Come sommare due matrici

Matrice trasposta

Prodotto tra matrici

Ricerca elementi in una matrice

Tavola pitagorica in C

Array multidimensionali

Quick sort in C

Selection sort in C

Merge sort in C

Insertion Sort in C

Cifrario di Cesare in C

da Cristina | Giu 14, 2019 | Tutorial C

In questa lezione implementeremo un algoritmo per il cifrario di Cesare in C.

Il cifrario di Giulio Cesare è un facile esempio di crittografia a sostituzione, cioè dove ciascun elemento del testo è trasformato in un altro elemento.

All’epoca di Giulio Cesare era un algoritmo efficace e veniva usato per inviare le sue corrispondenze.

Quindi si sceglieva una chiave numerica ed in base a questa chiave ogni lettera veniva sostituita dalla lettera indicata dalla chiave.

Facciamo quindi un esempio:

Alfabeto non cifrato: 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.

Assegniamo alla chiave numerica il valore 5.

L’alfabeto cifrato diventa così: F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A, B, C, D, E.

Il cifrario si realizza dunque in modo circolare, quando si arriva alla Z si riparte dalla A.

L’algoritmo quindi risulta molto semplice e proprio per questo è una tecnica che può essere facilmente violata. Infatti si può andare facilmente a tentativi, in quanto le possibili chiavi sono 26.

Si è cercato di superare questi limiti assegnando a ciascuna lettera del testo in chiaro una lettera scelta a caso. Così abbiamo ben 26! possibili chiavi. Ma rimaneva sempre un punto debole in quanto ogni lettera veniva sostituita sempre dalla stessa lettera.

Algoritmo per il cifrario di Cesare in C

Ecco dunque l’algoritmo sul cifrario di Cesare in linguaggio C che prende in input un testo scritto in maiuscolo e senza spazi e restituisce il messaggio cifrato.

Quindi leggiamo la lunghezza del testo inserito:

while(testo[n]!= '\0')  //finchè non arriviamo alla fine del testo
     n++;  

Dunque, con un ciclo for, convertiamo ciascun carattere aggiungendo la chiave inserita a ciascuna lettera facendo attenzione che, quando si arriva alla posizione Z – la chiave, dobbiamo iniziare nuovamente dalla lettera A e dobbiamo aggiungere la posizione della chiave meno le posizioni che rimanevano per arrivare alla lettera Z.

testoc[i]=’A’+c-(‘Z’-testo[i])-1;

Dopo, allo stesso modo, decifriamo il testo per ottenere ciò che avevamo inserito in input.

#include<stdio.h>

#define MAX 100

int main(){
	int i,n,c;
	char testo[MAX],testoc[MAX],testod[MAX];
	
	printf("Inserisci la frase in maiuscolo e senza spazi: ");
	gets(testo);
	if(testo[i]>='A' && testo[i]<='Z') {
	    do{
		printf("Chiave: ");
		scanf("%d",&c);
	     }while(c<0 || c>26);
	
	    while(testo[n]!= '\0')  
		n++;           
	
	    for(i=0;i<n;i++)
		if(testo[i]<'Z'-c)
			testoc[i]=testo[i]+c;
		else
			testoc[i]='A'+c-('Z'-testo[i])-1;
	
	    testoc[n] = '\0';
	
	    printf("Testo criptato : %s\n",testoc);
		
	    for(i=0;i<n;i++)
		if(testoc[i]<'A'+c)
			testod[i] = 'Z'-(c-(testoc[i]-'A')-1);
		else
			testod[i] = testoc[i] - c;
		
		testod[n] = '\0';
		
		printf("Testo decriptato: %s\n",testod);
	}
	else
	    printf("Errore il testo deve essere maiuscolo e senza spazi vuoti\n");
}

Nella prossima lezione svilupperemo l’algoritmo sul cifrario di Cesare, leggendo il testo da un file.

Alcuni link utili

Indice argomenti linguaggio C

La funzione fopen

La funzione fclose

Funzione fprintf

Funzione fscanf

Allocazione dinamica della memoria con malloc

Strutture in C

Typedef struct in C

Esercitazione sulle struct in C

Realizzare un menù di scelta in C

Strutture complesse in C

Come sommare gli elementi della cornice esterna

Come sommare due matrici

Matrice trasposta

Prodotto tra matrici

Ricerca elementi in una matrice

Tavola pitagorica in C

Array multidimensionali

Quick sort in C

Selection sort in C

Merge sort in C

Insertion Sort in C

Gestione di una pila mediante un array

da Cristina | Mag 29, 2019 | Tutorial C

In questo articolo implementeremo la gestione di una pila mediante un array in C.

Nella lezione precedente abbiamo già visto un metodo per la gestione di una pila in C, utilizzando le variabili globali Pila[MAX] e testa di tipo intero. Nell’esempio queste variabili rappresentano l’array e l’indice testa che va da 0 a MAX. Dunque se MAX ad esempio vale 10, testa va da 0 a 10.

La lezione è consultabile al seguente link: pila in C.

In questa lezione impareremo invece a gestire la pila tramite l’uso di funzioni con passaggio di parametri.

Gestione di una pila mediante un array – procedimento

Utilizzeremo dunque queste funzioni di cui elenchiamo i prototipi e le definizioni.

Funzione Push

int Push(int Pila[], int *testa, int n);

Ho costruito questa funzione in modo da prevedere il passaggio dei seguenti parametri:

Pila – il puntatore alla struttura dati (array) che contiene la pila fisicamente;

testa – il puntatore alla testa della pila;

n – l’elemento da inserire.

La funzione restituisce un intero *testa che rappresenta la posizione del puntatore dopo l’inserimento di ciascun valore.

Dunque costruiamo la nostra funzione in questo modo:

Inseriamo l’elemento nella posizione dell’array indicato da *testa. Dopo incrementiamo di uno il valore di *testa:

//inseriamo l’elemento nella posizione indicata da *testa
Pila[*testa]=n;
//incrementiamo di 1 *testa
++*testa;

int Push(int Pila[], int *testa, int n) {
		Pila[*testa]=n;
		++*testa;
		return (*testa);
}

Nel main invochiamo dunque la funzione Push in questo modo:

p=Push(Pila, &p, n);

Dunque in p memorizziamo l’indice ritornato dalla funzione Push.

Funzione Pop

int Pop(int Pila[], int *testa, int n);

La funzione Pop prevede il passaggio dei parametri, Pila, testa ed n. 

La funzione restituisce un intero *testa che rappresenta la posizione del puntatore dopo l’eliminazione del valore al top.

Dunque costruiamo la nostra funzione Pop in questo modo:

Decrementiamo di uno il valore di *testa (cioè il puntatore alla testa della pila). Dopo assegniamo il valore dell’elemento in testa alla pila ad n e restituiamo il nuovo puntatore alla pila.

int Pop(int Pila[], int *testa, int n) {
			--*testa;
			n=Pila[*testa];
			printf("\n -> Elemento rimosso %d" , Pila[*testa]);
			return (*testa);
}

Pertanto nel main invochiamo la funzione Pop in questo modo:

p=Pop(Pila, &p, n);

Quindi in p memorizziamo l’indice ritornato dalla funzione Pop.

Funzione Print

void Print(int Pila[], int testa);

I parametri passati sono quindi:

Pila – il puntatore alla struttura dati;

testa – l’indice della testa della pila.

La funzione non restituisce pertanto alcun valore.

Dunque costruiamo la nostra funzione Print in questo modo:

void Print(int Pila[], int testa) {
	while(testa>=1) 
		printf("indice %d elemento: %d\n", testa, Pila[--testa]);		
}

Con un ciclo while che continua finché l’indice testa è maggiore o uguale a 1, decrementiamo testa e stampiamo il valore corrispondente.

Infatti se ad esempio la pila fosse piena, l’indice testa partirebbe da MAX dove non c’è alcun valore.

Quindi se testa si trova ad esempio in posizione 3, dove non c’è nessun elemento, allora decrementiamo testa di 1 e stampiamo l’elemento corrispondente.

Invochiamo poi la funzione nel programma principale in questo modo:

Print(Pila, p);

Funzione Clear

int Clear(int testa);

Ho costruito questa funzione in modo da prevedere il passaggio come parametro solo dell’indice testa.

Dunque ecco la nostra funzione Clear:

int Clear(int testa) {
	printf("\n -> Pila svuotata");	
	return 0;		
}

Facciamo restituire alla funzione semplicemente 0 che rappresenta l’indice della Pila.

Nel main invochiamo dunque la funzione in questo modo:

p=Clear(p);

Ecco dunque il listato completo della gestione di una pila mediante un array:

#include <stdio.h>

#define MAX 10


int menu_scelta(void)
{
  int selezione = 0;
  do
    {
    printf("\n" );
    printf("\n1 -> Aggiungi un dato" );
    printf("\n2 -> Estrai un dato");
    printf("\n3 -> Svuota pila");
    printf("\n4 -> Stampa pila");
    printf("\n5 -> Esci");
    printf("\n" );
    printf("\nEffettua una scelta: " );
    scanf("%d", &selezione );
    } while (selezione<1 || selezione>5);
  return selezione;
}

int Push(int Pila[], int *testa, int n) {
	Pila[*testa]=n;
	++*testa;
	return (*testa);
}

int Pop(int Pila[], int *testa, int n) {
	--*testa;
	n=Pila[*testa];
	printf("\n -> Elemento rimosso %d" , Pila[*testa]);
	return (*testa);
}

int Clear(int testa) {
	printf("\n -> Pila svuotata" );	
	return 0;		
}

void Print(int Pila[], int testa) {
	while(testa>=1) 
		printf("indice %d elemento: %d\n", testa, Pila[--testa]);		
}

int main(){
	int scelta;
	int Pila[MAX];
	int n, p=0;
	
	while((scelta=menu_scelta())!=5){
           switch(scelta){
              case 1: 
        	     if(p==MAX)
        		  printf("\nPila piena! " );
        	     else {
        		  printf("\nInserisci un dato: " );
				scanf("%d", &n);
				p=Push(Pila, &p,n);
		     }
                     break;
             case 2:
		    p=Pop(Pila, &p, n);
                    break;
            case 3:
		    p=Clear(p);
                    break;
             case 4: 
		    if(p==0)
        		printf("\nPila vuota! " );
        	     else 
			Print(Pila, p);
			break;
	      case 5: 	
			break;
             }
    }             
    return 0;
}

Alcuni link utili

Indice argomenti linguaggio C

La funzione fopen

La funzione fclose

Funzione fprintf

Funzione fscanf

Allocazione dinamica della memoria con malloc

Typedef struct in C

Esercitazione sulle struct in C

Realizzare un menù di scelta in C

Strutture complesse in C

Come sommare gli elementi della cornice esterna

Come sommare due matrici

Matrice trasposta

Prodotto tra matrici

Ricerca elementi in una matrice

Tavola pitagorica in C

Array multidimensionali

Quick sort in C

Insertion Sort in C