681 lines
21 KiB
Python
681 lines
21 KiB
Python
# -*- coding:utf-8 -*-
|
||
# @Author len
|
||
# @Create 2023/12/20 14:15
|
||
|
||
|
||
|
||
# 从一个字符串中移除所有的中文字符，并返回一个新的不包含中文字符的字符串
|
||
def remove_chinese_chars(self, text):
|
||
"""移除字符串中的中文字符，并返回新的字符串"""
|
||
# 定义中文字符的Unicode范围
|
||
chinese_char_ranges = [
|
||
('\u4e00', '\u9fff'), # 基本汉字
|
||
('\u3400', '\u4dbf'), # 扩展A
|
||
('\u20000', '\u2a6df'), # 扩展B
|
||
# 可以根据需要添加更多的中文范围
|
||
]
|
||
# 移除中文字符
|
||
return ''.join(char for char in text if not any(start <= char <= end for start, end in chinese_char_ranges))
|
||
|
||
# 检查一个给定的字符串 text 是否是一个有效的公式
|
||
def if_formula(self, text):
|
||
# 允许的字符：数字、运算符和括号
|
||
allowed_chars = "0123456789+-*/%^().abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||
|
||
# 检查字符是否合法
|
||
for char in text:
|
||
if char not in allowed_chars:
|
||
return False
|
||
|
||
# 括号匹配检查
|
||
bracket_count = 0
|
||
for char in text:
|
||
if char == '(':
|
||
bracket_count += 1
|
||
elif char == ')':
|
||
bracket_count -= 1
|
||
if bracket_count < 0: # 右括号多于左括号
|
||
return False
|
||
if bracket_count != 0: # 左括号和右括号数量不匹配
|
||
return False
|
||
|
||
return True
|
||
|
||
# 提取中文字符和字母数字字符
|
||
def extract_chinese_and_alphanumeric_without_regex(text):
|
||
chinese_str = ''
|
||
alphanumeric_str = ''
|
||
|
||
for char in text:
|
||
# 检查是否是中文字符
|
||
if '\u4e00' <= char <= '\u9fff':
|
||
chinese_str += char
|
||
# 检查是否是字母或数字
|
||
elif char.isalnum():
|
||
alphanumeric_str += char
|
||
|
||
return chinese_str, alphanumeric_str
|
||
|
||
# 提取字符和数字
|
||
def extract_numbers_and_letters_combined(text):
|
||
combined_str = ''
|
||
for char in text:
|
||
# 检查字符是否是数字（0-9）或字母（A-Z 或 a-z）
|
||
if ('0' <= char <= '9') or ('A' <= char <= 'Z') or ('a' <= char <= 'z'):
|
||
combined_str += char
|
||
return combined_str
|
||
# print(extract_numbers_and_letters_combined("A/145#B6"))
|
||
|
||
|
||
# 提取数字字符
|
||
def extract_numbers_without_isdigit(text):
|
||
numbers_str = ''
|
||
for char in text:
|
||
# 检查字符是否是数字（0-9）
|
||
if '0' <= char <= '9':
|
||
numbers_str += char
|
||
return numbers_str
|
||
# 提取字母字符
|
||
def extract_letters_without_isalpha(text):
|
||
letters_str = ''
|
||
for char in text:
|
||
# 检查字符是否是字母（A-Z 或 a-z）
|
||
if ('A' <= char <= 'Z') or ('a' <= char <= 'z'):
|
||
letters_str += char
|
||
return letters_str
|
||
|
||
|
||
# 对字符串数字进行排序
|
||
def sort_numbers_without_function(text):
|
||
# 将字符串转换为数字列表
|
||
numbers_list = [int(char) for char in text]
|
||
# 使用简单的排序算法（如冒泡排序）对列表排序
|
||
for i in range(len(numbers_list)):
|
||
for j in range(0, len(numbers_list)-i-1):
|
||
if numbers_list[j] > numbers_list[j+1]:
|
||
numbers_list[j], numbers_list[j+1] = numbers_list[j+1], numbers_list[j]
|
||
# 将排序后的数字列表转换回字符串
|
||
sorted_str = ''.join(str(num) for num in numbers_list)
|
||
return sorted_str
|
||
|
||
# 对字符串字符进行排序
|
||
def sort_letters_without_function(text):
|
||
# 将字符串转换为字符列表
|
||
letters_list = [char for char in text]
|
||
|
||
# 使用简单的排序算法（如冒泡排序）对列表排序
|
||
for i in range(len(letters_list)):
|
||
for j in range(0, len(letters_list)-i-1):
|
||
if letters_list[j] > letters_list[j+1]:
|
||
letters_list[j], letters_list[j+1] = letters_list[j+1], letters_list[j]
|
||
|
||
# 将排序后的字符列表转换回字符串
|
||
sorted_str = ''.join(letters_list)
|
||
return sorted_str
|
||
|
||
|
||
def shandong(text):
|
||
str_result = ""
|
||
number_result = ""
|
||
for t in text:
|
||
if 'A'<= t <= 'G':
|
||
str_result += t
|
||
elif '0' <= t <= '7':
|
||
number_result += t
|
||
return str_result + number_result
|
||
|
||
|
||
def compress_string(input_string):
|
||
# 检查输入字符串是否为空
|
||
if not input_string:
|
||
return ""
|
||
|
||
# 初始化压缩后的字符串、当前字符和其出现次数
|
||
compressed_string = ""
|
||
current_char = input_string[0]
|
||
count = 1
|
||
|
||
# 遍历字符串，从第二个字符开始
|
||
for char in input_string[1:]:
|
||
if char == current_char:
|
||
# 如果当前字符与前一个字符相同，增加计数
|
||
count += 1
|
||
else:
|
||
# 如果当前字符与前一个字符不同，根据计数添加字符
|
||
if count > 1:
|
||
compressed_string += str(count) + current_char
|
||
else:
|
||
compressed_string += current_char
|
||
current_char = char
|
||
count = 1
|
||
|
||
# 添加最后一个字符（或字符组）
|
||
if count > 1:
|
||
compressed_string += str(count) + current_char
|
||
else:
|
||
compressed_string += current_char
|
||
|
||
return compressed_string
|
||
#
|
||
# # 测试函数
|
||
# input_string = "1EE55FFFCC333"
|
||
# compressed_string = compress_string(input_string)
|
||
# print(compressed_string)
|
||
|
||
|
||
# 统计连续字符出现的次数
|
||
# test_string = "1EE55FFFCC333"
|
||
# result = 11E252F3C233
|
||
def encode_string(s):
|
||
# 初始化结果字符串和当前字符计数器
|
||
result = ""
|
||
count = 1
|
||
|
||
# 如果字符串为空，直接返回空结果
|
||
if not s:
|
||
return result
|
||
|
||
# 遍历字符串中的每个字符
|
||
for i in range(1, len(s)):
|
||
# 如果当前字符与前一个字符相同，增加计数
|
||
if s[i] == s[i - 1]:
|
||
count += 1
|
||
else:
|
||
# 如果当前字符与前一个字符不同，将前一个字符和计数添加到结果字符串
|
||
result += s[i - 1] + str(count)
|
||
count = 1 # 重置计数器
|
||
|
||
# 添加最后一个字符和其计数
|
||
result += s[-1] + str(count)
|
||
|
||
return result
|
||
|
||
# # 测试函数
|
||
# test_string = "1EE55FFFCC333"
|
||
# encoded_string = encode_string(test_string)
|
||
# print(encoded_string)
|
||
|
||
# test_string = "1E8E55F6FF7C86C3933"
|
||
# result = 11E181E152F161F271C18161C1319132
|
||
# 统计每个字符出现的次数
|
||
def encode_string2(test_string):
|
||
# 统计每个字符的出现次数
|
||
char_counts = {}
|
||
for char in test_string:
|
||
if char in char_counts:
|
||
char_counts[char] += 1
|
||
else:
|
||
char_counts[char] = 1
|
||
|
||
# 将统计结果格式化为字符串
|
||
encoded_string = ''.join(f"{char}{count}" for char, count in char_counts.items())
|
||
|
||
return encoded_string
|
||
|
||
# 测试函数
|
||
# test_string = "1E8E55F6FF7C86C3933"
|
||
# encoded_string = encode_string(test_string)
|
||
# print(encoded_string)
|
||
|
||
def encode_string(test_string):
|
||
char_counts = {} # 字符计数的字典
|
||
order = [] # 记录字符出现的顺序
|
||
|
||
# 统计每个字符的出现次数，并记录顺序
|
||
for char in test_string:
|
||
if char in char_counts:
|
||
char_counts[char] += 1
|
||
else:
|
||
char_counts[char] = 1
|
||
order.append(char) # 记录新字符的顺序
|
||
|
||
# 构建编码后的字符串
|
||
encoded_string = ''.join([char + str(char_counts[char]) for char in order])
|
||
return encoded_string
|
||
|
||
# # 测试字符串
|
||
# test_string = "1E686E8585F6FFCC333"
|
||
# encoded_string = encode_string(test_string)
|
||
# print("Encoded string:", encoded_string)
|
||
|
||
|
||
# txt = "7%%￥&D**"
|
||
# print(shandong(txt))
|
||
#
|
||
# def remove_non_ascii_chars(text):
|
||
# """移除字符串中的非ASCII字符，并返回新的字符串"""
|
||
# # 只保留ASCII字符
|
||
# return ''.join(char for char in text if ord(char) < 128)
|
||
|
||
|
||
# 移除ASCII码值的字符
|
||
|
||
# # 使用该函数提取中文字符和字母数字字符
|
||
# test_str = "0 人 E12*34A 才强 B5678%国 CD&9”"
|
||
# chinese, alphanumeric = extract_chinese_and_alphanumeric_without_regex(test_str)
|
||
# print(chinese, alphanumeric)
|
||
# print(extract_numbers_without_isdigit(alphanumeric))
|
||
|
||
|
||
|
||
|
||
|
||
# txxt = "101110+0100-011"
|
||
# print(binary_to_hexadecimal("0101001"))
|
||
|
||
|
||
|
||
# 简单的字符串处理函数来解析JSON格式的数据
|
||
|
||
def parse_simple_json(data_str):
|
||
data_str = data_str.strip()[1:-1] # 去除首尾的大括号
|
||
parsed_data = {}
|
||
nested_obj = False
|
||
key = ''
|
||
value = ''
|
||
for char in data_str:
|
||
if char == '{': # 嵌套对象开始
|
||
nested_obj = True
|
||
value += char
|
||
elif char == '}': # 嵌套对象结束
|
||
nested_obj = False
|
||
value += char
|
||
elif char == ':' and not nested_obj: # 键值分隔
|
||
key = value.strip().strip('"')
|
||
value = ''
|
||
elif char == ',' and not nested_obj: # 键值对分隔
|
||
parsed_data[key] = value.strip().strip('"')
|
||
key = ''
|
||
value = ''
|
||
elif char in [" ", '\n', "'", '"']:
|
||
continue
|
||
else:
|
||
value += char
|
||
if key: # 添加最后一个键值对
|
||
parsed_data[key] = value.strip().strip('"')
|
||
return parsed_data
|
||
|
||
# 解析函数只适用于非常简单的JSON结构
|
||
# 它不会处理嵌套对象、数组、布尔值或null值
|
||
# data = '''{
|
||
# "code": "2023",
|
||
# "algorithm": "0123456789ABCDE ",
|
||
# "result": {
|
||
# "purpose": "赛课融通，综合育人"
|
||
# },
|
||
# "number": 1
|
||
# }'''
|
||
#
|
||
# # 使用字符串处理来解析JSON格式的数据
|
||
# parsed_data_str = parse_simple_json(data)
|
||
#
|
||
# # 显示解析后的数据
|
||
# print(parsed_data_str)
|
||
|
||
|
||
# 提取字符和数字
|
||
def lingxuansai(text):
|
||
result = ""
|
||
str_text = ''
|
||
for char in text:
|
||
# 检查字符是否是数字（0-9）或字母（A-Z 或 a-z）
|
||
if ('0' <= char <= '9') or ('A' <= char <= 'F'):
|
||
str_text += char
|
||
|
||
dict_result = {}
|
||
for c in str_text:
|
||
dict_result[c] = dict_result.get(c, 0) + 1
|
||
# print(dict_result)
|
||
list_result = dict_result.items()
|
||
list_result = (sorted(list_result, key=lambda x: x[0], reverse=False))
|
||
# print(list_result)
|
||
list_result = (sorted(list_result, key=lambda x: x[1], reverse=True))
|
||
# print(list_result)
|
||
char_flag = 0
|
||
number_flag = 0
|
||
|
||
for i in range(len(list_result)):
|
||
if 'A' <= list_result[i][0] <= 'Z' and char_flag == 0:
|
||
char_flag = 1
|
||
# text.find(list_result[i][0])
|
||
# result += f"{list_result[i][0]}{str_text.find(list_result[i][0]) + 1}"
|
||
result += list_result[i][0] + chr(str_text.find(list_result[i][0]) + 1 + 48)
|
||
|
||
for i in range(len(list_result)):
|
||
if '0' <= list_result[i][0] <= '9' and number_flag == 0:
|
||
number_flag = 1
|
||
# result += f"{list_result[i][0]}{str_text.find(list_result[i][0]) + 1}"
|
||
result += list_result[i][0] + chr(str_text.find(list_result[i][0]) + 1 + 48)
|
||
|
||
return result
|
||
|
||
# str = "/B2<AC3A%B2AA>E"
|
||
# print(str)
|
||
# str = lingxuansai(str)
|
||
# print(str)
|
||
|
||
|
||
def extract_differences(text_list):
|
||
"""
|
||
该函数接收一个包含两个二维码字符串的列表，提取尖括号内的有效信息，
|
||
并根据给定规则返回两个二维码之间的差异数据。
|
||
"""
|
||
extracted_data = [] # 初始化一个列表来存储提取的数据
|
||
for text in text_list:
|
||
bracket_content = [] # 用于临时存储尖括号内的数据
|
||
inside_bracket = False # 用于标记是否处于尖括号内部
|
||
for char in text:
|
||
if char == '<': # 如果遇到左尖括号，则开始记录数据
|
||
inside_bracket = True
|
||
elif char == '>': # 如果遇到右尖括号，则结束记录数据
|
||
if inside_bracket:
|
||
# 如果确实记录了数据，结束记录，并将其添加到结果列表中
|
||
extracted_data.append(''.join(bracket_content))
|
||
bracket_content = [] # 重置临时存储
|
||
inside_bracket = False # 重置标记
|
||
elif inside_bracket:
|
||
# 如果处于尖括号内部，则将字符添加到临时存储中
|
||
bracket_content.append(char)
|
||
|
||
# # 检查提取的数据是否确切地为15个字节长
|
||
# if not all(len(data) == 15 for data in qr_data):
|
||
# return "错误：尖括号内的数据不是15个字节长。"
|
||
|
||
# 对比数据并找出差异
|
||
differences = [[], []] # differences[0] 用于存储 QR1 != QR2 的差异，反之亦然
|
||
for a, b in zip(extracted_data[0], extracted_data[1]):
|
||
if a != b:
|
||
differences[0].append(a)
|
||
differences[1].append(b)
|
||
|
||
# 按要求返回合并后的差异数据
|
||
char_list = differences[0] + differences[1]
|
||
return ''.join(char_list)
|
||
|
||
|
||
# # 示例二维码文本列表
|
||
# QR_txt = ["A<A1B2C3D4E5F6>", "B<A1B2D1D4E5F7>"]
|
||
# if len(QR_txt) == 2:
|
||
# # 调用函数处理示例列表
|
||
# print(extract_differences(QR_txt))
|
||
# else:
|
||
# print("错误：列表中必须包含两个二维码字符串。")
|
||
# # QR_txt = ["A<A1B2C3D4E5F6>", "A<A1B2C3D4E5F6>"]
|
||
|
||
|
||
red = "5%Ar<b3!#<28,27,153>"
|
||
green = "2#A2%3b5|<5,6,153>"
|
||
|
||
# 判断水仙花数
|
||
def is_narcissistic_number(num):
|
||
num_str = str(num)
|
||
num_length = len(num_str)
|
||
sum_of_powers = sum(int(digit) ** num_length for digit in num_str)
|
||
return sum_of_powers == num
|
||
test_numbers = [153, 370, 371, 407, 1634, 8208, 9474, 9475]
|
||
results = {number: is_narcissistic_number(number) for number in test_numbers}
|
||
# print(is_narcissistic_number(370))
|
||
print(results)
|
||
|
||
|
||
def extract_parts_manual(input_str):
|
||
"""
|
||
手动解析字符串，提取尖括号前、内、后的内容。
|
||
|
||
参数:
|
||
input_str (str): 需要解析的字符串，形式可能包含尖括号括起来的部分。
|
||
|
||
返回:
|
||
tuple: 包含三个元素的元组：
|
||
- 第一个元素为尖括号前的内容 (str)，
|
||
- 第二个元素为尖括号内的内容 (str)，只处理第一个尖括号对，
|
||
- 第三个元素为尖括号后的内容 (str)。
|
||
如果没有找到尖括号，则尖括号内的内容为空字符串。
|
||
|
||
示例:
|
||
input_str = "5%Ar<b3!#<28,27,153>2#A2%3b5"
|
||
输出: ('5%Ar', 'b3!#', '2#A2%3b5')
|
||
"""
|
||
# 初始化变量
|
||
start_index = -1 # 最外层左尖括号的索引
|
||
bracket_count = 0 # 左尖括号计数
|
||
before_bracket = "" # 尖括号前的内容
|
||
inside_bracket = "" # 尖括号内的内容
|
||
after_bracket = "" # 尖括号后的内容
|
||
|
||
# 遍历字符串，查找最外层的尖括号
|
||
for i, char in enumerate(input_str):
|
||
if char == '<':
|
||
# 如果是第一个左尖括号，记录索引
|
||
if bracket_count == 0:
|
||
start_index = i
|
||
# 左尖括号计数加一
|
||
bracket_count += 1
|
||
elif char == '>':
|
||
# 右尖括号计数减一
|
||
bracket_count -= 1
|
||
# 如果所有左尖括号都找到了匹配的右尖括号
|
||
if bracket_count == 0:
|
||
before_bracket = input_str[:start_index] # 尖括号前的内容
|
||
inside_bracket = input_str[start_index + 1:i] # 尖括号内的内容
|
||
after_bracket = input_str[i + 1:] # 尖括号后的内容
|
||
break # 已找到最外层尖括号，退出循环
|
||
|
||
return before_bracket, inside_bracket, after_bracket
|
||
|
||
|
||
# # 示例字符串
|
||
# input_string = "5%Ar<b3!#<28,27,153>2#A2%3b5"
|
||
# result = extract_parts_manual(input_string)
|
||
# print(result)
|
||
|
||
|
||
def extract_innermost_bracket_content(input_string):
|
||
"""
|
||
提取给定字符串中最内层尖括号<>内的内容。
|
||
|
||
参数:
|
||
input_string (str): 输入的字符串。
|
||
|
||
返回:
|
||
str: 最内层尖括号内的内容，如果没有匹配则返回空字符串。
|
||
"""
|
||
depth = 0 # 嵌套深度计数器
|
||
max_depth = 0 # 最大深度
|
||
content_at_depth = {} # 存储每个深度的内容
|
||
for char in input_string:
|
||
if char == '<':
|
||
depth += 1
|
||
max_depth = max(max_depth, depth) # 更新最大深度
|
||
content_at_depth[depth] = "" # 为新的深度初始化内容
|
||
elif char == '>':
|
||
if depth > 0: # 只有在有效的深度下才减少深度
|
||
depth -= 1
|
||
elif depth > 0: # 只有在尖括号内部时才添加内容
|
||
content_at_depth[depth] += char
|
||
|
||
# 从记录的最大深度获取内容
|
||
return content_at_depth.get(max_depth, "")
|
||
|
||
|
||
# 示例使用
|
||
example_string = "这是一个示例: 1<9p*<C%15&9NY*>#>"
|
||
extracted_content = extract_innermost_bracket_content(example_string)
|
||
print("提取的内容:", extracted_content)
|
||
|
||
# 最大字串子串
|
||
def find_longest_common_substring(s1, s2):
|
||
# 初始化动态规划表
|
||
m, n = len(s1), len(s2)
|
||
dp = [[0] * (n + 1) for _ in range(m + 1)]
|
||
longest, x_longest = 0, 0
|
||
for i in range(1, m + 1):
|
||
for j in range(1, n + 1):
|
||
if s1[i - 1] == s2[j - 1]:
|
||
dp[i][j] = dp[i - 1][j - 1] + 1
|
||
if dp[i][j] > longest:
|
||
longest = dp[i][j]
|
||
x_longest = i
|
||
else:
|
||
dp[i][j] = 0
|
||
# 返回最长公共子字符串
|
||
return s1[x_longest - longest: x_longest]
|
||
# 示例数据
|
||
# qr_code_a = "ACDXYDOPQCDB"
|
||
# qr_code_b = "RXYDOPCBKNQS"
|
||
qr_code_a = "ACDXYDOPQCDB"
|
||
qr_code_b = "RXYDOPCBKNQS"
|
||
|
||
longest_substring = find_longest_common_substring(qr_code_a, qr_code_b) #
|
||
print("最大子串", longest_substring)
|
||
# 移除最大子字符串
|
||
remaining_a = qr_code_a.replace(longest_substring, "", 1)
|
||
remaining_b = qr_code_b.replace(longest_substring, "", 1)
|
||
print("移除最大子串后", remaining_a, remaining_b)
|
||
# 拼接并排序
|
||
combined = remaining_a + remaining_b
|
||
sorted_combined = ''.join(sorted(combined))
|
||
print("拼接并排序后", sorted_combined)
|
||
# 计算前6个字符的ASCII码
|
||
ascii_codes = [hex(ord(c)) for c in sorted_combined[:6]]
|
||
print(ascii_codes)
|
||
|
||
|
||
# 尖括号外的数据
|
||
def get_test_outside_brackets(qrstring):
|
||
# 提取尖括号外的内容
|
||
start_index = qrstring.find('<')
|
||
end_index = qrstring.find('>')
|
||
# 如果尖括号存在，切割尖括号外的内容
|
||
if start_index != -1 and end_index != -1:
|
||
return qrstring[:start_index] + qrstring[end_index + 1:]
|
||
else:
|
||
# 如果尖括号不存在，返回原字符串
|
||
return qrstring
|
||
|
||
# 尖括号内的数据
|
||
def get_test_inside_brackets(qrstring):
|
||
# 提取尖括号内的内容
|
||
start_index = qrstring.find('<')
|
||
end_index = qrstring.find('>')
|
||
# 如果尖括号存在，切割尖括号内的内容
|
||
if start_index != -1 and end_index != -1:
|
||
return qrstring[start_index + 1:end_index]
|
||
else:
|
||
# 如果尖括号不存在，返回空字符串
|
||
return ""
|
||
|
||
# 比较两个字符串的内容，存第一个二维码的不同
|
||
def compare_strings(str1, str2):
|
||
result1 = ""
|
||
result2 = ""
|
||
for i in range(len(str1)):
|
||
if str1[i] != str2[i]:
|
||
result1 += str1[i]
|
||
result2 += str2[i]
|
||
return result1 + result2
|
||
|
||
def qr_240606(str1, str2):
|
||
result = ""
|
||
ch1 = get_test_outside_brackets(str1)
|
||
ch2 = get_test_outside_brackets(str2)
|
||
|
||
str1 = get_test_inside_brackets(str1)
|
||
str2 = get_test_inside_brackets(str2)
|
||
# print(str1, str2)
|
||
if ch1 == 'A':
|
||
result = compare_strings(str1, str2)
|
||
elif ch2 == 'A':
|
||
result = compare_strings(str2, str1)
|
||
|
||
return result
|
||
|
||
str1 = "A<A1B2C3D4E5F6>"
|
||
str2 = "B<A1B2D1D4E5F7>"
|
||
|
||
# result = qr_240606(str1, str2)
|
||
#
|
||
# print(result)
|
||
|
||
def qr_240606_2(red, green):
|
||
result_1 = ""
|
||
result_2 = ""
|
||
nei1 = extract_innermost_bracket_content(red)
|
||
nei2 = extract_innermost_bracket_content(green)
|
||
|
||
one = red.replace(nei1, '')
|
||
two = green.replace(nei2, '')
|
||
|
||
nei1 = extract_numbers_without_isdigit(nei1)
|
||
nei2 = extract_numbers_without_isdigit(nei2)
|
||
|
||
# print(one, two)
|
||
one_number = extract_numbers_without_isdigit(one)
|
||
two_number = extract_numbers_without_isdigit(two)
|
||
one_str = extract_letters_without_isalpha(one)
|
||
two_str = extract_letters_without_isalpha(two)
|
||
|
||
# print(one_number, one_str)
|
||
# print(two_number, two_str)
|
||
|
||
if len(one_number) == 2 and len(two_str) == 2:
|
||
result_1 = one_number + nei1
|
||
result_2 = two_str + nei2
|
||
elif len(one_str) == 2 and len(two_number) == 2:
|
||
result_1 = two_number + nei2
|
||
result_2 = one_number + nei1
|
||
|
||
|
||
return result_1+result_2
|
||
|
||
red = '5%@#<b3!#<1,3>'
|
||
green = '2#A2%3b5|<2,4>'
|
||
|
||
print(qr_240606_2(red, green))
|
||
|
||
|
||
def process_qrcode(input_str):
|
||
# 提取'0'和'1'构成序列XL
|
||
XL = ''.join([char for char in input_str if char in '01'])
|
||
|
||
# 找到首个特殊字符
|
||
first_special_char = None
|
||
for char in input_str:
|
||
if char in '+-':
|
||
first_special_char = char
|
||
break
|
||
|
||
# 依据首个特殊字符进行位移操作
|
||
if first_special_char == '+':
|
||
# 循环左移2位
|
||
XL = XL[2:] + XL[:2]
|
||
elif first_special_char == '-':
|
||
# 循环右移3位
|
||
XL = XL[-3:] + XL[:-3]
|
||
|
||
# 将结果分成高8位和低8位
|
||
if len(XL) < 16:
|
||
XL = '0' * (16 - len(XL)) + XL
|
||
print(XL)
|
||
# 将高8位和低8位分别转换为十进制
|
||
DH_bin = XL[:8]
|
||
DL_bin = XL[8:]
|
||
|
||
DH = int(DH_bin, 2)
|
||
DL = int(DL_bin, 2)
|
||
print(DH, DL)
|
||
# # 转换为十六进制格式
|
||
# DH_hex = f"0x{DH:02X}"
|
||
# DL_hex = f"0x{DL:02X}"
|
||
#
|
||
# return DH_hex, DL_hex
|
||
return DH, DL
|
||
|
||
|
||
# 示例调用
|
||
input_str = "101110+01001-011"
|
||
DH, DL = process_qrcode(input_str)
|
||
result = str(DH) + str(DL)
|
||
print(result) # 输出: 0x39, 0x2E
|
||
print(f"DH: {DH}, DL: {DL}") # 输出: DH: 0x39, DL: 0x2E
|