Implementation of the A1Z26 cipher More...

#include <algorithm>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

Include dependency graph for a1z26_cipher.cpp:

Namespaces
namespace	ciphers
	Algorithms for encryption and decryption.

namespace	a1z26
	Functions for A1Z26 encryption and decryption implementation.

Functions
std::string	ciphers::a1z26::encrypt (std::string text)
	a1z26 encryption implementation

std::string	ciphers::a1z26::decrypt (const std::string &text, bool bReturnUppercase=false)
	a1z26 decryption implementation

static void	test ()
	Self-test implementations.

int	main ()
	Main function.

Variables
std::map< uint8_t, char >	ciphers::a1z26::a1z26_decrypt_map

std::map< char, uint8_t >	ciphers::a1z26::a1z26_encrypt_map

Detailed Description

Implementation of the A1Z26 cipher

The A1Z26 cipher is a simple substiution cipher where each letter is replaced by the number of the order they're in. For example, A corresponds to 1, B = 2, C = 3, etc.

Author: Focusucof

Definition in file a1z26_cipher.cpp.

Function Documentation

◆ decrypt()

std::string ciphers::a1z26::decrypt	(	const std::string &	text,
		bool	bReturnUppercase = false )

a1z26 decryption implementation

Parameters

text	is the encrypted text input
bReturnUppercase	is if the decoded string should be in uppercase or not

Returns: the decrypted string in all uppercase or all lowercase

Definition at line 78 of file a1z26_cipher.cpp.

                                                                        {
    std::string result;
 
    // split words seperated by spaces into a vector array
    std::vector<std::string> word_array;
    std::stringstream sstream(text);
    std::string word;
    while (sstream >> word) {
        word_array.push_back(word);
    }
 
    for (auto& i : word_array) {
        std::replace(i.begin(), i.end(), '-', ' ');
        std::vector<std::string> text_array;
 
        std::stringstream ss(i);
        std::string res_text;
        while (ss >> res_text) {
            text_array.push_back(res_text);
        }
 
        for (auto& i : text_array) {
            result += a1z26_decrypt_map[stoi(i)];
        }
 
        result += ' ';
    }
    result.pop_back();  // remove any leading whitespace
 
    if (bReturnUppercase) {
        std::transform(result.begin(), result.end(), result.begin(), ::toupper);
    }
    return result;
}

◆ encrypt()

std::string ciphers::a1z26::encrypt ( std::string text )

a1z26 encryption implementation

Parameters

text	is the plaintext input

Returns: encoded string with dashes to seperate letters

Definition at line 51 of file a1z26_cipher.cpp.

                                  {
    std::string result;
    std::transform(text.begin(), text.end(), text.begin(),
                   ::tolower);  // convert string to lowercase
    std::replace(text.begin(), text.end(), ':', ' ');
    for (char letter : text) {
        if (letter != ' ') {
            result += std::to_string(
                a1z26_encrypt_map[letter]);  // convert int to string and append
                                             // to result
            result += "-";  // space out each set of numbers with spaces
        } else {
            result.pop_back();
            result += ' ';
        }
    }
    result.pop_back();  // remove leading dash
    return result;
}

◆ main()

int main ( void )

Main function.

Returns: 0 on exit

Definition at line 159 of file a1z26_cipher.cpp.

           {
    test();  // run self-test implementations
    return 0;
}

◆ test()

static void test ( )

static

Self-test implementations.

Returns: void

Definition at line 120 of file a1z26_cipher.cpp.

                   {
    // 1st test
    std::string input = "Hello World";
    std::string expected = "8-5-12-12-15 23-15-18-12-4";
    std::string output = ciphers::a1z26::encrypt(input);
 
    std::cout << "Input: " << input << std::endl;
    std::cout << "Expected: " << expected << std::endl;
    std::cout << "Output: " << output << std::endl;
    assert(output == expected);
    std::cout << "TEST PASSED";
 
    // 2nd test
    input = "12-15-23-5-18-3-1-19-5";
    expected = "lowercase";
    output = ciphers::a1z26::decrypt(input);
 
    std::cout << "Input: " << input << std::endl;
    std::cout << "Expected: " << expected << std::endl;
    std::cout << "Output: " << output << std::endl;
    assert(output == expected);
    std::cout << "TEST PASSED";
 
    // 3rd test
    input = "21-16-16-5-18-3-1-19-5";
    expected = "UPPERCASE";
    output = ciphers::a1z26::decrypt(input, true);
 
    std::cout << "Input: " << input << std::endl;
    std::cout << "Expected: " << expected << std::endl;
    std::cout << "Output: " << output << std::endl;
    assert(output == expected);
    std::cout << "TEST PASSED";
}

Variable Documentation

◆ a1z26_decrypt_map

std::map<uint8_t, char> ciphers::a1z26::a1z26_decrypt_map

Initial value:

= {
    {1, 'a'},  {2, 'b'},  {3, 'c'},  {4, 'd'},  {5, 'e'},  {6, 'f'},  {7, 'g'},
    {8, 'h'},  {9, 'i'},  {10, 'j'}, {11, 'k'}, {12, 'l'}, {13, 'm'}, {14, 'n'},
    {15, 'o'}, {16, 'p'}, {17, 'q'}, {18, 'r'}, {19, 's'}, {20, 't'}, {21, 'u'},
    {22, 'v'}, {23, 'w'}, {24, 'x'}, {25, 'y'}, {26, 'z'},
}

Definition at line 33 of file a1z26_cipher.cpp.

                                          {
    {1, 'a'},  {2, 'b'},  {3, 'c'},  {4, 'd'},  {5, 'e'},  {6, 'f'},  {7, 'g'},
    {8, 'h'},  {9, 'i'},  {10, 'j'}, {11, 'k'}, {12, 'l'}, {13, 'm'}, {14, 'n'},
    {15, 'o'}, {16, 'p'}, {17, 'q'}, {18, 'r'}, {19, 's'}, {20, 't'}, {21, 'u'},
    {22, 'v'}, {23, 'w'}, {24, 'x'}, {25, 'y'}, {26, 'z'},
};

◆ a1z26_encrypt_map

std::map<char, uint8_t> ciphers::a1z26::a1z26_encrypt_map