00101010101100001010010
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

01010
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

# 读取输入字符串
s = input()

def longestAlternatingWave(s):
    max_len = 0  # 记录最长交替波的长度
    result = "-1"  # 存储最终结果（默认为 -1，表示不存在交替波）
    current_len = 0  # 当前交替波的长度
    start = 0  # 当前交替波的起始位置
    state = 0  # 状态机的初始状态：0 表示等待遇到 '0'

    # 遍历字符串中的每个字符
    for i, char in enumerate(s):
        if state == 0:  # 初始状态，等待遇到 '0'
            if char == "0":
                state = 1  # 转移到状态 1（遇到 '0'）
                start = i  # 记录交替波的起始位置
                current_len = 1  # 当前交替波长度为 1
            else:
                state = 0  # 继续等待 '0'
                current_len = 0  # 重置当前波长
        elif state == 1:  # 状态 1，等待遇到 '1'
            if char == "1":
                state = 2  # 转移到状态 2（遇到 '1'）
                current_len += 1  # 当前交替波长度加 1
            else:
                state = 1  # 如果遇到 '0'，重新开始交替波
                start = i  # 更新起始位置
                current_len = 1  # 当前波长重置为 1
        elif state == 2:  # 状态 2，等待遇到 '0'
            if char == "0":
                state = 1  # 转移回状态 1（遇到 '0'）
                current_len += 1  # 当前交替波长度加 1
                # 如果当前波长大于记录的最大波长，更新结果
                if current_len > max_len:
                    max_len = current_len  # 更新最大波长
                    result = s[start:i+1]  # 更新结果为当前交替波子串
            else:
                state = 0  # 如果遇到 '1'，重新开始波形
                current_len = 0  # 重置波长

    # 如果找到的最长交替波长度小于 3，则返回 -1
    if max_len < 3:
        return "-1"
    return result  # 返回最长交替波子串

# 调用函数并输出结果
print(longestAlternatingWave(s))

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48

java解法

• 解题思路
• 问题描述：

输入一个仅包含 ‘0’ 和 ‘1’ 的字符串。
查找其中最长的 “交替波” 子串。
“交替波” 的定义是以 01 模式交替出现的字符串，且以 0 结尾，例如：01010、010。
如果没有找到符合条件的子串，输出 -1。
解法设计：

使用类 WaveProcessor 封装处理逻辑。
遍历输入字符串，构造当前的波形子串，检测是否符合波形规则并更新最长波形。
波形规则通过正则表达式匹配，确保子串是有效波形。
关键方法设计：

getLongestWave：
遍历输入字符串构造波形。
每次遇到 ‘0’ 时，检测当前波形是否已完成。
如果当前波形有效且比最长波形更长，则更新最长波形。
isWaveTerminated：
检查波形是否以 ‘0’ 结尾，表示波形可能完成。
isValidWave：
使用正则表达式 ^(01)+0$ 检查波形是否为有效的交替波。
输入输出：

输入：
一个字符串，仅包含 ‘0’ 和 ‘1’。
输出：
最长的交替波子串；如果没有找到，输出 -1

import java.util.Scanner;
import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        // 创建 Scanner 对象用于读取输入
        Scanner sc = new Scanner(System.in);
        // 读取用户输入的信号字符串
        String input = sc.nextLine();

        // 创建 WaveProcessor 对象处理输入信号
        WaveProcessor processor = new WaveProcessor(input);
        // 获取最长的交替波子串
        String result = processor.getLongestWave();

        // 输出结果
        System.out.println(result);
    }
}

// 波形处理类，封装交替波查找的逻辑
class WaveProcessor {
    private final String signal; // 输入的信号字符串
    // 定义一个正则表达式，用于匹配有效的交替波
    private static final Pattern VALID_WAVE = Pattern.compile("^(01)+0$");

    // 构造方法，初始化信号字符串
    public WaveProcessor(String signal) {
        this.signal = signal;
    }

    /**
     * 查找最长的交替波子串
     * @return 最长的交替波子串，如果不存在返回 "-1"
     */
    public String getLongestWave() {
        StringBuilder currentWave = new StringBuilder(); // 当前正在构造的波形
        String longestWave = "-1"; // 用于存储最长波形，默认值为 "-1"
        int maxLength = 0; // 记录最长波形的长度

        // 遍历输入信号字符串的每个字符
        for (int i = 0; i < signal.length(); i++) {
            char currentChar = signal.charAt(i); // 当前字符

            if (currentChar == '0') { // 每当遇到 '0'
                // 检查当前波形是否以 '0' 终止
                if (isWaveTerminated(currentWave)) {
                    // 如果波形有效且长度大于已记录的最长波形
                    if (isValidWave(currentWave) && currentWave.length() > maxLength) {
                        longestWave = currentWave.toString(); // 更新最长波形
                        maxLength = currentWave.length(); // 更新最长波形的长度
                    }
                    // 当前波形无效或已完成，重置构造波形
                    currentWave.setLength(0);
                }
            }
            // 将当前字符追加到波形中
            currentWave.append(currentChar);
        }

        // 检查遍历结束后，最后一个波形是否为最长波形
        if (isValidWave(currentWave) && currentWave.length() > maxLength) {
            longestWave = currentWave.toString(); // 更新最长波形
        }

        // 返回最长波形，如果没有找到，返回默认值 "-1"
        return longestWave;
    }

    /**
     * 检查当前波形是否以 '0' 终止
     * @param wave 当前构造的波形
     * @return 如果以 '0' 终止，返回 true，否则返回 false
     */
    private boolean isWaveTerminated(StringBuilder wave) {
        return wave.length() > 0 && wave.charAt(wave.length() - 1) == '0';
    }

    /**
     * 检查波形是否符合交替波的规则
     * @param wave 当前构造的波形
     * @return 如果波形符合规则，返回 true，否则返回 false
     */
    private boolean isValidWave(StringBuilder wave) {
        return VALID_WAVE.matcher(wave).find();
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">