Scribd
Upload
29 views

Module 5

The document contains 12 code snippets with different sorting, searching and output operations on containers like vector, deque. The summaries are: 1. The code sorts a deque containing integers in descending order, finds the equal range for element 3 and outputs 3,3. 2. The code defines a Pocket class, sorts a deque of Pockets in descending order, finds an element greater than 3 and outputs the remaining elements. 3. The code removes elements from a vector, sorts in ascending order and outputs the elements. 4. The code sorts a deque of integers in ascending order, finds the equal range for element 1 and outputs 1,1. 5. The code searches sorted containers

Uploaded by

antonio luis tatel
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
29 views

Module 5

The document contains 12 code snippets with different sorting, searching and output operations on containers like vector, deque. The summaries are: 1. The code sorts a deque containing integers in descending order, finds the equal range for element 3 and outputs 3,3. 2. The code defines a Pocket class, sorts a deque of Pockets in descending order, finds an element greater than 3 and outputs the remaining elements. 3. The code removes elements from a vector, sorts in ascending order and outputs the elements. 4. The code sorts a deque of integers in ascending order, finds the equal range for element 1 and outputs 1,1. 5. The code searches sorted containers

Uploaded by

antonio luis tatel
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 14

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

You might also like