Java Program to Implement the Monoalphabetic Cypher

Monoalphabetic Cipher is a cipher where the letters of the plain text are mapped to ciphertext letters based on a single alphabetic key. It is a one to one mapping.

Given plain text, the task is to implement the Monoalphabetic Cipher.

Examples:

Input:  Welcome to geeksforgeeks
Output: Plain text: Welcome to geeksforgeeks
        Encrypted message: VTSEGDT ZG UTTALYGKUTTAL
        Decrypted message: welcome to geeksforgeeks

Input:  Live the moment
Output: Plain text: Live the moment
        Encrypted message: SOCT ZIT DGDTFZ
        Decrypted message: live the moment

Mapping characters to cipher text letters which we used in our code:

a	b	c	d	e	f	g	h	i	j
Q	W	E	R	T	Y	U	I	O	P
k	l	m	n	o	p	q	r	s	t
A	S	D	F	G	H	J	K	L	Z
u	v	w	x	y	z
X	C	V	B	N	M

Explanation of Output:

W – w – V	t – Z	g – U	g – U
e – T	o – G	e – T	e – T
l – S		e – T	e – T
c – E		k – A	k – A
o – G		s – L	s – L
m – D		f – Y
e – T		o – G
		r – K

Welcome to geeksforgeeks → VTSEGDT ZG UTTALYGKUTTAL

Approach: 

1.  Create two char arrays, one for normal alphabets(say normalChar[]) and another is for encoding(say codedChar[]).

2.  We will use two functions:

• stringEncryption: We pass string(string with all characters in lower case) as a parameter. Initialize an empty string(say encryptedString). We use for loop and compare each character with normal char array, whenever the condition is true, add the character with the corresponding index of codedChar to the encrypted string. In the case of special characters, we will add them directly to the string.
• stringDescryption: We pass the encrypted string as the parameter. Initialize an empty string(say descryptedString). In the same way, we run the for loop and add the character with the corresponding index of normalChar to the decrypted string. In the case of special characters, we will add them directly to the string.

Below is the implementation of the above approach:

Java

// Java Program to Implement the Monoalphabetic Cypher

import java.io.*;
class GFG {
    public static char normalChar[]
        = { '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' };

    public static char codedChar[]
        = { 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O',
            'P', 'A', 'S', 'D', 'F', 'G', 'H', 'J', 'K',
            'L', 'Z', 'X', 'C', 'V', 'B', 'N', 'M' };

    // Function which returns encrypted string
    public static String stringEncryption(String s)
    {
        // initializing an empty String
        String encryptedString = "";

        // comparing each character of the string and
        // encoding each character using the indices
        for (int i = 0; i < s.length(); i++) {
            for (int j = 0; j < 26; j++) {

                // comparing the character and
                // adding the corresponding char
                // to the encryptedString
                if (s.charAt(i) == normalChar[j])
                {
                    encryptedString += codedChar[j];
                    break;
                }

                // if there are any special characters
                // add them directly to the string
                if (s.charAt(i) < 'a' || s.charAt(i) > 'z')
                {
                    encryptedString += s.charAt(i);
                    break;
                }
            }
        }

        // return encryptedString
        return encryptedString;
    }

    // Function which returns descryptedString
    public static String stringDecryption(String s)
    {

        // Initializing the string
        String decryptedString = "";

        // Run the for loop for total string
        for (int i = 0; i < s.length(); i++)
        {
            for (int j = 0; j < 26; j++) {

                // compare each characters and decode them
                // using indices
                if (s.charAt(i) == codedChar[j])
                {
                    decryptedString += normalChar[j];
                    break;
                }

                // Add the special characters directly to
                // the String
                if (s.charAt(i) < 'A' || s.charAt(i) > 'Z')
                {
                    decryptedString += s.charAt(i);
                    break;
                }
            }
        }

        // return the decryptedString
        return decryptedString;
    }
    public static void main(String args[])
    {
        String str = "Welcome to geeksforgeeks";

        // print plain text
        System.out.println("Plain text: " + str);

        // Changing whole string to lower case
        // function call to stringEncryption and storing in
        // encryptedString
        String encryptedString = stringEncryption(str.toLowerCase());

        // printing encryptedString
        System.out.println("Encrypted message: "
                           + encryptedString);

        // function call to stringDecryption and printing
        // the decryptedString
        System.out.println("Decrypted message: "
            + stringDecryption(encryptedString));

    }
}

Output

Plain text: Welcome to geeksforgeeks
Encrypted message: VTSEGDT ZG UTTALYGKUTTAL
Decrypted message: welcome to geeksforgeeks