Free CPP sample questions

Correct answer: `std::stable_sort` with a lambda `[](const LogEntry& a, const LogEntry& b) { return a.timestamp < b.timestamp; }` because it guarantees that the relative order of elements with equal timestamps is maintained.

The key requirement is to preserve the original insertion order for entries with identical timestamps. The `std::stable_sort` algorithm is specifically designed for this purpose. It guarantees that the relative order of equivalent elements remains unchanged after sorting. `std::sort` does not provide this guarantee and may reorder elements with equal keys, which would violate the forensic analysis requirement. The other options are incorrect because `std::partition` only groups elements based on a predicate without fully sorting them, and `std::sort` on its own is insufficient.

Correct answer: `std::deque`

`std::deque` provides constant-time insertion and removal at both the front and the back (`push_front`/`pop_front`/`push_back`/`pop_back`) and constant-time random access via `operator[]`/`at()`, meeting every requirement. `std::vector` has O(1) random access and amortized O(1) back operations, but inserting or erasing at the front shifts every element (O(n)). `std::list` and `std::forward_list` offer no index access, and `std::stack` exposes only one end and no random access.

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`.