Question

我正在为testdome https://www.testdome.com/for-developers/solve-question/9880

中给出的测试样本编写答案

问题是关于排序搜索：实现函数countNumbers，它接受整数的排序向量，并计算小于参数lessThan的向量元素的数量。

例如，对于包含{1,3,5,7}的向量v，SortedSearch :: countNumbers（v，4）应该返回2，因为有两个向量元素小于4。

我修改了如下代码，但测试结果告诉我们有两个失败： 1）sortedVector包含lessThan：超出时间限制时的性能测试 2）sortedVector不包含lessThan：超出时间限制

时的性能测试

您能帮忙更新我的代码以解决问题吗？

#include <vector>
#include <stdexcept>
#include <iostream>

class SortedSearch
{
public:
    static int countNumbers(const std::vector<int>& sortedVector, int lessThan)
    {
        int a = 0;
        for (size_t i=0; i<sortedVector.size(); i++)
        {
            if (sortedVector[i]<lessThan)
            {
                a++;
            }
        }
        return a;
    }
};

#ifndef RunTests
int main()
{
    std::vector<int> v { 1, 3, 5, 7 };
    std::cout << SortedSearch::countNumbers(v, 4);
}
#endif

Answer 1

您可以利用数据排序的事实来查找对数时间的答案。 C ++标准库有一个用于此任务的算法。

使用std::lower_bound查找大于或等于目标值的第一个元素。然后调用std::distance将元素的数量从容器的开头返回到上一步中找到的位置。

#include <algorithm>
#include <iterator>

class SortedSearch
{
public:
    static int countNumbers(const std::vector<int>& sortedVector, int lessThan)
    {
        // get an iterator to the first element >= lessThan
        auto itr = std::lower_bound(std::begin(sortedVector), std::end(sortedVector), lessThan); // O(log n)

        // return the distance between two iterators
        return std::distance(std::begin(sortedVector), itr); // O(1)
    }
};

Answer 2

尝试使用更快的方法。使用binary_search查找小于给定值的最后一个元素。

Answer 3

实际上，该实现已在Wiki：二进制搜索算法中。在“查找最左边元素的过程”中查找解释和实现。

这是我的答案：

#include <vector>
#include <stdexcept>
#include <iostream>

class SortedSearch
{
public:
    static int countNumbers(const std::vector<int>& sortedVector, int lessThan)
    {
        int lower, upper, middle;

        lower = 0;
        upper = sortedVector.size();

        // do a binary search
        while(lower < upper)
        {
            middle = (lower + upper) / 2;

            if (sortedVector[middle] < lessThan)
            {
                lower = middle + 1;
            }
            else
            {
                upper = middle;
            }
        } 

        return lower;
        //throw std::logic_error("Waiting to be implemented");
    }
};

#ifndef RunTests
int main()
{
    std::vector<int> v { 1, 3, 5, 7 };
    std::cout << SortedSearch::countNumbers(v, 4);
}
#endif

您将得到4/4。

Answer 4

使用向量排序的事实可以通过不查看整个向量来帮助加速代码。

If (sortedVector[i]>=lessthan)
{
     return a;
}

当你点击一个大于the leshan的元素时，这将终止你的循环并节省你不必要的迭代。对于你给定的main，它只会经历2次迭代而不是4次。

虽然这并没有专门解决上面提到的问题，但看看它是否能够通过测试用例提供足够的性能提升来传递它们。这也将使你的最坏情况表现为O（n）而不是每次运行的O（n）

c ++代码：关于排序的搜索测试样本

4 个答案: