如何优化代码以返回最接近给定 integer 的数字，但不存在于给定列表中？

Question

I solved this problem statement (Yeah Yeah, I know, I am putting the problem statement below).

---

Given are an integer X and an integer sequence of length N: p1, …, pN. Among the integers not contained in the sequence p1, …, pN (not necessarily positive), find the integer nearest to X, ie the integer whose absolute difference with X is the minimum. If there are multiple such integers, report the smallest such integer

---

This is the code I used:

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <vector>

int main() {
    int x = 0;
    int n = 0;
    std::cin >> x >> n;
    std::vector<decltype(x)> vect(n);
    bool vect_contains_x = false;
    for (auto& elem : vect) {
        std::cin >> elem;
        if (elem == x) {
            vect_contains_x = true;
        }
    }
    int num = 0;
    if (!vect_contains_x) {
        num = x;
    }
    else {
        std::sort(vect.begin(), vect.end());
        while (1) {
            static int i = 1;
            if (std::find(vect.begin(), vect.end(), x - i) == vect.end()) {
                num = x - i;
                break;
            }
            else if (std::find(vect.begin(), vect.end(), x + i) == vect.end()) {
                num = x + i;
                break;
            }
            else {
                i += 1;
            }
        }
    }
    std::cout << num << "\n";
    return 0;
}

This code renders the result in 13-18ms .

---

I was able to get it down to 8-10ms by using the following optimised code:

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <vector>

int main() {
    int x = 0;
    int n = 0;
    std::cin >> x >> n;
    std::vector<decltype(x)> vect(n);
    bool vect_contains_x = false;
    for (auto& elem : vect) {
        std::cin >> elem;
        if (elem == x) {
            vect_contains_x = true;
        }
    }
    int num = 0;
    if (!vect_contains_x) {
        num = x;
    }
    else {
        std::sort(vect.begin(), vect.end());
        auto isPresent = [=](auto num) {
            for (const auto& elem : vect) {
                if (num == elem) {
                    return true;
                }
            }
            return false;
        };
        while (1) {
            static int i = 1;
            if (!isPresent(x - i)) {
                num = x - i;
                break;
            }
            else if (!isPresent(x + i)) {
                num = x + i;
                break;
            }
            else {
                i += 1;
            }
        }
    }
    std::cout << num << "\n";
    return 0;
}

---

However, the problem with both the codes (as they both use the same approach) is that, If there is a large continuous stream of integers in the given list, something like:

1,2,3,4,5,6,7,8,9,10,...,1501

and the X given is

751

---

The code will need 750 iterations of the for loop , which is a lot. Can we use a better algorithm to find the closest integer?

---

EDIT :

Got it down to 6ms by using binary_search (Thanks @Sebastian), but still, the algorithm remains the same...

Answer 1

You can see this "cheating" algorithm. It's cheating because the _Find_next method is only in the GCC compiler. Also, with the help of printf and scanf , I accelerated input and output, due to which the program runs faster. I sent it for execution several times and received 4, 6 and 8 ms (6 ms most often):

#include <bitset>
#include <algorithm>

using namespace std;

int main()
{
    const int MAX_VALUES = 101;
    bitset<MAX_VALUES> bits;
    bitset<MAX_VALUES> reversed;
    bits.flip();
    reversed.flip();
    int x, n, t;
    scanf("%d %d", &x, &n);
    if (n == 0) {
        printf("%d", x);
        exit(0);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &t);
        bits.reset(t);
        reversed.reset(MAX_VALUES - 1 - t);
    }
    if (bits[x]) {
        printf("%d", x);
        exit(0);
    }
    int rV = bits._Find_next(x);
    int lV = MAX_VALUES - 1 - reversed._Find_next(MAX_VALUES - 1 - x);
    int d1 = abs(rV - x);
    int d2 = abs(lV - x);
    if (d1 < d2) {
        printf("%d", rV);
    } else if (d2 < d1) {
        printf("%d", lV);
    } else {
        printf("%d", min(rV, lV));
    }
    return 0;
}

I am not saying that this "algorithm" is better than yours. But, as I understand it, you asked for some other solutions, this is one of the possible.

Answer 2

According to your link, the total number of integers is at most 100. So 100 bits are enough to hold the flags, which numbers appear in the sequence. Those can be held in the processor registers.

The following code shows only the storage, afterwords you would have to chose suitable bit scan operations:

#include <cstdlib>
#include <iostream>
#include <numeric>
#include <limits>
#include <bitset>

using namespace std;

int main() {
    bitset<100> flags;
    int x = 0;
    int n = 0;
    int min = std::numeric_limits<int>::max();
    int num = 0;
    std::cin >> x >> n;
    for (int i = 0; i < n; i++) {
        int elem;
        std::cin >> elem;
        flags.set(elem);
    }
    // then you can shift the result by x bits and do bit scan operations
    // there are built-ins depending on the compiler and processor architecture or the portable De Bruijn with multiplications
}
// alternatively (to the shift) you can use two bitsets, and for one set all the elements (elem - x) or for the other (x - elem)