霓虹

问题描述

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

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

图片[1]-霓虹-值得研究

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

图片[2]-霓虹-值得研究

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

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

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

输入格式

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

第一行包含一个字符串 S(∣S∣≤105),代表一开始的数字串。

第二行包含一个字符串 T(∣T∣≤105),代表跳变后的数字串。

输出格式

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

样例输入

01
56

样例输出

9

说明

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

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

运行限制

语言最大运行时间最大运行内存
C++1s256M
C1s256M
Java2s256M
Python33s256M
PyPy33s256M
Go3s256M
JavaScript3s256M


来自: 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

样例输出:

9

360GPT_V2_S9

思路:

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

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

它将输出:

9

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


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

© 版权声明
THE END
喜欢就点赞支持一下吧,如果觉得不错或日后有所需要,可以收藏文章和关注作者哦。
点赞1
评论 抢沙发

请登录后发表评论

    暂无评论内容