二进制数模式识别实现咨询（求伪代码/MQL5代码）

我来帮你搞定这个动态长度的二进制模式识别问题，核心思路是分阶段遍历+动态计数，不用预设固定长度，完全贴合你需求的规则。先理清楚问题细节：你需要把原序列从索引17倒推到0（也就是反转原序列），然后匹配「[≥3个相同值] → [≥5个相反值] → [≥3个相反值（即回到第一段的值）] → [≥5个相反值（即回到第二段的值）]」的模式。

伪代码实现（清晰易懂的逻辑） #

先给你伪代码，把整个逻辑拆解清楚，方便你理解：

// 1. 先反转原始序列，实现从索引17倒推到0的遍历顺序
original_seq = [1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0]
reversed_seq = reverse(original_seq)  // 反转后得到：[0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1]

// 2. 初始化遍历指针和计数器
current_pos = 0
seq_length = len(reversed_seq)
is_matched = false

// 3. 识别第一段：至少3个连续相同值
seg1_val = reversed_seq[current_pos]
seg1_count = 0
while current_pos < seq_length and reversed_seq[current_pos] == seg1_val:
    seg1_count += 1
    current_pos += 1
if seg1_count < 3:
    print("模式不匹配：第一段长度不够3个")
    exit

// 4. 识别第二段：至少5个和第一段相反的值
seg2_val = 1 - seg1_val  // 0变1，1变0
seg2_count = 0
while current_pos < seq_length and reversed_seq[current_pos] == seg2_val:
    seg2_count += 1
    current_pos += 1
if seg2_count < 5:
    print("模式不匹配：第二段长度不够5个")
    exit

// 5. 识别第三段：至少3个和第二段相反的值（即和第一段相同）
seg3_val = 1 - seg2_val
seg3_count = 0
while current_pos < seq_length and reversed_seq[current_pos] == seg3_val:
    seg3_count += 1
    current_pos += 1
if seg3_count < 3:
    print("模式不匹配：第三段长度不够3个")
    exit

// 6. 识别第四段：至少5个和第三段相反的值（即和第二段相同），且要遍历完整个序列
seg4_val = 1 - seg3_val
seg4_count = 0
while current_pos < seq_length and reversed_seq[current_pos] == seg4_val:
    seg4_count += 1
    current_pos += 1
if seg4_count < 5 or current_pos != seq_length:
    print("模式不匹配：第四段长度不够5个，或者序列还有未匹配部分")
    exit

// 所有条件都满足，模式匹配成功
is_matched = true
print("模式匹配成功！")
print("各段详情：")
print(f"第一段：值={seg1_val}，长度={seg1_count}")
print(f"第二段：值={seg2_val}，长度={seg2_count}")
print(f"第三段：值={seg3_val}，长度={seg3_count}")
print(f"第四段：值={seg4_val}，长度={seg4_count}")

MQL5 代码实现（可直接运行） #

下面是适配MQL5的代码，包含测试函数，你可以直接在MT5里测试：

//+------------------------------------------------------------------+
//| 二进制序列模式识别核心函数                                        |
//+------------------------------------------------------------------+
bool CheckBinaryPattern(const uchar originalSequence[], int originalLength)
{
    // 步骤1：反转序列，实现从索引17倒推到0的遍历顺序
    uchar reversedSequence[];
    ArrayResize(reversedSequence, originalLength);
    for(int i = 0; i < originalLength; i++)
    {
        reversedSequence[i] = originalSequence[originalLength - 1 - i];
    }
    
    int currentPos = 0;
    int seqLen = ArraySize(reversedSequence);
    
    // 步骤2：识别第一段（至少3个连续相同值）
    uchar seg1Val = reversedSequence[currentPos];
    int seg1Count = 0;
    while(currentPos < seqLen && reversedSequence[currentPos] == seg1Val)
    {
        seg1Count++;
        currentPos++;
    }
    if(seg1Count < 3)
    {
        Print("模式不匹配：第一段长度不足3");
        return false;
    }
    
    // 步骤3：识别第二段（至少5个相反值）
    uchar seg2Val = 1 - seg1Val;
    int seg2Count = 0;
    while(currentPos < seqLen && reversedSequence[currentPos] == seg2Val)
    {
        seg2Count++;
        currentPos++;
    }
    if(seg2Count < 5)
    {
        Print("模式不匹配：第二段长度不足5");
        return false;
    }
    
    // 步骤4：识别第三段（至少3个相反值，即和第一段相同）
    uchar seg3Val = 1 - seg2Val;
    int seg3Count = 0;
    while(currentPos < seqLen && reversedSequence[currentPos] == seg3Val)
    {
        seg3Count++;
        currentPos++;
    }
    if(seg3Count < 3)
    {
        Print("模式不匹配：第三段长度不足3");
        return false;
    }
    
    // 步骤5：识别第四段（至少5个相反值，即和第二段相同），需遍历完整个序列
    uchar seg4Val = 1 - seg3Val;
    int seg4Count = 0;
    while(currentPos < seqLen && reversedSequence[currentPos] == seg4Val)
    {
        seg4Count++;
        currentPos++;
    }
    if(seg4Count < 5 || currentPos != seqLen)
    {
        Print("模式不匹配：第四段长度不足5或序列未完全遍历");
        return false;
    }
    
    // 匹配成功，输出各段信息
    Print("模式匹配成功！");
    PrintFormat("第一段：值=%d，长度=%d", seg1Val, seg1Count);
    PrintFormat("第二段：值=%d，长度=%d", seg2Val, seg2Count);
    PrintFormat("第三段：值=%d，长度=%d", seg3Val, seg3Count);
    PrintFormat("第四段：值=%d，长度=%d", seg4Val, seg4Count);
    
    return true;
}

//+------------------------------------------------------------------+
//| 测试函数：验证给定的二进制序列                                    |
//+------------------------------------------------------------------+
void OnStart()
{
    // 原始序列：索引0-17对应的二进制值
    uchar testSequence[] = {1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0};
    int seqLength = ArraySize(testSequence);
    
    bool matchResult = CheckBinaryPattern(testSequence, seqLength);
    Print("最终测试结果：", matchResult ? "匹配成功" : "匹配失败");
}

关键逻辑说明 #

• 反转序列：因为要求从索引17倒推到0，所以直接把原序列反转，就能按正常顺序遍历处理了，不用倒着循环，逻辑更清晰
• 分阶段遍历：每一段只关注当前需要匹配的目标值，用计数器动态累加连续相同值的长度，直到遇到不同值或者序列结束，完美适配“无固定长度”的需求
• 严格校验：每一段结束后立即校验长度是否符合要求，最后还要确保整个序列都被遍历完，避免有多余的未匹配数据

内容的提问来源于stack exchange，提问作者trader