霓虹-值得研究

问题描述

晚上，小蓝正无聊的走在大路上，小蓝所在的街区是一个带有赛博朋克风格的街区。

他抬头一看，看到了很多霓虹灯牌。在其中的某一个店铺前，挂着一排的数字灯牌，每一个数字的显示都依靠 7 段 LED 管，亮着的灯管组成数字，具体来说如下图所示：

小蓝刚学过数字电路，他知道具体的工作原理如下：

在思考的过程中，他发现数字发生了变化。他想要知道，在数字变化的过程中，总共有多少根灯管的状态产生了变化？

例如，从显示数字 0 到显示数字 6，会有一个灯管熄灭，一个灯管点亮，那么总共有两根灯管发生了变化。

具体来说，当前的数字串是 A，一秒钟之后，数字串变成了 BBB，小蓝想知道，在数字跳转的过程中，有多少个灯管的状态发生了变化。

输入格式

输入共两行，包含两个等长字符串。

第一行包含一个字符串 S（∣S∣≤10⁵），代表一开始的数字串。

第二行包含一个字符串 T（∣T∣≤10⁵），代表跳变后的数字串。

输出格式

一个整数，代表跳变过程中变化的灯管数量。

样例输入

01
56

样例输出

说明

跳变过程如题干中的图片。

0→5 变化了 3 根灯管，1→6 变化了 6 根灯管，共变化 9 根灯管。

运行限制

语言	最大运行时间	最大运行内存
C++	1s	256M
C	1s	256M
Java	2s	256M
Python3	3s	256M
PyPy3	3s	256M
Go	3s	256M
JavaScript	3s	256M

来自: 2.霓虹【算法赛】 – 蓝桥云课

我的题解

def compute(init, end):
    """
    计算从初始状态到结束状态之间所有可能变化的数量。
    
    参数:
    init: 字符串，表示初始状态，由数字组成，每个数字代表一个灯泡的状态。
    end: 字符串，表示结束状态，同样由数字组成。

    返回值:
    整数，表示从初始状态变化到结束状态之间所有可能变化的数量。
    """
    result = 0  # 初始化结果为0
    # 遍历初始状态中的每个灯泡
    for i in range(len(init)):
        # 计算当前灯泡在初始状态到结束状态间增加的可能状态数
        set_add = set(num_lis[int(end[i])]) - set(num_lis[int(init[i])])
        # 计算当前灯泡在初始状态到结束状态间减少的可能状态数
        set_reduce = set(num_lis[int(init[i])]) - set(num_lis[int(end[i])])
        # 将增加和减少的可能状态数累加到结果中
        result += len(set_add) + len(set_reduce)
    return result


num_lis = [
    [0, 1, 2, 4, 5, 6],
    [2, 5],
    [0, 2, 3, 4, 6],
    [0, 2, 3, 5, 6],
    [1, 2, 3, 5],
    [0, 1, 3, 5, 6],
    [0, 1, 3, 4, 5, 6],
    [0, 2, 5],
    [0, 1, 2, 3, 4, 5, 6],
    [0, 1, 2, 3, 5, 6]
]  # 灯泡状态对应的可能数值列表

# 从用户输入中获取初始状态和结束状态
light_init = input()
light_end = input()

# 打印计算结果
print(compute(light_init, light_end))

AI 题解

qwen-max-longcontext

为了解决这个问题，我们需要比较两个字符串中每个位置的数字所对应的 7 段 LED 灯管的状态差异。

对于每一个数字，我们可以预先定义好它在 7 段 LED 上点亮的灯管状态（1 表示点亮，0 表示熄灭），然后逐个字符进行比较。对于同一个位置上的两个数字，计算它们对应二进制表示中有多少位不同，这个数目即为该位置上变化的灯管数量。

然后将所有位置的变化灯管数量加起来，即可得到总变化灯管数量。

下面是一个简单的 Python 解答方案：

# 定义 0-9 的七段显示码
seg_code = {
    '0': '1111110',
    '1': '0110000',
    '2': '1101101',
    '3': '1111001',
    '4': '0110011',
    '5': '1011011',
    '6': '1011111',
    '7': '1110000',
    '8': '1111111',
    '9': '1111011',
}

def count_changes(s, t):
    total_changes = 0
    for s_digit, t_digit in zip(s, t):
        s_binary = seg_code[s_digit]
        t_binary = seg_code[t_digit]
        changes = sum(int(a) ^ int(b) for a, b in zip(s_binary, t_binary))
        total_changes += changes
    return total_changes

s = input().strip()
t = input().strip()

print(count_changes(s, t))

样例输入：

01
56

样例输出：

360GPT_V2_S9

思路：

先定义一个7位的数组，表示7段LED管的状态。数组的每一位表示一个段的状态，数组的值为1表示该段亮，为0表示该段熄灭。
对于输入的两个字符串S和T，分别计算出对应的7位数组。对于字符串中的每一个字符，通过映射关系得到对应的7位数组，并累加到结果数组中。
计算两个结果数组的差异，即为变化的灯管数量。

Python代码：

def count_change(S, T):
    seg = [0, 0, 0, 0, 0, 0, 0]
    seg_dict = {'0': [1, 1, 1, 1, 1, 1, 0],
                '1': [0, 1, 1, 0, 0, 0, 0],
                '2': [1, 1, 0, 1, 1, 0, 1],
                '3': [1, 1, 1, 1, 0, 0, 1],
                '4': [0, 1, 1, 0, 0, 1, 1],
                '5': [1, 0, 1, 1, 0, 1, 1],
                '6': [1, 0, 1, 1, 1, 1, 1],
                '7': [1, 1, 1, 0, 0, 0, 0],
                '8': [1, 1, 1, 1, 1, 1, 1],
                '9': [1, 1, 1, 1, 0, 1, 1]}
    for s in S:
        for i in range(7):
            seg[i] += seg_dict[s][i]
    for t in T:
        for i in range(7):
            seg[i] -= seg_dict[t][i]
    return sum([abs(i) for i in seg])

S = input()
T = input()
print(count_change(S, T))

百川大模型

这个问题可以通过计算两个字符串之间的汉明距离来解决，汉明距离是指两个字符串相同位置上不同字符的数量。在这个问题中，我们可以将每个数字的7段LED编码映射到一个长度为7的二进制字符串，然后计算这两个二进制字符串的汉明距离。

以下是一个Python解决方案：

def calculate_hamming_distance(s, t):
    # 创建一个映射，将数字映射到其对应的7段LED编码
    led_map = {'0': '1111110', '1': '0011000', '2': '1011011', '3': '1011111',
               '4': '0111101', '5': '1101111', '6': '1101111', '7': '0001111',
               '8': '1111111', '9': '1111011'}

    # 将输入的字符串转换为对应的LED编码
    s_led = ''.join([led_map[digit] for digit in s])
    t_led = ''.join([led_map[digit] for digit in t])

    # 计算汉明距离
    distance = sum(c1 != c2 for c1, c2 in zip(s_led, t_led))

    return distance

# 读取输入
s = input().strip()
t = input().strip()

# 计算并输出结果
print(calculate_hamming_distance(s, t))

这个程序首先定义了一个字典 led_map，它将每个数字映射到其对应的7段LED编码。然后，它将输入的字符串转换为对应的LED编码，并计算这两个LED编码的汉明距离。最后，它打印出汉明距离，这就是跳变过程中变化的灯管数量。

搜索 AI 伙伴

为了解决这个问题，我们需要将每个数字映射到其对应的灯管状态，并比较两个字符串中相同位置数字的灯管状态变化。以下是使用Python实现的一个解决方案：

def count_changed_segments(num):
    """将数字映射到灯管状态，0表示灯管熄灭，1表示灯管点亮"""
    segments = {
        '0': [1, 1, 1, 1, 1, 1, 0],
        '1': [0, 1, 1, 0, 0, 0, 0],
        '2': [1, 1, 0, 1, 1, 0, 1],
        '3': [1, 1, 1, 1, 0, 0, 1],
        '4': [0, 1, 1, 0, 0, 1, 1],
        '5': [1, 0, 1, 1, 0, 1, 1],
        '6': [1, 0, 1, 1, 1, 1, 1],
        '7': [1, 1, 1, 0, 0, 0, 0],
        '8': [1, 1, 1, 1, 1, 1, 1],
        '9': [1, 1, 1, 1, 0, 1, 1]
    }
    return segments[num]


def count_changed_lights(s, t):
    """计算两个数字串跳变过程中变化的灯管数量"""
    if len(s) != len(t):
        raise ValueError("Input strings must be of equal length")

    changed_lights = 0
    for digit_s, digit_t in zip(s, t):
        segments_s = count_changed_segments(digit_s)
        segments_t = count_changed_segments(digit_t)
        changed_lights += sum(s != t for s, t in zip(segments_s, segments_t))

    return changed_lights


# 读取输入
s = input().strip()
t = input().strip()

# 计算并输出变化的灯管数量
print(count_changed_lights(s, t))

例如，对于样例输入：

01
56

它将输出：

这表示从数字串”01″到”56″的跳变过程中，总共有9根灯管的状态发生了变化。

存档地址：https://www.yuque.com/worthstudy/study/ho4dktwhidsk6w68?singleDoc# 《霓虹》

文章版权归作者所有，如需转载请联系作者。若文章内容侵犯了您的权益，请通过网站底部联系方式联系我们处理（本站具有最终解释权）。如有不便之处，敬请谅解。

THE END

霓虹