#chalenge
Does this work?
void printPair(std::pair<auto, auto> p) {
std::cout << p.first << ", " << p.second << '\n';
}
printPair({32,34});
If not why, and how do you fix it?

All C++20 core language features with examples

https://oleksandrkvl.github.io/2021/04/02/cpp-20-overview.html

A very nice comparison table:
https://www.educba.com/c-plus-plus-using-vs-typedef/

A good resource to read about design patterns using object oriented programming:
https://refactoring.guru/design-patterns/factory-method

#challenge (Task)
The variables i, d , and s are already defined. You must declare three variables of the same types.
Read 3 lines of input from stdin and initialize your variables according to the sequence above.
Use the` +` operator to perform the following operations:
Print the sum of i plus your int variable on a new line.
Print the sum of d plus your double variable to a scale of one decimal place on a new line.
Concatenate s with the string you read as input and print the result on a new line.

Sample Input
12
4.0
is the best place to learn and practice coding!

Sample Output
16
8.0
C++ & Qt group is the best place to learn and practice coding!

int main() {
int i = 4;
double d = 4.0;
string s = "C++ & Qt group ";
// your code

#challenge
Does it compile? If yes, what is the output and if not what is the error?
class test {
int i;

public:
int& getVal() { return i; }
void printVal() { std::cout << i << '\n'; }
};

int main() {
test t{};
t.printVal();
auto p = t.getVal();
p++;
t.printVal();
}

#Challenge (Task)

A string S consisting of N characters is considered to be properly nested if any of the following conditions is true:

- S is empty;
- S has the form "(U)" or "[U]" or "{U}" where U is a properly nested string;
- S has the form "VW" where V and W are properly nested strings.

For example, the string "{[()()]}" is properly nested but "([)()]" is not.

Write a function:

int solution(string &S);

that, given a string S consisting of N characters, returns 1 if S is properly nested and 0 otherwise.

For example, given S = "{[()()]}", the function should return 1 and given S = "([)()]", the function should return 0, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [0..200,000];
string S consists only of the following characters: "(", "{", "[", "]", "}" and/or ")".

#Challenge - Task
You are given two non-empty arrays A and B consisting of N integers. Arrays A and B represent N voracious fish in a river, ordered downstream along the flow of the river.

The fish are numbered from 0 to N − 1. If P and Q are two fish and P < Q, then fish P is initially upstream of fish Q. Initially, each fish has a unique position.

Fish number P is represented by A[P] and B[P]. Array A contains the sizes of the fish. All its elements are unique. Array B contains the directions of the fish. It contains only 0s and/or 1s, where:

0 represents a fish flowing upstream,
1 represents a fish flowing downstream.
If two fish move in opposite directions and there are no other (living) fish between them, they will eventually meet each other. Then only one fish can stay alive − the larger fish eats the smaller one. More precisely, we say that two fish P and Q meet each other when P < Q, B[P] = 1 and B[Q] = 0, and there are no living fish between them. After they meet:

If A[P] > A[Q] then P eats Q, and P will still be flowing downstream,
If A[Q] > A[P] then Q eats P, and Q will still be flowing upstream.
We assume that all the fish are flowing at the same speed. That is, fish moving in the same direction never meet. The goal is to calculate the number of fish that will stay alive.

For example, consider arrays A and B such that:

A[0] = 4 B[0] = 0
A[1] = 3 B[1] = 1
A[2] = 2 B[2] = 0
A[3] = 1 B[3] = 0
A[4] = 5 B[4] = 0
Initially all the fish are alive and all except fish number 1 are moving upstream. Fish number 1 meets fish number 2 and eats it, then it meets fish number 3 and eats it too. Finally, it meets fish number 4 and is eaten by it. The remaining two fish, number 0 and 4, never meet and therefore stay alive.

Write a function:

int solution(vector<int> &A, vector<int> &B);

that, given two non-empty arrays A and B consisting of N integers, returns the number of fish that will stay alive.

For example, given the arrays shown above, the function should return 2, as explained above.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..100,000];
each element of array A is an integer within the range [0..1,000,000,000];
each element of array B is an integer that can have one of the following values: 0, 1;
the elements of A are all distinct.

#challenge - Task
Let us consider a sequence with n elements a0, a1, . . . , an−1 such that 0 << ai <<10^9. The leader of this sequence is the element whose value occurs more than n/2 times.
For instance in: A{6,8,4,6,8,6,6} the leader is 6 because it has appeared 4 times in the sequence which is more than (7/2) 3.
Write a function
int solution(vector<int> &A);
and an efficient algorithm that given an array of n elements returns 1 if the array contains a leader and 0 otherwise.

#Challenge - Task

A good link to learn code smells: https://refactoring.guru/refactoring/smells

Recording: https://resources.qt.io/on-demand/roadmap-to-the-future-of-qt-on-demand-webinar