MTH 4300: Final Practice 2

• (a) The proposition is false.
• (b) The proposition true. The command declares X to be a pointer to an object of type Y and assigns the address of the first element of sequence of \(20\) consecutive objects of type Y
• (c) The proposition true. This is the simplest way of calling a method.
• (d) The proposition false because X is a pointer. A pointer does not have the method Z.
• (e) The proposition true because it declares X to be a pointer to a memory location that stores a pointer of type Y*. A new memory capable of storing an object of type Y* is allocated and the address is assigned to X.

Therefore, the correct answer is FTTFT.

We will have two variables min and max that store the maximum and minimum of all numbers provided by the user. If in the end the minimum and maximum are the same, then the program should print Yes. Otherwise, the program should print No.

#include<iostream>
int main(){ 
   long min,max,input;
   std::cin>>input;
   min=input;max=input;
   while(input > -1){
      if(input > max){max=input;}
      if(input < min){min=input;}
      std::cin>>input;
   }
   if(min==max){
      std::cout<<"yes\n";
   }
   else{
      std::cout<<"no\n";
   }
   return 0;
}

The sign is \(1\). The absolute value of the number is \(23.125\). We will first determine the binary expansion of \(23.125\). Notice that \(23.125=23+\frac18\). The binary expansion of \(23\) is \(23=\overline{10111}_2\). The binary expansion of \(\frac18\) is \(\frac18=\overline{0.001}_2\). Therefore \(23.125=\overline{10111.001}_2\) and the normalized floating point representation is \[23.125=\overline{10111.001}_2= \overline{1.0111001}_2\cdot2^{4}.\] The exponent shift is \(2^{6-1}-1=31\). Therefore, we need to store the number \(4+31=35\) in the \(6\) exponent bits. The binary expansion of \(35\) is \(35=\overline{100011}_2\). The mantissa is \(p= \overline{1.0111001}_2\). Since the number is normal (and not sub-normal), the first bit of mantissa will not be stored. Thus, the storage will look like this: \[\underbrace{1}_1\underbrace{100011}_6\underbrace{011100100}_9\]

The size of the memory leak is 716.

In the beginning of the main function the objects m and p are created using the default constructor. The copy assignment is applied to the object p with argument m. These operations result in allocation of \(12\) memory locations of type long.

In each of the \(50\) iterations of the for loop the following happens: The argument m of the function is passed by reference and the copy constructor is not called. The object n is created using copy constructor applied to the object m. The copy constructor creates a memory leak of size \(3\). When the function reaches the return statement it first creates a temporary object using the move constructor with argument n. The move constructor creates a memory leak of size \(4\). The local variable n is destroyed and its destructor creates a memory leak of size \(2\). The move assignment is called by the object p from the main program with the argument that is the temporary object. The move assignment creates memory leak of size \(3\). The destructor is used for the temporary object. Since the argument m of the function is passed by reference the destructor is not called. Therefore in each iteration of the for loop there are \(14\) memory leaks.

After the for loop the destructors are called for objects p and m. Each of the destructors causes a memory leak of size \(2\).

We will store all input values in a map whose keys are the elements of the sequence and values are their frequencies. In addition we will keep two variables mostCommonElement and maxOccurrences.

#include<iostream>
#include<map>
void addInputValue(std::map<std::string,long> & elements, std::string& mostCommonElement, long & maxOccurrences, std::string x){
   std::map<std::string,long>::iterator it;   
   it=elements.find(x);
   if(it!=elements.end()){
      ++(it->second);
      if(it->second > maxOccurrences){
         maxOccurrences=it->second;
         mostCommonElement=x;
      }
   }
   else{
      elements[x]=1;
      if(maxOccurrences < 1){
         maxOccurrences=1;
         mostCommonElement=x;
      }
   }
}
int main(){ 
   std::map<std::string,long> elements;
   std::string uI, mostCommonElement="unknown";
   long maxOccurrences=0;
   std::cin >> uI;
   while(uI != "end"){
      addInputValue(elements,mostCommonElement,maxOccurrences,uI);
      std::cin >> uI;
   }
   std::cout << mostCommonElement << "\n";
   return 0;
}

We will keep all prime factors of \(x_0\), \(x_1\), \(\dots\), \(x_{n-1}\) in two sets primes1 and primes2. The set primes1 will contain the primes that appear at least once. The set primes2 will contain the primes that appear at least twice. Once we receive a number from the input, we find all of its prime factors. For each prime factor \(p\) we first test whether it is in primes1. If it is, then we place it in primes2. If it is not, then we place it in primes1. In the end we count the number of elements in primes2.

#include<iostream>
#include "simple_set_and_map.cpp"
void addPrimeFactorsToSet(ssm::set<long> &primes1, ssm::set<long> &primes2,  long n){
   long p=2; 
   long k;
   while( p*p <= n ){
      if(n%p==0){
        // We are sure that p is prime. This is the reason:
        // If p were not prime, then it would have a prime factor q. 
        // q would be smaller than p. Since n is divisible by p, n must 
        // be divisible by q. However, we are sure that n is not divisible by q.
        // This while loop is always making n smaller and smaller. p is the 
        // smallest possible factor of n.
         if(primes1.find(p)!=-1){primes2.insert(p);}
         primes1.insert(p);
         k=0;
         while(n%p==0){ // If n is divisible by p^k, then p should be inserted only once, 
                                   // However, n should be divided by p^k
            n = n / p; 
            ++k;
         }
         if(k>1){primes2.insert(p);}
      }
      ++p;
      if(p > 3){++p;}
   }
   if(n > 1){ 
      if(primes1.find(n)!=-1){primes2.insert(n);}
      primes1.insert(n);
   }
}
int main(){
   long uI;
   ssm::set<long> primes1,primes2;
   std::cin >> uI;
   while(uI > 0){
      addPrimeFactorsToSet(primes1,primes2,uI);
      std::cin >> uI;
   }
   std::cout << primes2.size() << "\n";
   return 0;
}

We will store the data in a map mainData whose keys are strings and values are integers of type double. We will keep an additional variable multiplier of type double. Initially, the variable multiplier will be equal to \(1.0\). The content of the variable multiplier will be the real number such that the price of every item is calculated in the following way: If x is a name of the product, then the price will be

price = multiplier * mainData[x]

The inflation can now be executed by changing only the variable multiplier. The complexity of this operation will be just \(O(1)\). The entire code is given below.

#include<iostream>
#include "simple_set_and_map.cpp"
std::string mainMenu(){
  return "1. Insert\n2. Delete\n3. Search\n4. Inflation\n5. Print menu\n0. Exit\n";
}
int main(){
    ssm::map<std::string,double> mainData; 
    double multiplier=1.0;
    std::string x;
    double z,M; long i;
    std::string choice;
    std::cout << mainMenu();
    std::cout << ">> ";
    std::cin >> choice;
    while(choice!="0"){
      if(choice=="1"){
        std::cout << "Insert the name and the price of the product. ";
        std::cin >> x >> z;
        mainData.erase(x);
        mainData.insert(x,z/multiplier); 
      }
      if(choice=="2"){
        std::cout << "Insert the name of the product that needs to be deleted. ";
        std::cin >> x;
        mainData.erase(x);
      }
      if(choice=="3"){
        std::cout << "Insert the name of the product whose price you want to see. ";
        std::cin >> x;
        i=mainData.find(x);
        if(i!=-1){
          std::cout << "The price is " << (mainData[i].second) * multiplier << "\n";
        }
        else{
          std::cout << "The product does not exist.\n";
        }
      }
      if(choice=="4"){
        std::cout << "Insert the percentage by which you want to increase all prices. ";
        std::cin >> M;
        multiplier *= 1.0 + 0.01*M;
      }
      if(choice=="5"){
        std::cout<<mainMenu();
      }
      std::cout << ">> ";
      std::cin >> choice;
    }
    return 0;
}