The Algorithms logo
The Algorithms

Playfair Cipher


The Playfair cipher was developed by Charles Wheatstone in 1854
It's use was heavily promotedby Lord Playfair, hence its name

Some features of the Playfair cipher are:

1) It was the first literal diagram substitution cipher
2) It is a manual symmetric encryption technique
3) It is a multiple letter encryption cipher

The implementation in the code below encodes alphabets only.
It removes spaces, special characters and numbers from the

Playfair is no longer used by military forces because of known
insecurities and of the advent of automated encryption devices.
This cipher is regarded as insecure since before World War I.

import itertools
import string
from import Generator, Iterable

def chunker(seq: Iterable[str], size: int) -> Generator[tuple[str, ...], None, None]:
    it = iter(seq)
    while True:
        chunk = tuple(itertools.islice(it, size))
        if not chunk:
        yield chunk

def prepare_input(dirty: str) -> str:
    Prepare the plaintext by up-casing it
    and separating repeated letters with X's

    dirty = "".join([c.upper() for c in dirty if c in string.ascii_letters])
    clean = ""

    if len(dirty) < 2:
        return dirty

    for i in range(len(dirty) - 1):
        clean += dirty[i]

        if dirty[i] == dirty[i + 1]:
            clean += "X"

    clean += dirty[-1]

    if len(clean) & 1:
        clean += "X"

    return clean

def generate_table(key: str) -> list[str]:
    # I and J are used interchangeably to allow
    # us to use a 5x5 table (25 letters)
    # we're using a list instead of a '2d' array because it makes the math
    # for setting up the table and doing the actual encoding/decoding simpler
    table = []

    # copy key chars into the table if they are in `alphabet` ignoring duplicates
    for char in key.upper():
        if char not in table and char in alphabet:

    # fill the rest of the table in with the remaining alphabet chars
    for char in alphabet:
        if char not in table:

    return table

def encode(plaintext: str, key: str) -> str:
    Encode the given plaintext using the Playfair cipher.
    Takes the plaintext and the key as input and returns the encoded string.

    >>> encode("Hello", "MONARCHY")
    >>> encode("attack on the left flank", "EMERGENCY")
    >>> encode("Sorry!", "SPECIAL")
    >>> encode("Number 1", "NUMBER")
    >>> encode("Photosynthesis!", "THE SUN")

    table = generate_table(key)
    plaintext = prepare_input(plaintext)
    ciphertext = ""

    for char1, char2 in chunker(plaintext, 2):
        row1, col1 = divmod(table.index(char1), 5)
        row2, col2 = divmod(table.index(char2), 5)

        if row1 == row2:
            ciphertext += table[row1 * 5 + (col1 + 1) % 5]
            ciphertext += table[row2 * 5 + (col2 + 1) % 5]
        elif col1 == col2:
            ciphertext += table[((row1 + 1) % 5) * 5 + col1]
            ciphertext += table[((row2 + 1) % 5) * 5 + col2]
        else:  # rectangle
            ciphertext += table[row1 * 5 + col2]
            ciphertext += table[row2 * 5 + col1]

    return ciphertext

def decode(ciphertext: str, key: str) -> str:
    Decode the input string using the provided key.

    >>> decode("BMZFAZRZDH", "HAZARD")
    >>> decode("HNBWBPQT", "AUTOMOBILE")
    >>> decode("SLYSSAQS", "CASTLE")

    table = generate_table(key)
    plaintext = ""

    for char1, char2 in chunker(ciphertext, 2):
        row1, col1 = divmod(table.index(char1), 5)
        row2, col2 = divmod(table.index(char2), 5)

        if row1 == row2:
            plaintext += table[row1 * 5 + (col1 - 1) % 5]
            plaintext += table[row2 * 5 + (col2 - 1) % 5]
        elif col1 == col2:
            plaintext += table[((row1 - 1) % 5) * 5 + col1]
            plaintext += table[((row2 - 1) % 5) * 5 + col2]
        else:  # rectangle
            plaintext += table[row1 * 5 + col2]
            plaintext += table[row2 * 5 + col1]

    return plaintext

if __name__ == "__main__":
    import doctest


    print("Encoded:", encode("BYE AND THANKS", "GREETING"))
    print("Decoded:", decode("CXRBANRLBALQ", "GREETING"))
About this Algorithm

The Playfair cipher was invented in 1854 by Charles Wheatstone but was named after Lord Playfair who promoted the use of the cipher.

The Playfair cipher was the first practical digraph substitution cipher. In Playfair cipher unlike traditional cipher, we encrypt a pair of alphabets(digraphs) instead of a single alphabet. A 5 × 5 grid of alphabets was used as the key-square. Each of the 25 alphabets is unique and one letter of the alphabet (usually J) is omitted from the table. If the plaintext contains J, then it is replaced by I or vice-versa. The initial alphabets in the key square are the unique alphabets of the key in the order in which they appear followed by the remaining letters of the alphabet in order.


Suppose we take an example as:

Plain Text (PT): instruments, key: monarchy


  1. If both the letters are in the same column, take the letter below each one (going back to the top if at the bottom).
    Diagraph: "me"
    Encrypted Text: cl
      m -> c
      e -> l
  1. If both the letters are in the same row, take the letter to the right of each one (going back to the leftmost only if it's at the rightmost position).
    Diagraph: "st"
    Encrypted Text: tl
      s -> t
      t -> l
  1. If neither of the above rules is true, form a rectangle with the two letters, and take the letters on the horizontal opposite corner of the rectangle.
    Diagraph: "nt"
    Encrypted Text: rq
      n -> r
      t -> q

The rules above are used for Encryption. Can be applied vice-versa for Decryption.



  1. We have to generate a 5 × 5 matrix from the key as
   [m o n a r]
   [c h y b d]
   [e f g i k]
   [l p q s t]
   [u v w x z]
  1. Split the plaintext in digraphs(pair of two). If there is an odd number of letters, an X is added to the last letter. Pairs cannot be made with same letter. If this occurs, split the pair by adding an X between the duplicate letters.
   'in' 'st' 'ru' 'me' 'nt' 'sx'
  1. Now, we need to follow the rules for encrypting and do as follows:
    Plain Text: instrumentsx
    key: monarchy
      i -> g
      n -> a
      s -> t
      t -> l
      r -> m
      u -> z
      m -> c
      e -> l
      n -> r
      t -> q
      s -> x
      x -> a

So we will get the encrypted text as gatlmzclrqxa.


  1. We have to generate a 5 × 5 matrix from the key as
   [m o n a r]
   [c h y b d]
   [e f g i k]
   [l p q s t]
   [u v w x z]
  1. We need to split the ciphertext as done for plaintext while encrypting
   'ga' 'tl' 'mz' 'cl' 'rq' 'xa'
  1. For the previous Cipher Text gatlmzclrqxa, by following the rules we get:
    Plain Text: gatlmzclrqtx
    key: monarchy
      ga -> in
      tl -> st
      mz -> ru
      cl -> me
      rq -> nt
      xa -> sx

So we will get the encrypted text as instrumentsx.

Video Explanation