Free CPP sample questions

Correct answer: `std::remove_if` does not actually erase elements from the container; it shunts the elements to be kept to the beginning and returns an iterator to the new logical end. The container must be resized manually.

`std::remove_if` (and `std::remove`) cannot alter the size of the container because it only has access to iterators, not the container object itself. It works by moving all elements that do not match the removal criteria to the front of the range and returns an iterator pointing one past the last element that was kept. The elements from this new logical end to the container's actual end are left in a valid but unspecified state. The correct way to physically remove the elements is to call the container's `erase` method with the iterator range returned by `remove_if`, a pattern known as the 'erase-remove idiom'.

Correct answer: An overloaded `operator<` that provides a strict weak ordering.

`std::map` is an ordered associative container, typically implemented as a red-black tree. To maintain order and determine the correct position for each key, it needs a way to compare two keys. By default, it uses `std::less `, which in turn calls `operator<` on the key objects. Therefore, the `UserSession` struct must provide a public `operator<` that establishes a strict weak ordering among its instances. Alternatively, a custom comparator function object could be provided as a template argument to the map, but the most common solution is to overload `operator<`.

Correct answer: 1. For the consolidated list, use `std::merge`. 2. For common trades, use `std::set_intersection`. 3. For trades unique to exchange A, use `std::set_difference`.

This approach is the most efficient because it leverages the fact that the input vectors are already sorted. `std::merge`, `std::set_intersection`, and `std::set_difference` are all linear time O(N+M) algorithms when operating on sorted ranges. `std::merge` efficiently creates the consolidated list. `std::set_intersection` produces the common trades, and `std::set_difference` produces the trades in the first range but not the second. Any approach involving re-sorting (like concatenation followed by `std::sort`) would be less efficient, with a complexity of O((N+M)log(N+M)).

Correct answer: Non-template overload

During C++ overload resolution, the compiler follows a set of rules to select the best function to call. A non-template function that is a perfect match for the argument types is preferred over a template instantiation. In this case, the string literal `"hello"` has the type `const char[6]`, which decays to `const char*`. The `process(const char*)` function is an exact match for this type. The template function `process ` could also be instantiated with `T` as `const char*`, but the non-template overload is a better match and will be chosen without hesitation.

Correct answer: `auto it = std::find_end(source.begin(), source.end(), pattern.begin(), pattern.end());`

The `std::find_end` algorithm is specifically designed for this purpose. It searches for the last occurrence of a sub-sequence within a larger sequence. It takes iterators for the range to be searched and iterators for the pattern to search for. `std::search` finds the *first* occurrence. Using reverse iterators with `std::search` is tricky because it finds the first occurrence in the reversed sequence, which corresponds to the last occurrence but returns a reverse iterator that needs to be converted back correctly.

Correct answer: True

Manipulators like `std::fixed`, `std::scientific`, `std::boolalpha`, and `std::setprecision` modify the internal state of the stream object. This state is persistent and affects all subsequent I/O operations on that stream until the state is explicitly changed by another manipulator. In contrast, manipulators like `std::setw` only affect the very next output operation.

Correct answer: 3 2 9 4 15

The code first initializes the vector `data` to `{1, 2, 3, 4, 5}` using `std::iota`. The `std::transform` algorithm is then used for an in-place modification (source and destination iterators are the same). The lambda function captures the `multiplier` variable (value 3) by value. It iterates through each element of `data`. If an element (`val`) is odd (`val % 2 != 0`), it returns `val * multiplier`; otherwise, it returns the original `val`. - 1 is odd: 1 * 3 = 3 - 2 is even: 2 - 3 is odd: 3 * 3 = 9 - 4 is even: 4 - 5 is odd: 5 * 3 = 15 Therefore, the final state of the vector is `{3, 2, 9, 4, 15}`.

Correct answer: 50

The `std::lower_bound` algorithm returns an iterator pointing to the first element in the range `[first, last)` which does not compare less than `val`. In a sorted range, this is the correct insertion point to maintain order. In the vector `{10, 20, 30, 50, 60}`, the algorithm is searching for `40`. The first element that is not less than `40` is `50`. Therefore, the iterator `it` will point to the element `50`, and dereferencing it will print `50`.

Correct answer: for (auto it = v.begin(); it != v.end(); ) { if (*it == 3) { it = v.erase(it); } else { ++it; } }

When `v.erase(it)` is called on a `std::vector`, it invalidates all iterators at or after the point of erasure, including `it` itself. Incrementing the invalidated iterator `it` in the `for` loop's increment step (`++it`) leads to undefined behavior, often a crash. The `erase` method for `std::vector` conveniently returns a new valid iterator pointing to the element that followed the erased element. The correct pattern is to capture this returned iterator and only increment the iterator manually when no erasure occurs.

Correct answer: 205 301

The `std::set_intersection` algorithm constructs a sorted range that is the intersection of two sorted source ranges. It iterates through both input ranges and copies elements that are present in both to the destination. In this case, the elements `205` and `301` are present in both the `admins` and `power_users` vectors. Therefore, the `result` vector will contain `{205, 301}`.