deque <int> d1 (mynumbers, mynumbers + 7);

deque <Pocket> d1 (mynumber, mynumbers + 7);

vector <Pocket> v1 (mynumbers, mynumbers + 7);
set <Pocket> s1 (mynumbers, mynumbers + 7);
deque <Pocket> =:: iterator it=lower_bound (d1.begin(), d1.end (), 3, greater
<Pocket> ())
for_each (it,d1.end(), printer);

1, the program outputs 3,3

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

void printer (int i)

{
cout << i <<", ";
}
int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <int> d1 (mynumbers, mynumbers + 7);
d1.push_back(3); //line i
sort (d1.begin (), d1.end());
pair <deque <int>::iterator, deque <int> ::iterator > result = equal_range
(d1.begin(), d1.end (), 3);
for_each (result.first, result.second, printer);

return 0;
}

2, the program outputs 4,5,6,9

#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;
}

void printer (Pocket i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
sort (d1.begin (), d1.end(), greater <Pocket> ());
deque <Pocket>:: iterator it=lower_bound (d1.begin(), d1.end (), 3, greater
<Pocket> ());
for_each (it, d1.end(), printer);

return 0;
}

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

the size of v1 is 6
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void printer (int i)

{
cout << i <<", ";
}
bool
Compare (int _Left, int _Right)
{
return _Left <_Right;
}
int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <int> v1 (mynumbers, mynumbers + 7);
remove (v1.begin (), v1.end(),1 ); //line I
sort (v1.begin (), v1.end(), Compare); //line II
for_each (v1.begin (), v1.end(), printer);

return 0;
}

4, 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;
}

void printer (Pocket i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
sort (d1.begin (), d1.end());
set <Pocket> s1 (mynumbers, mynumbers + 7);
cout << binary_search (s1.begin(), s1.end (),Pocket (3)) <<", "
<< binary_search (d1.begin(), d1.end (),Pocket (5)) <<endl;

return 0;
}

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

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

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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
sort (d1.begin (), d1.end(), greater <Pocket> ()); //line i
deque < Pocket > ::iterator it = lower_bound (d1.begin(), d1.end (), 3,
greater <Pocket> ());
for_each (it, d1.end(), printer);

return 0;
}

6, the program outputs 4

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

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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
d1.push_back(3);
sort (d1.begin (), d1.end()); //line i
pair <deque <Pocket>::iterator, deque <Pocket> ::iterator > result =
equal_range (d1.begin(), d1.end (),Pocket (4));
for_each (result.first, result.second, printer);

return 0;
}
7. the program outputs yyY, Yyy, yyy, yYy, zzz, zzZ, Zzz, zZz
#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <functional>
#include <string>
#include <ctype.h>

using namespace std;

template <typename T> class Pocket
{
T value;

public:

Pocket (T value):value (value)

{
}
T getValue () const
{
return value;
}
bool operator < (const Pocket &_Right) const
{
return value <_Right.value;
}
};
template < typename T >
ostream & operator << (ostream & stream, const Pocket <T> & pocket)
{
stream << pocket.getValue ();
return stream;
}

void printer (Pocket <string> i)

{
cout << i <<", ";
}
 string tolower (const string & s)
{
string tmp (s);
for (unsigned i=0; i < tmp.size(); i++)
{
tmp[i] = tolower (tmp[i]);
}
return tmp;
}
bool Compare (const Pocket < string > &_Left, const Pocket <string> &_Right)
{
return tolower (_Left.getValue ()) < tolower (_Right.getValue());
}

int main()
{
string t [] = {"zzz","zzZ","yyY","Zzz","Yyy","zZz","yyy","yYy"}; //line i
vector < Pocket <string> > v1;
v1.assign (t,t + 8); //line ii

stable_sort (v1.begin (), v1.end(), Compare);

for_each (v1.begin (), v1.end(), printer);

return 0;
}
8, the program outputs 0.22, 1.14, 3.33, 4.45, 5.55, 9.19, 9.19
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

void printer (double i)

{
cout << i <<", ";
}
bool
Compare (double a, double b)
{
return int (a) < int (b);
}
int main()
{
double mynumbers [] = {3.33,9.19,0.22,2.12,1.14,4.45,5.55};
vector <double> v1 (mynumbers, mynumbers + 7);
stable_sort (v1.begin (), v1.end(), Compare); //line I
remove (v1.begin (), v1.end(), 2.12 ); //line Ii
for_each (v1.begin (), v1.end(), printer);

return 0;
}
9, the program outputs 3,3
#include <vector>
#include <iostream>
#include <deque>
#include <algorithm>
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 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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
d1.push_back(3);
sort (d1.begin (), d1.end(), greater <Pocket> ()); //line i
pair <deque <Pocket>::iterator, deque <Pocket> ::iterator > result =
equal_range (d1.begin(), d1.end (),Pocket (3), greater <Pocket> ()); //line ii
for_each (result.first, result.second, printer);

return 0;
}
10, the program outputs 0,1,2,3,4,5,9
#include <vector>
#include <iostream>
#include <deque>
#include <algorithm>
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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <Pocket> v1 (mynumbers, mynumbers + 7);
sort (v1.begin (), v1.end(), greater <Pocket> ()); //line i
for_each (v1.begin (), v1.end(), printer); //line ii

return 0;
}
11, the program outputs 9,5,4,3,2,1,0
#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <functional>
#include <string>
#include <ctype.h>

using namespace std;

void printer (int i)

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

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

return 0;
}
12, the program outputs 3,
 #include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <functional>
#include <string>
#include <ctype.h>

using namespace std;

void printer (int i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <int> d1 (mynumbers, mynumbers + 7);
sort (d1.begin (), d1.end());
d1.push_back(3); //line i
pair <deque <int>::iterator, deque <int> ::iterator > result = equal_range
(d1.begin(), d1.end (), 3);
for_each (result.first, result.second, printer);

return 0;
}
13, compilation error at line II / 1
#include <vector>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
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 Pocket & _Right) const
{
return _Right < value;
}
//line i

};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}

void printer (Pocket i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <int> d1 (mynumbers, mynumbers + 7);
sort (d1.begin (), d1.end());
deque <Pocket>:: iterator it = upper_bound (d1.begin(), d1.end (), Pocket
(5), greater <Pocket> ()); //line ii
for_each (it, d1.end(), printer);

return 0;
}
14, compilation error in line II/ 1

15, the program outputs 4,5,6,9

#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <functional>
#include <string>
#include <ctype.h>

using namespace std;

void printer (int i)

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

int main()
{
int mynumbers [] = {0,1,2,3,4,5,6};
deque <int> d1 (mynumbers, mynumbers + 7);
d1.push_back(9); //line i
deque <int>::iterator it = lower_bound (d1.begin(), d1.end (), 4);
for_each (it, d1.end (), printer); //line 2

return 0;
}
16, the program outputs 3,3,
#include <vector>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>
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;
}
//line i

};
ostream & operator << (ostream & stream, const Pocket & pocket)
{
stream << pocket.getValue ();
return stream;
}

void printer (Pocket i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <Pocket> d1 (mynumbers, mynumbers + 7);
d1.push_back(3); //line i
sort (d1.begin (), d1.end()); //line i
pair <deque <Pocket>::iterator, deque <Pocket> ::iterator > result =
equal_range (d1.begin(), d1.end (), Pocket (3)); //line 2
for_each (result.first, result.second, printer); //line ii

return 0;
}
17, the program outputs 1,0
#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
#include <set>
#include <functional>
#include <string>
#include <ctype.h>

using namespace std;

void printer (int i)

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

int main()
{
int mynumbers [] = {3,9,0,2,1,4,5};
deque <int> d1 (mynumbers, mynumbers + 7);
set <int> s1 (mynumbers, mynumbers + 7);
cout << binary_search (s1.begin(), s1.end (),1) <<", "
<< binary_search (d1.begin(), d1.end (),6) <<endl;

return 0;
}
18, compilation error in line ii
#include <vector>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>
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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <Pocket> v1 (mynumbers, mynumbers + 7);
sort (v1.begin (), v1.end()); //line i
remove (v1.begin (), v1.end(), 2); //line ii
 for_each (v1.begin (), v1.end (), printer);

return 0;
}
19, compilation error in line ii
#include <vector>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>
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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <Pocket> s1 (mynumbers, mynumbers + 7); //line i
sort (s1.begin (), s1.end(), greater <Pocket> ()); //line 2
for_each (s1.begin (), s1.end (), printer);

return 0;
}
20, the program outputs 0,1,2,3,4,5,9
#include <vector>
#include <deque>
#include <iostream>
#include <deque>
#include <algorithm>
#include <functional>
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()
{
int mynumbers [] = {3,9,0,2,1,4,5};
vector <Pocket> s1 (mynumbers, mynumbers + 7); //line i
sort (s1.begin (), s1.end(), greater <Pocket> ()); //line 2
for_each (s1.begin (), s1.end (), printer);

return 0;
}