Lesson 1

Welcome! Today, I am thrilled to guide you through a fascinating task involving vectors in **C++**: pairing up 'opposite' elements. Specifically, we're going to learn how to access and manipulate elements within a C++ vector. The task at hand provides an excellent opportunity to elevate your **vector-handling skills** within the C++ language. Are you ready to get started? Let's dive right in!

Our task today is to form pairs of 'opposite' elements in a given vector of integers. In a vector consisting of `n`

elements, the first and last elements are known as 'opposite', the second element and the second last element are considered 'opposite', and so on. For a vector with an odd length, the middle element is its own 'opposite'.

You will be provided with a vector of `n`

integers. The value of `n`

could range from 1 to 100, inclusive. The task will require you to return a `std::vector`

of `std::pair`

objects. Each `std::pair`

consists of an element and its 'opposite' element.

Let's use example vector `numbers`

as `{1, 2, 3, 4, 5}`

to simplify our understanding. In this case, the output of our `solution(numbers)`

function will be `{(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)}`

.

Before we start writing code, let's familiarize ourselves with how to access the elements of an vector in C++.

In C++, the `i`

-th element of a vector `numbers`

can be accessed as `numbers[i]`

, with the index starting from `0`

. Consequently, the first element is `numbers[0]`

, the second one is `numbers[1]`

, and so forth, up to `numbers[number.size() - 1]`

for the last element.

Now, let's figure how to access an element's 'opposite'.

The 'opposite' of the `i`

-th element of the vector is the element at the `numbers.size() - i - 1`

-th position. To illustrate this concept, consider standing at the start of a line and your friend standing at the end of the line. In this scenario, you and your friend could be considered 'opposites'. Similarly, the 'opposite' of `numbers[0]`

is `numbers[numbers.size() - 0 - 1]`

, the 'opposite' to `numbers[1]`

is `numbers[numbers.size() - 1 - 1]`

, and so forth.

Now that we understand how to locate an element's 'opposite', we can proceed to code our solution. Let's start by initializing an empty `std::vector`

named `result`

to store our 'opposite' pairs and compute the vector's size for future reference.

C++`1std::vector<std::pair<int, int>> solution(std::vector<int>& numbers) { 2 std::vector<std::pair<int, int>> result; 3 int n = numbers.size();`

The next step is to loop over all elements in our `numbers`

vector. Within our loop, we'll create a `std::pair`

for each pairing of 'opposite' elements. This pair will consist of the `i`

-th element and the `n - i - 1`

-th element. This pair will then be pushed onto the back of our `result`

`std::vector`

. Here's the final version of our function:

C++`1std::vector<std::pair<int, int>> solution(std::vector<int>& numbers) { 2 std::vector<std::pair<int, int>> result; 3 int n = numbers.size(); 4 for (int i = 0; i < n; i++) { 5 result.push_back({numbers[i], numbers[n - i - 1]}); 6 } 7 return result; 8}`

This function iterates over all the elements of the vector. For each of these elements, it forms a `std::pair`

with its 'opposite' and subsequently inserts the pair into the `result`

`std::vector`

.

Great job! You've successfully navigated through the concept of 'opposite' pairs and vector indexing in C++. By now, you should be familiar with the notion of accessing and pairing elements in a vector based on their positions. This fundamental step brings you closer to mastering vector manipulation within C++. Up next, we've prepared a series of hands-on exercises for you to apply and further practice what you've learned today. Remember, practice makes a man perfect. Keep up the great work, and happy coding!