9

I understand that iota can be complex(e.g. infinite), so this can not be done easily in general case, but in some cases it should be possible to do find/contains operation in O(1).

For example

int main() {
    auto vals = views::iota(10'000'000'000, 100'000'000'000);
    return ranges::find(vals, 74'656'000'000) != vals.end();
}

runs "infinitely" (doing linear search) while

obviously check can be done in O(1).

Is there a way to do this generic way with C++(i.e. find/contains that on other views takes linear time, and when it detects iota it takes O(1)), or I need to manually detect when view passed to my function is finite iota view and do the >=front <=back check?

NoSenseEtAl
  • 28,205
  • 28
  • 128
  • 277
  • 1
    `find` would still need to do a linear operation, but `contains` could be specialised – Caleth May 03 '23 at 09:57
  • 1
    I would remove `find` from the question and just leave `contains`, for the reason explained in Caleth's comment. – Enlico May 03 '23 at 10:55
  • 1
    You're violating your own API when you try to break into the implementation of a range argument. Either have a different API with different parameters or use the range as intended. – Passer By May 03 '23 at 10:55
  • 3
    It's pretty hard to figure out how to customize algorithms in light already existing member functions which [mean different things](https://stackoverflow.com/a/75687947/2069064). Python gets away with this in a pretty interesting way: a `dict` is a range of keys, so having `key in d` work is consistent - but in C++ our hashtables are ranges of pairs... – Barry May 03 '23 at 13:47
  • @Barry I see your point, but do you know then why iota view does not have .contains() (constrained by something unreadable that basically guarantees value is computable in O(1)). That seems relatively ok solution. Then I could use that... – NoSenseEtAl May 03 '23 at 15:53
  • @Enlico I see your point, but not sure most C++ learners are helped by this change. find is a much older function name in C++ than contains and for example map find is not linear. Again I could be wrong, I am just guessing what ppl googling might use for search – NoSenseEtAl May 03 '23 at 15:56

3 Answers3

8

iota_view is always ordered, so you can use ranges::binary_search to avoid infinite linear search

int main() {
  auto vals = views::iota(10'000'000'000, 100'000'000'000);
  return ranges::binary_search(vals, 74'656'000'000);
}

Demo

康桓瑋
  • 33,481
  • 5
  • 40
  • 90
  • 3
    upvote since it is an improvement, but it is still O(log n), no? – NoSenseEtAl May 03 '23 at 12:11
  • also this is getting into "intentionally breaking it" but I presume you could make a iota where std::less (default used by binary search) is giving wrong result since "incremeting" value that is done by iota actually decreses it. – NoSenseEtAl May 04 '23 at 12:00
1

No it cannot be done in O(1).

The reason is simple, since the introduction of <algorithm> in C++11 the algorithms like find just assume a container with iterators as input. So for all algorithms the input is generic.

If you look at member functions of ranges/iota_view, you can see that the access functions are similar to those in std::vector. And algorithms like find simply use this interface without caring what is behind, e.g. they behave generic and not specialized.

Ranges and Views which came with C++20 are no game changers here. If you need performance boosts you need to implement a spezializated functions yourself.

int main() {
  auto vals = views::iota(10'000'000'000, 100'000'000'000);
  return *vals.begin() >= 74'656'000'000 && *vals.end() <= 74'656'000'000);
}
Jan Hackenberg
  • 481
  • 3
  • 14
0

It can be done for O(1) with a bit field if you have extra at least 11 GB of RAM. Set the required bits number - 10'000'000'000 in a bit field, where number is between 10'000'000'000 and 100'000'000'000. Then check if the bit 74'656'000'000 - 10'000'000'000 is set. This is O(1).

273K
  • 29,503
  • 10
  • 41
  • 64