关键字密码

关键字密码是单字母替换的一种形式。关键字作为关键字，它决定了密码字母表与普通字母表的字母匹配。去除单词中的重复字母，然后生成密文字母，关键字匹配A、B、C等，直到关键字用完，其余密文字母按字母顺序使用，不包括那些已在密钥中使用。

加密

输入的第一行包含您要输入的关键字。第二行输入包含您必须加密的字符串。
明文： ABCDEFGHIJKLMNOPQRSTU VWXY Z
加密： KRYPTOSABCDEFGHIJLMNQ UVWXZ
以 KRYPTOS 为关键字，所有 As 变为 Ks，所有 Bs 变为 Rs，以此类推。使用关键字“Kryptos”加密信息“知识就是力量”：
加密信息：知识就是力量
编码消息：IlmWjbaEb GQ NmWbp
例子：

Input :
Keyword : secret
Message : Zombie Here
Output :
Ciphered String : ZLJEFT DTOT

Take the first example, we used "secret" keyword there.
Plain Text : 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
When "secret" keyword is used, the new encrypting text becomes :
Encrypting : S E C R T A B D F G H I J K L M N O P Q U V W X Y Z
This means 'A' means 'S', 'B' means 'E' and 'C' means 'C' and so on.
Lets encode the given message "Zombie Here"
ZOMBIE HERE becomes ZLJEFT DTOT

Input :
Keyword : Star War
Message : Attack at dawn
Output :
Ciphered String : SPPSAG SP RSVJ

该方法需要注意的几点：

• 所有消息都以大写形式编码。
• 空格、特殊字符和数字不考虑关键字，尽管您可以将它们放在其中。
• 在加密消息时，空格、特殊字符和数字不受影响。

C++

// CPP program for encoding the string
// using classical cipher
 
#include
using namespace std;
 
// Function generates the encoded text
string encoder(string key)
{
    string encoded = "";
    // This array represents the
    // 26 letters of alphabets
    bool arr[26] = {0};
 
    // This loop inserts the keyword
    // at the start of the encoded string
    for (int i=0; i= 'A' && key[i] <= 'Z')
        {
            // To check whether the character is inserted
            // earlier in the encoded string or not
            if (arr[key[i]-65] == 0)
            {
                encoded += key[i];
                arr[key[i]-65] = 1;
            }
        }
        else if (key[i] >= 'a' && key[i] <= 'z')
        {
            if (arr[key[i]-97] == 0)
            {
                encoded += key[i] - 32;
                arr[key[i]-97] = 1;
            }
        }
    }
 
    // This loop inserts the remaining
    // characters in the encoded string.
    for (int i=0; i<26; i++)
    {
        if(arr[i] == 0)
        {
            arr[i]=1;
            encoded += char(i + 65);
        }
    }
    return encoded;
}
 
// Function that generates encodes(cipher) the message
string cipheredIt(string msg, string encoded)
{
    string cipher="";
 
    // This loop ciphered the message.
    // Spaces, special characters and numbers remain same.
    for (int i=0; i='a' && msg[i] <='z')
        {
            int pos = msg[i] - 97;
            cipher += encoded[pos];
        }
        else if (msg[i] >='A' && msg[i] <='Z')
        {
            int pos = msg[i] - 65;
            cipher += encoded[pos];
        }
        else
        {
            cipher += msg[i];
        }
    }
    return cipher;
}
 
// Driver code
int main()
{
    // Hold the Keyword
    string key;
    key = "Computer";
    cout << "Keyword : " <

---

Java

// Java program for encoding the string
// using classical cipher
 
class GFG
{
 
    // Function generates the encoded text
    static String encoder(char[] key)
    {
        String encoded = "";
         
        // This array represents the
        // 26 letters of alphabets
        boolean[] arr = new boolean[26];
 
        // This loop inserts the keyword
        // at the start of the encoded string
        for (int i = 0; i < key.length; i++)
        {
            if (key[i] >= 'A' && key[i] <= 'Z')
            {
                // To check whether the character is inserted
                // earlier in the encoded string or not
                if (arr[key[i] - 65] == false)
                {
                    encoded += (char) key[i];
                    arr[key[i] - 65] = true;
                }
            }
            else if (key[i] >= 'a' && key[i] <= 'z')
            {
                if (arr[key[i] - 97] == false)
                {
                    encoded += (char) (key[i] - 32);
                    arr[key[i] - 97] = true;
                }
            }
        }
 
        // This loop inserts the remaining
        // characters in the encoded string.
        for (int i = 0; i < 26; i++)
        {
            if (arr[i] == false)
            {
                arr[i] = true;
                encoded += (char) (i + 65);
            }
        }
        return encoded;
    }
 
    // Function that generates encodes(cipher) the message
    static String cipheredIt(String msg, String encoded)
    {
        String cipher = "";
 
        // This loop ciphered the message.
        // Spaces, special characters and numbers remain same.
        for (int i = 0; i < msg.length(); i++)
        {
            if (msg.charAt(i) >= 'a' && msg.charAt(i) <= 'z')
            {
                int pos = msg.charAt(i) - 97;
                cipher += encoded.charAt(pos);
            }
            else if (msg.charAt(i) >= 'A' && msg.charAt(i) <= 'Z')
            {
                int pos = msg.charAt(i) - 65;
                cipher += encoded.charAt(pos);
            }
            else
            {
                cipher += msg.charAt(i);
            }
        }
        return cipher;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        // Hold the Keyword
        String key;
        key = "Computer";
        System.out.println("Keyword : " + key);
 
        // Function call to generate encoded text
        String encoded = encoder(key.toCharArray());
 
        // Message that need to encode
        String message = "GeeksforGeeks";
        System.out.println("Message before Ciphering : " + message);
 
        // Function call to print ciphered text
        System.out.println("Ciphered Text : " + cipheredIt(message,
                encoded));
    }
}
 
// This code is contributed by 29AjayKumar

C#

// C# program for encoding the string
// using classical cipher
using System;
     
class GFG
{
 
    // Function generates the encoded text
    static String encoder(char[] key)
    {
        String encoded = "";
         
        // This array represents the
        // 26 letters of alphabets
        Boolean[] arr = new Boolean[26];
 
        // This loop inserts the keyword
        // at the start of the encoded string
        for (int i = 0; i < key.Length; i++)
        {
            if (key[i] >= 'A' && key[i] <= 'Z')
            {
                // To check whether the character is inserted
                // earlier in the encoded string or not
                if (arr[key[i] - 65] == false)
                {
                    encoded += (char) key[i];
                    arr[key[i] - 65] = true;
                }
            }
            else if (key[i] >= 'a' && key[i] <= 'z')
            {
                if (arr[key[i] - 97] == false)
                {
                    encoded += (char) (key[i] - 32);
                    arr[key[i] - 97] = true;
                }
            }
        }
 
        // This loop inserts the remaining
        // characters in the encoded string.
        for (int i = 0; i < 26; i++)
        {
            if (arr[i] == false)
            {
                arr[i] = true;
                encoded += (char) (i + 65);
            }
        }
        return encoded;
    }
 
    // Function that generates encodes(cipher) the message
    static String cipheredIt(String msg, String encoded)
    {
        String cipher = "";
 
        // This loop ciphered the message.
        // Spaces, special characters and numbers remain same.
        for (int i = 0; i < msg.Length; i++)
        {
            if (msg[i] >= 'a' && msg[i] <= 'z')
            {
                int pos = msg[i] - 97;
                cipher += encoded[pos];
            }
            else if (msg[i] >= 'A' && msg[i] <= 'Z')
            {
                int pos = msg[i] - 65;
                cipher += encoded[pos];
            }
            else
            {
                cipher += msg[i];
            }
        }
        return cipher;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        // Hold the Keyword
        String key;
        key = "Computer";
        Console.WriteLine("Keyword : " + key);
 
        // Function call to generate encoded text
        String encoded = encoder(key.ToCharArray());
 
        // Message that need to encode
        String message = "GeeksforGeeks";
        Console.WriteLine("Message before Ciphering : " + message);
 
        // Function call to print ciphered text
        Console.WriteLine("Ciphered Text : " + cipheredIt(message,
                encoded));
    }
}
 
/* This code contributed by PrinciRaj1992 */

Javascript

 
// JavaScript program for encoding the string
// using classical cipher
 
// Function generates the encoded text
function encoder(key)
{
    let encoded = "";
           
        // This array represents the
        // 26 letters of alphabets
        let arr = new Array(26);
        for(let i=0;i<26;i++)
        {
            arr[i]=false;
        }
   
        // This loop inserts the keyword
        // at the start of the encoded string
        for (let i = 0; i < key.length; i++)
        {
            if (key[i].charCodeAt(0) >= 'A'.charCodeAt(0) &&
            key[i].charCodeAt(0) <= 'Z'.charCodeAt(0))
            {
                // To check whether the character is inserted
                // earlier in the encoded string or not
                if (arr[key[i].charCodeAt(0) - 65] == false)
                {
                    encoded += ( key[i]);
                    arr[key[i].charCodeAt(0) - 65] = true;
                }
            }
            else if (key[i].charCodeAt(0) >= 'a'.charCodeAt(0) &&
            key[i].charCodeAt(0) <= 'z'.charCodeAt(0))
            {
                if (arr[key[i].charCodeAt(0) - 97] == false)
                {
                    encoded +=
                    String.fromCharCode(key[i].charCodeAt(0) - 32);
                    arr[key[i].charCodeAt(0) - 97] = true;
                }
            }
        }
   
        // This loop inserts the remaining
        // characters in the encoded string.
        for (let i = 0; i < 26; i++)
        {
            if (arr[i] == false)
            {
                arr[i] = true;
                encoded += String.fromCharCode(i + 65);
            }
        }
        return encoded;
}
 
// Function that generates encodes(cipher) the message
function cipheredIt(msg,encoded)
{
     let cipher = "";
   
        // This loop ciphered the message.
        // Spaces, special characters and numbers remain same.
        for (let i = 0; i < msg.length; i++)
        {
            if (msg[i] >= 'a' && msg[i] <= 'z')
            {
                let pos = msg[i].charCodeAt(0) - 97;
                cipher += encoded[pos];
            }
            else if (msg[i] >= 'A' && msg[i] <= 'Z')
            {
                let pos = msg[i].charCodeAt(0) - 65;
                cipher += encoded[pos];
            }
            else
            {
                cipher += msg[i];
            }
             
        }
        return cipher;
}
 
// Driver code
// Hold the Keyword
let key;
key = "Computer";
document.write("Keyword : " + key+"<br>");
 
// Function call to generate encoded text
let encoded = encoder(key.split(""));
 
// Message that need to encode
let message = "GeeksforGeeks";
document.write("Message before Ciphering : " + message+"<br>");
 
// Function call to print ciphered text
document.write("Ciphered Text : " + cipheredIt(message,
                                                   encoded));
 
 
// This code is contributed by rag2127
 

输出：

Keyword : Computer
Message before Ciphering : GeeksforGeeks
Ciphered Text : EUUDNTILEUUDN

解密

要解码消息，请检查给定消息在使用纯文本加密文本时的位置。
明文： ABCDEFGHIJKLMNOPQRSTU VWXY Z
加密： KRYPTOSABCDEFGHIJLMNQ UVWXZ
消息：PTYBIATLEP
解密文本：已解密
现在，我们如何生成解密的字符串？
我们在加密文本中搜索“P”并将其位置与纯文本字母进行比较并生成该字母。所以“P”变成“D”，“T”变成“E”，“Y”变成“C”，以此类推。
例子：


Input :
Keyword : secret
Message : zljeft dtOT
Output :
Deciphered String : ZOMBIE HERE

Input :
Keyword : joker0O7hack123
Message : QjTijl
Output :
Deciphered String : BATMAN

CPP

// CPP program for decoding the string
// which generate using classical cipher
 
#include
using namespace std;
 
// Original Set of letters
string plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
// Function generates the encoded text
string encoder(string key)
{
    string encoded = "";
    bool arr[26] = {0};
 
    // This loop inserts the keyword
    // at the start of the encoded string
    for (int i=0; i= 'A' && key[i] <= 'Z')
        {
            // To check whether the character is inserted
            // earlier in the encoded string or not
            if (arr[key[i]-65] == 0)
            {
                encoded += key[i];
                arr[key[i]-65] = 1;
            }
        }
        else if (key[i] >= 'a' && key[i] <= 'z')
        {
            if (arr[key[i]-97] == 0)
            {
                encoded += key[i] - 32;
                arr[key[i]-97] = 1;
            }
        }
    }
 
    // This loop inserts the remaining
    // characters in the encoded string.
    for (int i=0; i<26; i++)
    {
        if(arr[i] == 0)
        {
            arr[i]=1;
            encoded += char(i + 65);
        }
    }
    return encoded;
}
 
// This function will decode the message
string decipheredIt(string msg, string encoded)
{
    // Hold the position of every character (A-Z)
    // from encoded string
    map  enc;
    for(int i=0; i='a' && msg[i] <='z')
        {
            int pos = enc[msg[i]-32];
            decipher += plaintext[pos];
        }
        else if(msg[i] >='A' && msg[i] <='Z')
        {
            int pos = enc[msg[i]];
            decipher += plaintext[pos];
        }
        else
        {
            decipher += msg[i];
        }
    }
    return decipher;
}
 
// Driver code
int main()
{
    // Hold the Keyword
    string key;
    key = "Computer";
    cout << "Keyword : "<< key << endl;
 
    // Function call to generate encoded text
    string encoded = encoder(key);
 
    // Message that need to decode
    string message = "EUUDN TIL EUUDN";
    cout << "Message before Deciphering : " << message << endl;
 
    // Function call to print deciphered text
    cout << "Deciphered Text : " << decipheredIt(message,encoded) << endl;
 
    return 0;
}

输出：


Keyword : Computer
Message before Deciphering : EUUDN TIL EUUDN
Deciphered Text : GEEKS FOR GEEKS