1. Toy模板网首页
  2. > Toy博客

凯撒密码_c++_java_python（加密及解密）

10月前 作者：mc_故事与你 分类：Toy博客 阅读(47) 违法举报

这篇具有很好参考价值的文章主要介绍了凯撒密码_c++_java_python（加密及解密）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.凯撒密码简介

公元前100多年凯撒发明的一种密码，简单来说是平移密码，也就是将字母位置向后移动一定位数。
如原文是ABCXYZ，密钥为3，加密后就是DEFABC。
以密钥的数字向后平移了三位，如果密钥是5就是平移五位。
解密就是把加密的文字进行还原。

2.凯撒密码分析

我们通过对题目的分析可以发现，加密与解密就是对字母的ASCII值移动n位后得到的字母，当我们对字母加密后解密就是加密的反过程。
总体来说就是对ASCII的处理。

3.代码实现

1.c++实现

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
char caidan();
void jiami();
void jiami_1(char mima_1[], char mima_2[]);
void jiemi();
void jiemi_1(char mima_1[], char mima_2[]);
int main() {
	while (1) {
		int n = caidan();
		if (n == '0') {
			cout << "已退出";
			return 0;
		}
		else if (n == '1') {
			jiami();
		}
		else if (n == '2') {
			jiemi();
		}
		else {
			cout<<"输入错误\n";
		}
	}
}

char caidan(){
	cout << "----------凯撒密码----------" << endl;
	cout << "|          1.加密          |\n";
	cout << "|          2.解密          |\n";
	cout << "|          0.退出          |\n";
	cout << "----------------------------\n";
	cout << "请输入：";
	char n;
	cin >> n;
	return n;
}
void jiami() {
	char mima_1[100];
	char mima_2[100];
	cout << "请输入明文";
	cin >> mima_1;
	jiami_1(mima_1,mima_2);
	cout << "所对应的暗文是:";
	for(int i=0;i<strlen(mima_1);i++)
		cout << mima_2[i];
	cout << endl;
}
void jiami_1(char mima_1[], char mima_2[]) {
	int n;
	cout << "请输入密钥";
	cin >> n;
	n = n % 26;
	int s;
	s = strlen(mima_1);
	for (int i = 0; i < s; i++) {
		if(mima_1[i]>='a'&& mima_1[i] <= 'z')
			mima_2[i] = (((mima_1[i] - 'a') + n) % 26) + 'a';
		else if (mima_1[i] >= 'A' && mima_1[i] <= 'Z')
			mima_2[i] = (((mima_1[i] - 'A') + n) % 26) + 'A';
		else {
			return;
		}
	}
}
void jiemi() {
	char mima_1[100];
	char mima_2[100];
	cout << "请输入暗文";
	cin >> mima_1;
	jiemi_1(mima_1, mima_2);
	for (int i = 0; i < strlen(mima_1); i++)
		cout << mima_2[i];
	cout << endl;
}
void jiemi_1(char mima_1[], char mima_2[]) {
	int n;
	cout << "请输入密钥";
	cin >> n;
	n = n % 26;
	int s;
	s = strlen(mima_1);
	for (int i = 0; i < s; i++) {
		if (mima_1[i] >= 'a' && mima_1[i] <= 'z')
			mima_2[i] = (((mima_1[i] - 'a') - n + 26) % 26) + 'a';
		else if (mima_1[i] >= 'A' && mima_1[i] <= 'Z')
			mima_2[i] = (((mima_1[i] - 'A') - n + 26) % 26) + 'A';
		else {
			return;
		}
	}
}

2.java实现

import java.util.Scanner;

public class Main {
    private static char caidan() {
        System.out.println("----------凯撒密码----------");
        System.out.println("|         1.加密          |");
        System.out.println("|         2.解密          |");
        System.out.println("|         0.退出          |");
        System.out.println("---------------------------");
        char n;
        System.out.print("请输入:");
        Scanner sc =new Scanner(System.in);
        n=sc.next().charAt(0);
        return n;
    }

    private static void jiami() {
        Scanner sc=new Scanner(System.in);
        String mima_1;
        String mima_2;
        System.out.print("请输入明文:");
        mima_1=sc.nextLine();
        mima_2=jiami_1(mima_1);
        System.out.print("所对应的暗文是:");
        System.out.println(mima_2);
    }
    private static String jiami_1(String mima_1) {
        String mima_2="";
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入密钥:");
        int n=sc.nextInt();
        n=n%26;
        for(int i=0;i<mima_1.length();i++){
            char a=mima_1.charAt(i);
            if(a>='a'&&a<='z'){
                int b;
                b=a-'a';
                b+=n;
                if(b>25){
                    b-=26;
                }
                mima_2+=(char)(b+'a');
            }
            else if(a>='A'&&a<='Z'){
                int b;
                b=a-'A';
                b+=n;
                if(b>25){
                    b-=26;
                }
                mima_2+=(char)(b+'A');
            }
            else {
                mima_2="错误";
                System.out.println(mima_2);
            }
        }
        return mima_2;
    }
    private static void jiemi() {
        Scanner sc=new Scanner(System.in);
        String mima_1;
        String mima_2;
        System.out.print("请输入暗文:");
        mima_1=sc.nextLine();
        mima_2=jiemi_1(mima_1);
        System.out.print("所对应的明文是:");
        System.out.println(mima_2);
    }

    private static String jiemi_1(String mima_1) {
        String mima_2="";
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入密钥:");
        int n=sc.nextInt();
        n=n%26;
        for(int i=0;i<mima_1.length();i++){
            char a=mima_1.charAt(i);
            if(a>='a'&&a<='z'){
                int b;
                b=a-'a';
                b-=n;
                if(b<0){
                    b+=26;
                }
                mima_2+=(char)(b+'a');
            }
            else if(a>='A'&&a<='Z'){
                int b;
                b=a-'A';
                b-=n;
                if(b<0){
                    b+=26;
                }
                mima_2+=(char)(b+'A');
            }
            else {
                mima_2="错误";
                System.out.println(mima_2);
            }
        }
        return mima_2;
    }

    public static void main(String[] args) {
        while (true){
            char n=caidan();
            if(n=='1'){
                jiami();
            }
            else if(n=='2'){
                jiemi();
            }
            else if(n=='0'){
                System.out.println("已退出");
                break;
            }
            else {
                System.out.println("输入错误");
            }
        }
    }
}

3.python实现

def caidan():
    print("----------凯撒密码----------")
    print("|          1.加密         |")
    print("|          2.解密         |")
    print("|          0.退出         |")
    print("---------------------------")
    a = input("请输入:")
    return a


def jiami():
    a = input("请输入明文:")
    b = jiami_1(a)
    print("所对应的暗文是:" + b)


def jiami_1(a):
    n = int(input("请输入密钥:"))
    n = n % 26
    b = ""
    for i in a:
        if i == ' ':
            i = ' '
        else:
            if 'a'<=i<='z':
                s = chr((ord(i) - ord('a') + n) % 26 + ord('a'))
                b += s
            if 'A'<=i<='Z':
                s = chr((ord(i) - ord('A') + n) % 26 + ord('A'))
                b += s
    return b


def jiemi():
    a = input("请输入明文:")
    b = jiemi_1(a)
    print("所对应的暗文是:" + b)


def jiemi_1(a):
    n = int(input("请输入密钥:"))
    n = n % 26
    b = ""
    for i in a:
        if i == ' ':
            i = ' '
        else:
            if 'a' <= i <= 'z':
                s = chr((ord(i) - ord('a') - n) % 26 + ord('a'))
                b += s
            if 'A' <= i <= 'Z':
                s = chr((ord(i) - ord('A') - n) % 26 + ord('A'))
                b += s
    return b


if __name__ == '__main__':
    while 1:
        n = caidan()
        if n == '1':
            jiami()
        elif n == '2':
            jiemi()
        elif n == '0':
            print("已退出")
            break
        else:
            print("输入错误")

4.算法分析

1.c++实现

1.加密

for (int i = 0; i < s; i++) {
		if(mima_1[i]>='a'&& mima_1[i] <= 'z')
			mima_2[i] = (((mima_1[i] - 'a') + n) % 26) + 'a';
		else if (mima_1[i] >= 'A' && mima_1[i] <= 'Z')
			mima_2[i] = (((mima_1[i] - 'A') + n) % 26) + 'A';
		else {
			return;
		}
	}

s为字符串的长度，然后字符减‘a’或‘A’，得到一个序号(0–25代表字母a–z)然后加上密钥再对26求余，可以得到一个新的序号。再加上‘a’或‘A’可以变成所对应字母的ascii。

2.解密

for (int i = 0; i < s; i++) {
		if (mima_1[i] >= 'a' && mima_1[i] <= 'z')
			mima_2[i] = (((mima_1[i] - 'a') - n + 26) % 26) + 'a';
		else if (mima_1[i] >= 'A' && mima_1[i] <= 'Z')
			mima_2[i] = (((mima_1[i] - 'A') - n + 26) % 26) + 'A';
		else {
			return;
		}
	}

s为字符串的长度，然后字符减‘a’或‘A’，得到一个序号(0–25代表字母a–z)然后减去密钥再对26求余，可以得到一个新的序号。再加上‘a’或‘A’可以变成所对应字母的ascii。

2.java实现

1.加密

for(int i=0;i<mima_1.length();i++){
            char a=mima_1.charAt(i);
            if(a>='a'&&a<='z'){
                int b;
                b=a-'a';
                b+=n;
                if(b>25){
                    b-=26;
                }
                mima_2+=(char)(b+'a');
            }
            else if(a>='A'&&a<='Z'){
                int b;
                b=a-'A';
                b+=n;
                if(b>25){
                    b-=26;
                }
                mima_2+=(char)(b+'A');
            }
            else {
                mima_2="错误";
                System.out.println(mima_2);
            }
        }

charAt(i)是 提取字符串中第i个字符，注意i是从0开始。
mima_1.length()是求字符串的长度。
字符减‘a’或‘A’，把字符型转换为整型，得到一个序号(0–25代表字母a–z)然后加上密钥，如果得到的数字大于25，则需要减去26，可以得到一个新的序号。再加上‘a’或‘A’可以变成所对应字母的ascii。然后进行数据的强制转换得到加密后的结果

2.解密

for(int i=0;i<mima_1.length();i++){
            char a=mima_1.charAt(i);
            if(a>='a'&&a<='z'){
                int b;
                b=a-'a';
                b-=n;
                if(b<0){
                    b+=26;
                }
                mima_2+=(char)(b+'a');
            }
            else if(a>='A'&&a<='Z'){
                int b;
                b=a-'A';
                b-=n;
                if(b<0){
                    b+=26;
                }
                mima_2+=(char)(b+'A');
            }
            else {
                mima_2="错误";
                System.out.println(mima_2);
            }
        }

charAt(i)是 提取字符串中第i个字符，注意i是从0开始。
mima_1.length()是求字符串的长度。
字符减‘a’或‘A’，把字符型转换为整型，得到一个序号(0–25代表字母a–z)然后减去密钥，如果得到的数字小于0，则需要加上26，可以得到一个新的序号。再加上‘a’或‘A’可以变成所对应字母的ascii。然后进行数据的强制转换得到加密后的结果

3.python实现

1.加密

for i in a:
        if i == ' ':
            i = ' '
        else:
            if 'a'<=i<='z':
                s = chr((ord(i) - ord('a') + n) % 26 + ord('a'))
                b += s
            if 'A'<=i<='Z':
                s = chr((ord(i) - ord('A') + n) % 26 + ord('A'))
                b += s

可以先利用ord（）将字符转换为数字，然后利用公式进行计算，最后通过chr（）将数字转换成字符。

2.解密

 for i in a:
        if i == ' ':
            i = ' '
        else:
            if 'a' <= i <= 'z':
                s = chr((ord(i) - ord('a') - n) % 26 + ord('a'))
                b += s
            if 'A' <= i <= 'Z':
                s = chr((ord(i) - ord('A') - n) % 26 + ord('A'))
                b += s

可以先利用ord（）将字符转换为数字，然后利用公式进行计算，最后通过chr（）将数字转换成字符。

3.chr()_and_ord()

1.chr()函数参数是0 - 256 的一个整数，
ord()函数参数是一个ascii字符；
2.chr()函数返回值是当前整数对应的ascii字符，
ord()函数返回对应字符的ascii码；
3.chr函数将ascll码转为字符，
ord函数将字符转为ascll码文章来源地址https://www.toymoban.com/news/detail-738946.html

到了这里，关于凯撒密码_c++_java_python（加密及解密）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【免费题库】华为OD机试 - 密码解密（Java & JS & Python & C & C++）

    哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持 给定一段“密文”字符串 s，其中字符都是经过“密码本”映射的，现需要将“密文”解密并输出。 映射的规则（‘a’ ~ ‘i’）分别用（‘1’ ~ ‘9’）表示；（‘j’ ~ ‘z’）分别

    2024年04月10日
    浏览(48)
  • Java小案例----数字密码的加密与解密

    Java小案例----数字密码的加密与解密

    在数据传输中，为了网络安全，数字的加密极为重要，以下将说明Java是如何将四位数字密码进行加密和解密的过程！ 本例题如下：   1.对数字的加密： 需要对数字加密，具体思路就是将数据先进行加五操作，然后进行对十取余，最后在进行逆置操作。首先就得输入数字，比

    2024年02月03日
    浏览(41)
  • C语言实现简单加密算法 凯撒密码 RSA算法 简介及实现

    C语言实现简单加密算法 凯撒密码 RSA算法 简介及实现

    凯撒密码的核心思想就是移位。 将明文的每一个字符 在 密码系统所支持字符序列中向右平移N，映射得到新的字符从而实现加密，而解密则相反向左平移N。加密的Key即为N。 加密  解密 在如今的万维网环境中，如果A要向B发送数据，需要先加密这个数据，因为在一些不安全

    2024年02月08日
    浏览(53)

  • Python：实现密码加密解密（含完整源码）

    Python：实现密码加密解密（含完整源码） 密码加密是保护用户隐私的一种有效手段。本文将讲解如何使用Python编写一个简单的密码加密解密程序，并提供完整源代码。 步骤一：安装依赖库 我们需要使用到pycrypto库来实现密码加密解密的功能。安装pycrypto库，可以通过pip命令进

    2024年02月14日
    浏览(41)

  • c++ 凯撒密码

            凯撒密码（Caesar Cipher）是一种简单的替代加密技术，以罗马大帝凯撒·尤利乌斯·凯撒（Julius Caesar）的名字命名。它通过将每个字母按照字母表向后移动固定数量的位置来进行加密。 示例一： /**  * @file caesar_cipher.cpp  * @brief Implementation of [Caesar cipher](https://en.wi

    2024年02月02日
    浏览(51)

  • 【华为OD机考 统一考试机试C卷】密码解密（C++ Java JavaScript Python C语言）

    目前在考C卷，经过两个月的收集整理， C卷真题已基本整理完毕 抽到原题的概率为2/3到3/3， 也就是最少抽到两道原题。 请注意：大家刷完C卷真题，最好要把B卷的真题刷一下，因为C卷的部分真题来自B卷。 另外订阅专栏还可以联系笔者开通在线OJ进行刷题，提高刷题效率。

    2024年04月12日
    浏览(37)
  • Java使用MD5加盐对密码进行加密处理,附注册和登录加密解密处理

    Java使用MD5加盐对密码进行加密处理,附注册和登录加密解密处理

    在开发的时候，有一些敏感信息是不能直接通过明白直接保存到数据库的。最经典的就是密码了。如果直接把密码以明文的形式入库，不仅会泄露用户的隐私，对系统也是极其的不厉，这样做是非常危险的。 那么我们就需要对这些铭文进行加密。 现在市场是加密的方式已经

    2024年02月02日
    浏览(42)
  • 凯撒密码-java

    凯撒密码-java

    在 密码学 中， 恺撒密码 （英语：Caesar cipher），或称 恺撒加密 、 恺撒变换 、 变换加密 ，是一种最简单且最广为人知的加密技术。它是一种替换加密的技术， 明文 中的所有字母都在 字母表 上向后（或向前）按照一个固定数目进行偏移后被替换成 密文 。例如，当偏移量

    2024年02月07日
    浏览(38)

  • 凯撒密码(Python)

    一、凯撒密码是什么? 凯撒密码是一种非常古老的加密方法，最初由古罗马的凯撒大帝使用。凯撒大帝将纸条卷起后，按照字母表顺序向后移动一定的位数，然后再写下加密后的字母，这样其他人就无法直接读取他的信息。 凯撒密码（移位密码）：是一种替换加密，明文中的

    2024年02月05日
    浏览(44)
  • Java代码实现RSA算法加密解密文件功能

    Java代码实现RSA算法加密解密文件功能

    底层算法不做赘述，想要了解自行百度。 RSA属于非对称加密，非对称加密有公钥和私钥两个概念，私钥自己拥有，不能给别人，公钥公开。根据应用的不同，我们可以选择使用不同的密钥加密： 签名：使用私钥加密，公钥解密。用于让所有公钥所有者验证私钥所有者的身份

    2024年02月12日
    浏览(56)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包