Each program (the source code .cpp file) should be submitted through Blackboard (Course Materials > Lab).

You can submit all your programs at the end of the lab session in one submission. This way, we can hopefully avoid the situation when you are quickly writing your program, immediately uploading it to Blackboard, but then, say 10 minutes later, realizing that there is a bug in it.

Basically, submit when you are sure that it will be your final version.

Each program should start with a comment that contains your name and a short program description, for example:

```
/*
Author: Your Name
Description: Lab 1. Task 1. Hello world
*/
```

You can submit incomplete programs, but their “incomplete” status must be clearly mentioned in the comment to the program. In this case, also briefly describe what is implemented, and what is not.

`vector<T>`

you need to know**Constructors:**

`vector<T> v;`

default constructor, makes an empty vector.`vector<T> v(n);`

makes a vector of size`n`

. All elements are initialized using the default constructor for the type`T`

. The primitive types (for example`int`

,`double`

, or`bool`

), don’t have a constructor and they are initialized with`0`

.`vector<T> v(n, value);`

makes a vector of size`n`

with all elements equal to`value`

.

**Methods (member functions):**

`v.size()`

,`v.push_back(x)`

,`v.pop_back()`

,`v.resize(n)`

change the size of the vector, with all newly created elements initialize using their default constructor,`v.resize(n, value)`

change the size of the vector, all newly created elements are initialized with the value`value`

.

`vector<int>`

.Implement the following three functions:

```
// Print a vector of integers
void print(vector<int> &v);
// Array to Vector conversion function.
// It copies the contents of the array `arr` of length `n` into the output vector 'v'.
// It should work correctly even if the vector `v` is not empty
void array_to_vector(int arr[], int n, vector<int> &v);
// Vector concatenation.
// Concatenate two vectors `a` and `b`, the result should be stored in the vector `c`
// the function should work correctly even if the output vector `c` is not empty
void concat_two (vector<int> &a, vector<int> &b, vector<int> &c);
```

Please use the following main function as a test:

```
int main() {
int arr1[4] = {1,3,5,7};
int arr2[3] = {2,4,6};
// Initialize vectors
vector<int> v1; // empty vector
vector<int> v2(10); // or nonempty vector
// convert the arrays to vectors
array_to_vector(arr1, 4, v1);
array_to_vector(arr2, 3, v2);
// print two vectors
print (v1); cout << endl;
print (v2); cout << endl;
// concatenate two vectors
vector<int> result(5);
concat_two(v1, v2, result);
// print out the result
print (result); cout << endl;
}
```

`vector <vector<int> >`

.

Creation of a two-dimensional vector of vectors looks somewhat tricky, this is how it can be done:

```
int width = 3;
int height = 4;
// Initializing a 2-dimensional vector by calling a constructor
// vector<T> v(n, value), where the second argument is a constructor call too:
vector <vector<int> > v (height, vector<int>(width));
// now, you can initialize the 2-dimensional vector in any way you want
// by assigning the values to v[i][j]:
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
v[i][j] = (i * width + j) % 10;
}
}
```

Implement the following two functions and test them in the `main`

function:

```
// Print a vector of vectors `v` Example:
// v[0] - first line, 1 2 3 4
// v[1] - second line, 5 6 7 8
// v[2] - third line, 9 1 2 3
// ... etc.
void print_v(vector <vector<int> > &v);
// Concatenate a vector of vectors `v`, store the result in `c`.
void concat_vector (vector <vector <int> > &v, vector <int> &c);
```

Matrix transposition is the reflection of the matrix over its main diagonal. That is, to get a matrix transposed, you write its rows as columns:

Implement two matrix transposition functions and test them in the `main`

function
(start with the first function, it’s easier to implement than the second one):

```
// Transpose a square vector of vectors
// The vector of vectors must be updated in-place
//
// Example:
//
// 1 2 3 1 4 7
// 4 5 6 -> 2 5 8
// 7 8 9 3 6 9
//
void transpose_square (vector <vector <int> > &v);
// Transpose a rectangular vector of vectors
// The vector of vectors must be updated in-place
//
// Example:
//
// 1 2 3 4 1 5 9
// 5 6 7 8 -> 2 6 1
// 9 1 2 3 3 7 2
// 4 8 3
//
void transpose_rectangle (vector <vector <int> > &v);
```