# -*- 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 = "/B2E" # 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", "B"] # if len(QR_txt) == 2: # # 调用函数处理示例列表 # print(extract_differences(QR_txt)) # else: # print("错误：列表中必须包含两个二维码字符串。") # # QR_txt = ["A", "A"] red = "5%Ar" 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%Ar2#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%Ar2#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*#>" 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" str2 = "B" # 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%@#' 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