E' un particolare tipo di cifrario, che associa all'n-esima lettera dell'alfabeto

la (n+3)-esima lettera dell'alfabeto.

Un cifrario di questo tipo � strutturato cosi:

1) Alfabeto E' l'insieme dei caratteri cui attingiamo per scrivere il

messaggio;
2) Regole La logica alla base della cifratura;
3) Testo Il messaggio da cifrare;
4) Regole Inverse La logica alla base della decifratura.

Per prima cosa, bisogna definire l'alfabeto, che chiameremo alph, dunque
scriveremo:

alph = CharacterRange["A", "Z"]

Osservazione 1: l'alfabeto � composto da 26 lettere, quindi � una lista di 26

elementi.
Osservazione 2: questa lista comprende solo le lettere maiuscole.

Adesso � necessario definire la regola ( che chiameremo rule ) che associa all'n-
esima lettera dell'alfabeto la (n+3)-esima lettera dell'alfabeto. Ovviamente, �
scomodo definire 26 funzioni ( una per ogni lettera ), dunque vogliamo definire una
successione di funzioni con un solo comando. Per farlo ci serviamo di una funzione
Table in questa forma, sulla quale apporteremo gradualmente le dovute modifiche:

rule = Table[alph[[n]] -> alph[[n + 3]], {n, 26}]

Osservazione: l'argomento n � fra doppie quadre poich� rappresenta l'elemento n-

esimo di una lista.

Chiaramente, in questo caso conosciamo la cardinalit� della lista alph, ma vogliamo

impostare un discorso pi� generale. Dunque riscriveremo il comando nella forma pi�
generale:

rule = Table[alph[[n]] -> alph[[n + 3]], {n, Length[alph]}]

Tuttavia il comando non � ancora completo, infatti ci restituirebbe errore. Questo

perch�, poich� trasliamo ogni lettera di 3 posizioni, le ultime 3 posizioni
( avendo alph cardinalit� fissa a 26 ) non hanno elementi cui possono essere
associati, dato che non esistono le posizioni 27, 28 e 29 ( ovvero 24+3,25+3 e
26+3, in base alla regola che abbiamo definito ). Sar� necessario dare alla nostra
regola un'impianto ciclico, in modo che alle ultime 3 lettere dell'alfabeto vengano
associate le prime 3. Per farlo, applichiamo rule solo alle prime 23 lettere e
riserviamo alle ultime 3 lettere 3 regole apposite. Per farlo, sfruttiamo dei
blocchi di Append annidati ( su una stessa linea ), in modo da accodare queste
regole a rule: chiameremo la nuova regola risultante, rule1, ritrovandoci a
schermo:

alph = CharacterRange["A", "Z"]

rule = Table[alph[[n]] -> alph[[n + 3]], {n, Length[alph] - 3}]
rule1 = Append[Append[Append[rule, "X" -> "A"], "Y" -> "B"],
"Z" -> "C"]

E dunque avremo:

{"A" -> "D", "B" -> "E", "C" -> "F", "D" -> "G", "E" -> "H", "F" -> "I", "G" ->
"J", "H" -> "K", "I" -> "L", "J" -> "M", "K" -> "N", "L" -> "O", "M" -> "P", "N" ->
"Q", "O" -> "R", "P" -> "S", "Q" -> "T", "R" -> "U", "S" -> "V", "T" -> "W", "U" ->
"X", "V" -> "Y", "W" -> "Z", "X" -> "A", "Y" -> "B", "Z" -> "C"}

Abbiamo appena definito le regole per la cifratura. Definiamo ora il messaggio da

cifrare, chiamiandolo msg, che in questa prima fase necessita di essere
inizializzato, fra doppi apici:

msg = "TUTTE LE LEGIONI DEVONO SPOSTARSI A ROMA"

Per legare il blocco di regole, definito in precedenza, a questo messaggio e

cifrarlo, ci serviamo del comando StringReplace. Il messaggio cifrato, encmsg, sar�
dato

encmsg = StringReplace[msg, rule1]

Osservazione: al messaggio ( msg ) abbiamo applicato rule1 e non rule, perch�

altrimenti non sarebbero stati presi in considerazione i successivi Append ( vedi
teoria su comando Append ).

Abbiamo appena definito un programma che cifra un messaggio inizializzato:

alph = CharacterRange["A", "Z"]

rule = Table[alph[[n]] -> alph[[n + 3]], {n, Length[alph] - 3}]
rule1 = Append[Append[Append[rule, "X" -> "A"], "Y" -> "B"], "Z" -> "C"]
msg = "TUTTE LE LEGIONI DEVONO SPOSTARSI A ROMA"
encmsg = StringReplace[msg, rule1]

Che ci restituir�: "WXWWH OH OHJLRQL GHYRQR VSRVWDUVL D URPD".

Osservazione 1: il carattere di spazio non viene cifrato, poich� non � compreso

nella lista alph, dunque avremo degli spazi fra le lettere.
Osservazione 2: le doppie restano doppie, anche nel messaggio cifrato ( TUTTE ->
WXWWH ).

Adesso occupiamoci della decifratura ( quindi le regola inverse ). Per farlo,

potremmo definire le esatte regole inverse, riscrivendole tutte "al contrario"
( notare infatti che stiamo lavorando con funzioni biettive ). Tuttavia, questa
pratica richiederebbe troppo tempo, mentre esiste una via pi� economica. Iniziamo
col fare alcune considerazioni. Con rule abbiamo associato ad ogni lettera
dell'alfabeto, una ed una sola lettera dell'alfabeto ( chiaramente diversa ),
dunqua abbiamo formato coppie ordinate, tali che il primo elemento sia la lettera
originale ed il secondo, quella cifrata. Questo ci permette di introdurre una
regola inversa, irule, cosi definita:

irule = Table[rule1[[n, 2]] -> rule1[[n, 1]], {n, Length[rule1]}]

Stiamo lavorando per coppie e, nello specifico, stiamo associando all'ennesimo

secondo elemento di ogni coppia, ovvero [n, 2] ( la lettera cifrata ), l'ennesimo
primo elemento di ogni coppia, ovvero [n, 1] ( la lettera originale ). Notare
infatti che stiamo prendendo in considerazione rule ( o meglio, rule1, dato che
dobbiamo citare l'ultimo Append ) e non alph, dunque una funzione e non una lista.
Di fatto, poich� lavoriamo con una FUNZIONE, per di pi� biettiva, stiamo invertendo
il suo dominio con il suo codominio. Questa linea ci restituir� dunque la funzione
inversa di rule ( rule1 ), ossia:

{"D" -> "A", "E" -> "B", "F" -> "C", "G" -> "D", "H" -> "E", "I" -> "F", "J" ->
"G", "K" -> "H", "L" -> "I", "M" -> "J", "N" -> "K", "O" -> "L", "P" -> "M", "Q" ->
"N", "R" -> "O", "S" -> "P", "T" -> "Q", "U" -> "R", "V" -> "S", "W" -> "T", "X" ->
"U", "Y" -> "V", "Z" -> "W", "A" -> "X", "B" -> "Y", "C" -> "Z"}
Adesso applichiamo la nuova regola al messaggio cifrato, encmsg, scrivendo:

StringReplace[encmsg, irule]

Che ci restituir� il messaggio originale. Il cifrario completo, dunque, �:

alph = CharacterRange["A", "Z"]

rule = Table[alph[[n]] -> alph[[n + 3]], {n, Length[alph] - 3}]
rule1 = Append[Append[Append[rule, "X" -> "A"], "Y" -> "B"],
"Z" -> "C"]
msg = "TUTTE LE LEGIONI DEVONO SPOSTARSI A ROMA"
encmsg = StringReplace[msg, rule1]
irule = Table[rule1[[n, 2]] -> rule1[[n, 1]], {n, Length[rule1]}]
StringReplace[encmsg, irule]