TestDome - C++ 中的恶意软件分析

Question

我正在 TestDome 上练习这个问题，我发现自己陷入了恶意软件过程的最后一步，即用值 0 替换正确的位置。我的程序准确地打印出这些值，直到我们遇到最后一个位置，我们得到的是

3, 3, 0

，而不是打印倒数第二个值

0, 0, 0

。

这是我的代码：

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

// Update: The problematic is that we need to find a way to not eliminate the first two 77 values.

std::vector<int> simulate(const std::vector<int>& entries) {
    std::vector<int> tempEntries{};
    std::vector<int> simEntries{ entries };

    for (std::vector<int>::const_iterator itX = entries.begin();
        itX != entries.end(); itX++) {
        std::vector<int>::const_iterator itRightT{}; // Iterator of right T position. 
        itRightT = itX + 4;
        if (itRightT != entries.end()) {
            if (*itX <= *itRightT) {
                tempEntries.push_back(*itX);
            }
        }
        else {
            break;
        }
    }

    for (std::vector<int>::const_reverse_iterator itReverseX = entries.rbegin();
        itReverseX != entries.rend(); itReverseX++) {
        std::vector<int>::const_reverse_iterator itLeftT{}; // Iterator of left T position.
        itLeftT = itReverseX + 3;
        if (itLeftT != entries.rend()) {
            if (*itReverseX <= *itLeftT) {
                tempEntries.push_back(*itReverseX);
            }
        }
        else {
            break;
        }
    }

    std::sort(tempEntries.begin(), tempEntries.end());

    for (std::vector<int>::iterator it = simEntries.begin();
        it != simEntries.end(); it++) {
        if (std::find(tempEntries.begin(), tempEntries.end(), *it) != tempEntries.end()) {
            *it = 0;
        }
    }

    // Desired Result: 1, 0, 0, 5, 0, 0, 0, 3, 3, 0
    //  Actual Result: 1, 0, 0, 5, 0, 0, 0, 0, 0, 0
    return simEntries; 
}

#ifndef RunTests
int main()
{
    std::vector<int> result = simulate({ 1, 2, 0, 5, 0, 2, 4, 3, 3, 3 });
    for (int value : result)
    {
        std::cout << value << " ";
    }
    // Expected output
    // 1, 0, 0, 5, 0, 0, 0, 3, 3, 0
}
#endif

我试图寻找能够完成上述任务的STL函数。然而，我找不到任何一个特别令人惊叹的。例如，

std::set_intersection

就很好地完成了比较；但是，我无法直接修改元素。 （也许有一种方法可以解决这个限制，但我不知道。）

感谢解决此问题的任何帮助。

Answer 1

我用Python编写了这个示例，它适用于示例答案，但它没有通过其他测试。你可以看一下：

def simulate(entries):
    """
    :param entries: (list(int)) The numerical record files
    :returns: (list(int)) The record files after running the malware
    """
    # Create a copy of the input list to avoid modifying the original
    result = entries[:]

    window_size = 8
    ref_position = 3
    second_half_length = 4

    for i in range(len(entries)):

        if i >= ref_position:
            window = entries[i-ref_position:i + window_size]
            x_position = 3
            T1 = window[0]
            T2 = window[-1] if len(window) <= window_size else None
            X = window[x_position] if len(window) >= x_position + 1 else None
        else:
            window = entries[i:5+i]
            x_position = 0
            T1 = None
            T2 = window[-1] if len(window) <= window_size else None
            X = window[i] if len(window) >= x_position + 1 else None

        if X is not None and T1 is not None and X < T1:
            result[i ] = 0
        if X is not None and T2 is not None and X < T2:
            result[i ] = 0
    return result


# Test the function with your example
records = [1, 2, 0, 5, 0, 2, 4, 3, 3, 3]
print(simulate(records))
# Expected output
# [1, 0, 0, 5, 0, 0, 0, 3, 3, 0]

Answer 2

这是问题的可能解决方案之一，就像我之前在另一个答案中所说的那样，它只通过了第一个和第三个测试，而不是其余的。

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

std::vector<int> simulate(const std::vector<int>& entries) {
    std::vector<int> simEntries{ entries };
    std::vector<std::vector<int>::iterator> tempEntries{};

    for (std::vector<int>::iterator itX = simEntries.begin();
        itX != simEntries.end(); itX++) {
        std::vector<int>::iterator rightT{};  // Iterator of right T position.

        if (itX >= (simEntries.end() - 4)) {
            break;
        }
        else {
            rightT = itX + 4;
            if (*itX <= *rightT) {
                tempEntries.push_back(itX);
            }
        }
    }

    for (std::vector<int>::iterator itX = simEntries.begin();
        itX != simEntries.end(); itX++) {
        std::vector<int>::iterator leftT{ itX }; // Iterator of left T position.

        if (leftT <= (simEntries.begin() + 3)) {
            continue;
        }
        else {
            leftT = itX - 3;
            if (*itX <= *leftT) {
                tempEntries.push_back(itX);
            }
        }
    }

    for (std::vector<int>::iterator it = simEntries.begin();
        it != simEntries.end(); it++) {
        if (std::find(tempEntries.begin(), tempEntries.end(), it) != tempEntries.end()) {
            *it = 0;
        }
    }

    return simEntries;
}

#ifndef RunTests
int main() {
    std::vector<int> result = simulate({ 1, 2, 0, 5, 0, 2, 4, 3, 3, 3 });
    for (int value : result) {
        std::cout << value << " ";
    }
    // Expected output
    // 1, 0, 0, 5, 0, 0, 0, 3, 3, 0
}
#endif