1. Create C++ minimize member function for a dynamic sequence container that is implemented using an array. Member variables include the array itself, the size of the array and the current number of items stored in the array. The function should insure that there is no dynamic memory being wasted by empty array elements.
2. Write a function implementation that overloads the == operator of a dynamic array sequence (sequence2) container class to test if two object have the same data sets. The sequence class is similar to the bag, except that the order of the items should not be modified.
3. Write efficient member functions for the following operations (include documentation):
   • delete the first element from a dynamic array.
   • delete the last element from a dynamic array.
4. Implement the following function. Make sure you have no memory leaks.

5. //Precondition: olda is a dynamic array
6. //Postcondition: The array at olda is replaced with a new array that contains
7. //ONLY the EVEN indexed values in its most minimal usage of memory. For
8. //example, index's 0,2,4, and so on will exist in the new array and 1 and 3
9. //will be discarded. The new array will be about half the size of original.
10. //The number of items removed from the array is returned.

size_t reduceEven(double*& olda, const size_t& size);

11. Implement the following function. Make sure you have no memory leaks.

12. //Precondition: array points to dynamic array of char with a physical size // of count.
13. //Postcondition: appends a copy of the string passed as a parameter,
14. // into the back of the array. count is updated with the new physical // size of the array.

void append(char*& array, size_t& count, const string& s);

15. What is the big O of the following code snippet in terms of n when n > 0? Note: there is not a worst or best case for this code. Show evaluations of a few ns to loosely prove your answer for full credit.

16. for ( size_t i=n - 1 ; i > 0 ; --i)
17. for ( size_t j=0 ; j < n ; ++j)

//work here of constant time

18. Implement the following function. Make sure you have no memory leaks.

19. //Precondition: data points to an array of count items, or null when
20. // count is 0.
21. //Postcondition: All indexes where the data is odd will be removed
22. // from the array. The physical size of the array is reduced and
23. // data pointer is updated. The new size of the array is returned.
24. // No memory leaks.

size_t removeOdds(int*& data, size_t count);

25. Overload the << operator on the bag2 class, assuming the value_type is string, we should get the following. Make sure you have no memory leaks.

26. bag b;
27. b.insert(string1);
28. b.insert(string2);
29. b.insert(string3);

cout << b;

Would output:

[string1, string2, string3]