华为OD机试 - 最长的完全交替连续方波信号 - 逻辑分析（Python/JS/C/C++ 2025 A卷 200分）

华为OD机试 2025A卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

最长的完全交替连续方波信号。

输入一串方波信号，求取最长的完全连续交替方波信号，并将其输出，如果有相同长度的交替方波信号，输出任一即可，方波信号高位用1标识，低位用0标识。

说明：

1. 一个完整的信号一定以0开始然后以0结尾，即010是一个完整的信号，但101,1010,0101不是；
2. 输入的一串方波信号是由一个或多个完整信号组成；
3. 两个相邻信号之间可能有0个或多个低位，如0110010,011000010；
4. 同一个信号中可以有连续的高位，如011101010111100001010，前14为是一个具有连续高位的信号；
5. 完全连续交替方波是指10交替，如01010是完全连续交替方波，0110不是

二、输入描述

输入信号字符串（长度 >= 3 且 <= 1024）: 0010101010110000101000010
注：输入总是合法的，不用考虑异常情况

三、输出描述

输出最长的完全连续交替方波信号串：01010 若不存在完全连续交替方波信号串，输出-1。

四、测试用例

测试用例1：

1、输入

00101010101100001010010

2、输出

01010

3、说明

注意一个完整的信号一定以0开始然后以0结尾。

00101010101100001010010包含四个信号段，分别是：

• 0010101010110
• 00
• 01010
• 010

第一个信号段虽然有连续的交替连续方波信号，但是出现了连续的11高位信号，故不算是完全交替连续方波信号。

测试用例2：

1、输入

0011010101001010

2、输出

01010

3、说明

虽然信号中包含了多个交替的部分，但01010是最长的交替方波。

测试用例3：

1、输入

0101010

2、输出

0101010

五、解题思路

1. 输入信号字符串；
2. 定义正则表达式匹配完全连续交替方波信号；
3. 定义最长完全连续交替方波信号的长度maxLength；
4. 定义最长完全连续交替方波信号的字符串result；
5. 定义stringbuilder，用于存储当前处理的信号；
6. 遍历信号字符串的每个字符；
7. 当前字符是0，且前一个字符也是0，说明一个完整信号结束；
   • 对当前信号进行匹配；
   • 如果匹配到完全连续交替方波信号，并且长度大于之前的最大长度；
   • 更新最大长度；
   • 更新最大长度对应的字符串；
   • 清空当前信号；
   • 将当前字符加入当前信号；
8. 对最后一个信号进行匹配；
9. 如果匹配到完全连续交替方波信号，并且长度大于之前的最大长度；
10. 输出最长的完全连续交替方波信号串。

六、Python算法源码

import re

# 获取输入信号字符串
signal = input().strip()

# 定义正则表达式匹配完全连续交替方波信号
pattern = re.compile("^(01)+0$")

# 最长完全连续交替方波信号的长度
max_length = 0
# 最长完全连续交替方波信号的字符串
result = "-1"

# 用于存储当前处理的信号
builder = []

for i in range(len(signal)):
    c = signal[i]

    # 当前字符是0，且前一个字符也是0，说明一个完整信号结束
    if c == '0' and builder and builder[-1] == '0':
        # 对当前信号进行匹配
        match = pattern.match("".join(builder))
        # 如果匹配到完全连续交替方波信号，并且长度大于之前的最大长度
        if match and len(builder) > max_length:
            # 更新最大长度
            max_length = len(builder)
            # 更新最大长度对应的字符串
            result = "".join(builder)
        # 清空当前信号
        builder = []

    # 将当前字符加入当前信号
    builder.append(c)

# 对最后一个信号进行匹配
match = pattern.match("".join(builder))
if match and len(builder) > max_length:
    result = "".join(builder)

# 输出最长的完全连续交替方波信号串
print(result)

七、JavaScript算法源码

// 获取输入信号字符串
let signal = prompt().trim();

// 定义正则表达式匹配完全连续交替方波信号
const pattern = /^(01)+0$/;

// 最长完全连续交替方波信号的长度
let maxLength = 0;
// 最长完全连续交替方波信号的字符串
let result = "-1";

// 用于存储当前处理的信号
let builder = [];

for (let i = 0; i < signal.length; i++) {
    let c = signal[i];

    // 当前字符是0，且前一个字符也是0，说明一个完整信号结束
    if (c === '0' && builder.length > 0 && builder[builder.length - 1] === '0') {
        // 对当前信号进行匹配
        if (pattern.test(builder.join('')) && builder.length > maxLength) {
            maxLength = builder.length;
            result = builder.join('');
        }
        // 清空当前信号
        builder = [];
    }

    // 将当前字符加入当前信号
    builder.push(c);
}

// 对最后一个信号进行匹配
if (pattern.test(builder.join('')) && builder.length > maxLength) {
    result = builder.join('');
}

// 输出最长的完全连续交替方波信号串
console.log(result);

八、C算法源码

#include <stdio.h>
#include <string.h>
#include <regex.h>

int main() {
    char signal[1025];
    scanf("%s", signal);

    regex_t regex;
    regcomp(&regex, "^(01)+0$", REG_EXTENDED);

    int maxLength = 0;
    char result[1025] = "-1";
    char builder[1025];
    int builderLength = 0;

    for (int i = 0; signal[i] != '\0'; i++) {
        char c = signal[i];

        if (c == '0' && builderLength > 0 && builder[builderLength - 1] == '0') {
            builder[builderLength] = '\0';
            if (regexec(&regex, builder, 0, NULL, 0) == 0 && builderLength > maxLength) {
                maxLength = builderLength;
                strcpy(result, builder);
            }
            builderLength = 0;
        }

        builder[builderLength++] = c;
    }

    builder[builderLength] = '\0';
    if (regexec(&regex, builder, 0, NULL, 0) == 0 && builderLength > maxLength) {
        strcpy(result, builder);
    }

    printf("%s\n", result);
    return 0;
}

九、C++算法源码

#include <iostream>
#include <string>
#include <regex>
using namespace std;

int main() {
    string signal;
    cin >> signal;

    regex pattern("^(01)+0$");

    int maxLength = 0;
    string result = "-1";
    string builder;

    for (int i = 0; i < signal.length(); i++) {
        char c = signal[i];

        if (c == '0' && builder.length() > 0 && builder[builder.length() - 1] == '0') {
            if (regex_match(builder, pattern) && builder.length() > maxLength) {
                maxLength = builder.length();
                result = builder;
            }
            builder.clear();
        }

        builder.push_back(c);
    }

    if (regex_match(builder, pattern) && builder.length() > maxLength) {
        result = builder;
    }

    cout << result << endl;
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 A卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。