1, compilation error in line II

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <double> v1 (7);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
merge (mynumbers1, mynumbers1 + 3, mynumbers2, v1.begin ()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;
}

2, the program outputs 1,1

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket &_Right) const
{
return value < _Right.value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
 return stream;
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2,1,4,5};
Pocket mynumbers2 [] = {Pocket (3), Pocket (2), Pocket (4), Pocket (1) };
deque <Pocket> d1 (mynumbers1, mynumbers1 + 7);
set <Pocket> s1 (mynumbers1, mynumbers1 + 7);
sort (d1.begin (), d1.end());
sort (mynumbers1, mynumbers1 + 5);
sort (mynumbers2, mynumbers2 + 4);
cout << includes (d1.begin (), d1.end (), mynumbers1, mynumbers1 + 4) <<",
" //line i
<< includes (s1.begin (), s1.end (), mynumbers2, mynumbers2 + 4) //line ii
<<endl;
return 0;
}

3, compilation error in line ii

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
bool operator < (const int & _Right) const
{
return value < _Right;
}
operator int () const
{
return value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
 return stream;
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,2};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4);
set_symmetric_difference (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 +
3, v1.begin ()); //line i
cout << max_element (v1.begin (), v1.end ()) <<", "; //line ii
return 0;
}

4, the program outputs 2,0,0,0,0,0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,2};
vector <int> v1 (7);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4 ); //line i
set_intersection (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3,
v1.begin ()); //line ii
for_each (v1.begin (), v1.end (), printer);

return 0;
}

5, the program outputs 0,1,2,4,

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}

bool operator < (const Pocket & _Right) const

{
return value < _Right.value;
}
};

ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}
void printer (Pocket i)
{
cout << i <<", ";
}
int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
Pocket mynumbers2 [] = {6,1,4,5};
vector <Pocket> v1 (mynumbers1, mynumbers1 + 4 ); //line i
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4 );
merge (mynumbers1, mynumbers1 + 2, mynumbers2, mynumbers2 + 2, v1.begin
()); //line ii
for_each (v1.begin (), v1.end (), printer);

return 0;
}

6, the program outputs 0,

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <int> v1 (mynumbers, mynumbers + 7 ); //line i
cout <<*min_element (v1.begin (), v1.end ()) <<", "; //line ii
 return 0;
}

7, the program outputs 9

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <int> v1 (mynumbers, mynumbers + 7 ); //line i
cout <<*max_element (v1.begin (), v1.end ()) <<", "; //line ii

return 0;
}

8, the program outputs 0,1,2,3,4,5,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
bool operator < (const int & _Right) const
{
return value < _Right;
}
operator int () const
{
return value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}
void printer (Pocket i)
{
cout << i <<", ";
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
set_union (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3, v1.begin
()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;
}

9, the program outputs 0,1,2,3,4,5,0,

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <int> v1 (7);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
merge (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3, v1.begin
()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;
}

10, the program outputs 0,2,3,

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}
void printer (Pocket i)
{
cout << i <<", ";
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
sort (mynumbers1, mynumbers1 + 4); //line i
vector <Pocket> v1 (mynumbers1, mynumbers1 + 3);
inplace_merge (v1.begin (), v1.begin () + 3, v1.end ()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;
}

11, the program outputs 0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
sort (mynumbers1, mynumbers1 + 4);
sort (mynumbers2, mynumbers2 + 4);
deque < int > d1 (mynumbers1, mynumbers1 + 3); //line i
set < int > s1 (mynumbers2, mynumbers2 + 3); //line ii
 sort (d1.begin (), d1.end());
cout << includes (s1.begin (), s1.end (), mynumbers1,
mynumbers1 + 4) <<", " << includes (d1.begin (),
d1.end (),
mynumbers1,
mynumbers1 + 4) <<endl;
return 0;
}

12, the program outputs 0,1,3,4,5,6,9

you shouldn't call inplace_merge

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>
using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket &_Right) const
{
return value < _Right.value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}
void printer (Pocket i)
{
cout << i <<", ";
}

int main ()
{
Pocket mynumbers1 [] = {3,9,0,2};
Pocket mynumbers2 [] = {6,1,4,5};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
copy (mynumbers1, mynumbers1 + 4, v1.begin ());
copy (mynumbers2, mynumbers2 + 4, v1.begin () + 3);
sort (v1.begin (), v1.begin () + 5); //line i
inplace_merge (v1.begin (), v1.begin () + 5, v1.end ()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;
}

13, the program outputs 0,1,3,4,0,0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>
using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
bool operator < (const int & _Right) const
{
return value < _Right;
}
operator int () const
{
return value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}
void printer (Pocket i)
{
cout << i <<", ";
}

int main ()
{
Pocket mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,2};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
set_symmetric_difference (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 +
3, v1.begin ()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;

}
14, the program outputs 0,1,2,3,4,5,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main ()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <int> v1 (7);
sort (mynumbers2, mynumbers2 + 4); //line i
sort (mynumbers1, mynumbers1 + 4);
set_union (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3, v1.begin
()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;

15, the program outputs 0,1,2,3,4,5,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main ()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <int> v1 (7);
sort (mynumbers2, mynumbers2 + 4); //line i
sort (mynumbers1, mynumbers1 + 4);
set_union (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3, v1.begin
()); //line ii
for_each (v1.begin (), v1.end (), printer);
return 0;

}
16, the program outputs 2,0,0,0,0,0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
bool operator < (const int & _Right) const
{
return value < _Right;
}
operator int () const
{
return value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}

void printer (Pocket i)

{
cout << i <<", ";
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,2};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
set_intersection (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3,
v1.begin ()); //line ii
for_each (v1.begin (), v1.end (), printer) ;
return 0;
}
17, the program outputs 0,3,0,0,0,0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
bool operator < (const int & _Right) const
{
return value < _Right;
}
operator int () const
{
return value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}

void printer (Pocket i)

{
cout << i <<", ";
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,2};
vector <Pocket> v1 (7,0);
sort (mynumbers2, mynumbers2 + 4);
sort (mynumbers1, mynumbers1 + 4); //line i
set_difference (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 3,
v1.begin ()); //line ii
for_each (v1.begin (), v1.end (), printer) ;
return 0;
}
18, the program outputs 1,1

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

class Pocket
{
int value;;

public:
Pocket (int value): value (value)
{ }
int getValue ()const
{
return value;
}
bool operator < (const Pocket & _Right) const
{
return value < _Right.value;
}
};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}

int main()
{
Pocket mynumbers1 [] = {3,9,0,2,1,4,5};
Pocket mynumbers2 [] = {Pocket (3), Pocket (2), Pocket (4), Pocket (1) };
deque <Pocket> d1 (mynumbers1, mynumbers1 + 7);
set <Pocket> s1 (mynumbers1, mynumbers1 + 7);
sort (d1.begin (), d1.end());
sort (mynumbers1, mynumbers1 + 5);
sort (mynumbers2, mynumbers2 + 4);
cout << includes (d1.begin (), d1.end (), mynumbers1, mynumbers1 + 4) <<",
" //line i
<< includes (s1.begin (), s1.end (), mynumbers2, mynumbers2 + 3) //line ii
<<endl;
return 0;
}

19, the program outputs 0,1,3,4,9

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

void printer (int i)
{
cout << i <<", ";
}

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <int> v1 (5);
sort (mynumbers2, mynumbers2 + 3);
sort (mynumbers1, mynumbers1 + 3);
set_symmetric_difference (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 +
2, v1.begin ()); //line i
for_each (v1.begin (), v1.end (), printer);

return 0;
}

20, the program outputs 0,3,9,0,0,0,0

#include <iostream>
#include <algorithm>
#include <deque>
#include <set>
#include <vector>

using namespace std;

void printer (int i)

{
cout << i <<", ";
}

int main()
{
int mynumbers1 [] = {3,9,0,2};
int mynumbers2 [] = {6,1,4,5};
vector <int> v1 (7);
sort (mynumbers2, mynumbers2 + 3);
sort (mynumbers1, mynumbers1 + 3);
set_difference (mynumbers1, mynumbers1 + 3, mynumbers2, mynumbers2 + 2,
v1.begin ()); //line i
for_each (v1.begin (), v1.end (), printer);

return 0;
}