当前位置：首页 > article >正文

【华为OD-E卷 - 字符串加密 100分（python、java、c++、js、c）】

article 2025/1/19 20:33:53

【华为OD-E卷 - 字符串加密 100分（python、java、c++、js、c）】

题目

给你一串未加密的字符串str，通过对字符串的每一个字母进行改变来实现加密，加密方式是在每一个字母str[i]偏移特定数组元素a[i]的量，数组a前三位已经赋值：a[0]=1,a[1]=2,a[2]=4。
当i>=3时，数组元素a[i]=a[i-1]+a[i-2]+a[i-3]。
例如：原文 abcde 加密后 bdgkr，其中偏移量分别是1,2,4,7,13

输入描述

第一行为一个整数n（1<=n<=1000），表示有n组测试数据，每组数据包含一行，原文str（只含有小写字母，0<长度<=50）

输出描述

每组测试数据输出一行，表示字符串的密文

用例

用例一：

输入：

1
xy

输出：

ya

python解法

解题思路：
这段代码实现了一种加密算法。通过以下步骤完成：

生成位移序列：
使用 generate_shift 函数递归生成一个位移值序列。前 3 个位移值是固定的 [1, 2, 4]，之后的位移值是基于前三个值的和计算的，并对 26 取模，形成循环。
使用 memo 记忆化存储已计算的位移值，避免重复计算。
加密文本：
对输入文本的每个字符，根据其在字符串中的索引生成对应的位移值。
字符的 ASCII 值经过位移处理后重新转换为字符，实现加密操作。
多文本处理：
对多个输入文本分别执行加密操作，输出结果。

def generate_shift(index, memo):
    # 生成位移值的递归函数
    # 前三个值固定为 [1, 2, 4]
    if index < 3:
        return [1, 2, 4][index]
    # 如果位移值已经计算过，从 memo 中读取
    if index not in memo:
        # 使用递归计算当前位移值并存入 memo 中
        # 当前位移值等于前三个值之和模 26
        memo[index] = (generate_shift(index - 1, memo) + generate_shift(index - 2, memo) + generate_shift(index - 3, memo)) % 26
    return memo[index]

def encrypt_text(s, memo):
    # 加密单个文本字符串
    result = []
    for i, char in enumerate(s):
        # 根据字符位置 i 生成对应的位移值
        shift = generate_shift(i, memo)
        # 计算加密后的字符
        # 字符转为 ASCII 值，进行位移操作后重新转为字符
        result.append(chr((ord(char) - 97 + shift) % 26 + 97))
    # 将加密后的字符列表合并为字符串
    return "".join(result)

# 输入文本数量
n = int(input())
# 读取 n 个文本输入
texts = [input() for _ in range(n)]
# 初始化 memo 字典，存储位移值
memo = {}

# 对每个输入文本加密并输出结果
for text in texts:
    print(encrypt_text(text, memo))

java解法

解题思路

更新中

C++解法

解题思路
这段代码实现了一个简单的加密算法。主要流程如下：

生成位移值：
使用 generate_shift 函数生成一个基于前3个固定值和递归公式计算的位移值序列。
使用 unordered_map 进行记忆化，避免重复计算。
加密文本：
遍历输入字符串的每个字符，根据字符的索引生成对应的位移值。
使用位移值对字符进行偏移，并保持加密后的字符在 ‘a’ 到 ‘z’ 的范围内。
多文本处理：
接收多行输入文本，逐行进行加密并输出结果

#include <iostream>
#include <vector>
#include <unordered_map>
#include <string>

using namespace std;

// 递归生成位移值
int generate_shift(int index, unordered_map<int, int>& memo) {
    // 前三个固定位移值为 [1, 2, 4]
    if (index < 3) {
        return vector<int>{1, 2, 4}[index];
    }
    // 如果位移值尚未计算，进行递归计算并存储到 memo
    if (memo.find(index) == memo.end()) {
        // 当前位移值为前三个位移值之和模 26
        memo[index] = (generate_shift(index - 1, memo) + generate_shift(index - 2, memo) + generate_shift(index - 3, memo)) % 26;
    }
    return memo[index];
}

// 对单个字符串进行加密
string encrypt_text(const string& s, unordered_map<int, int>& memo) {
    string result; // 存储加密后的字符串
    for (int i = 0; i < s.size(); ++i) {
        // 根据字符索引 i 生成位移值
        int shift = generate_shift(i, memo);
        // 对字符进行加密操作并保持在 'a'-'z' 范围内
        result += char((s[i] - 'a' + shift) % 26 + 'a');
    }
    return result;
}

int main() {
    int n; // 输入文本的数量
    cin >> n; // 读取文本数量
    cin.ignore(); // 忽略换行符以便读取多行输入

    vector<string> texts(n); // 存储输入的文本
    for (int i = 0; i < n; ++i) {
        getline(cin, texts[i]); // 逐行读取文本
    }

    unordered_map<int, int> memo; // 用于存储位移值的记忆化表
    for (const string& text : texts) {
        // 对每个文本加密并输出结果
        cout << encrypt_text(text, memo) << endl;
    }

    return 0;
}