Question

100n Run the attached program with the given values for N and R and record your results in the TT and T columns. The remaining fields should be calculated based on your results from the T and N columns. Program: permute.zip R I T T T/ N T /(N log N) T/N T/(N? log N) T/N 100 100 100 1000 100 10000 500 100 500 1000 500 10000 1000 100 1000 1000 1000 10000 10000 100 10000 1000 10000 10000 To run the program, use the following command with the corresponding values for N and R: time /pdriver NR This will provide output that looks like 3.36 0.075 0:05.43 63.2% The first 2 numbers are the important numbers. These are the user and system time spent executing the program. Together, they make up the total CPU time spent executing. Sum them together to get your value for TT. Tis computed by dividing TT by R. Fill in the table and select which column is most consistent. O A. B. Nlog(N) I OD. Nalog(N) 12

permute zip contains:

makefile:

DIR=${PWD}
ASST=$(notdir ${DIR})
MAINPROG=pdriver
ifneq (,$(findstring MinGW,$(PATH)))
DISTR=MinGW
EXE=.exe
LFLAGS=
else
DISTR=Unix
EXE=
LFLAGS=
endif
#
########################################################################
# Macro definitions for "standard" C and C++ compilations
#
CPPFLAGS=-g -D$(DISTR)
CFLAGS=-g
TARGET=$(MAINPROG)$(EXE)
CPPS=pdriver.cpp permute.cpp
LINK=g++ $(CPPFLAGS)
#
CC=gcc
CXX=g++
#
#
# In most cases, you should not change anything below this line.
#
# The following is "boilerplate" to set up the standard compilation
# commands:
#

OBJS=$(CPPS:%.cpp=%.o)
DEPENDENCIES = $(CPPS:%.cpp=%.d)

%.d: %.cpp
   touch $@

%.o: %.cpp
   $(CXX) $(CPPFLAGS) -MMD -o $@ -c $*.cpp

#
# Targets:
#
all: $(TARGET)

$(TARGET): $(OBJS)
   $(LINK) $(FLAGS) -o $(TARGET) $(OBJS) $(LFLAGS)

clean:
   -/bin/rm -f *.d *.o $(TARGET)

make.dep: $(DEPENDENCIES)
   -cat $(DEPENDENCIES) > $@

include make.dep

pdriver.cpp:

#include 
#include 
#include 
#include 

using namespace std;

void permute (int[], int);


int main(int argc, char** argv)
{
  if (argc != 3)
    {
      cerr << "When you run this program, you must supply two parameters.\n" 
           << "The first is the size of the array you want to permute.\n"
           << "The second is the number of trials you want to perform.\n"
           << "\n"
           << "For example, if you called this program pdriver, you\n"
           << "might invoke it as:\n"
           << "   pdriver 100 10 \n"
           << "to generate 10 random permutations of 100 elements each."
        << endl;
      return 1;
    }

  int N;
  int trials;

  {
    istringstream arg1 (argv[1]);
    arg1 >> N;

    istringstream arg2 (argv[2]);
    arg2 >> trials;
  }
  
  int *array = new int[N];

  srand(time(0));
  for (int t = 0; t < trials; t++)
    {
      permute (array, N);
      // for (int i = 0; i < N; ++i) cout << array[i] << ' '; cout << endl;
    }

  return 0;
}

permute.cpp:

#include 
#include 
#include 

using namespace std;

unsigned rnd(unsigned limit)
{
  return rand() % limit;
}

//  Generate a random permutation of the integers from
//  0 .. n-1, storing the results in array a.
//
void permute (int a[], int n)
{
  for (int i = 0; i < n; i++)
    {
      // Guess at a value to put into a[i]
      int guess = rnd(n);
      while (find(a, a+i, guess) != a+i)
        {
    // If it's one that we've already used, guess again.
         guess = rnd(n);
        }
      a[i] = guess;
    }
}

Answer 1

So to complete the above problem, we need to find the time complexity of the permute function.

void permute (int a[], int n)
{
  for (int i = 0; i < n; i++)        //n times
    {
      // Guess at a value to put into a[i]
      int guess = rnd(n);           // Constant
      while (find(a, a+i, guess) != a+i) // Each find request will be proportional to n and finding the guess number which is not present will be of n complexity. So we will have n2 complexity here.
        {
    // If it's one that we've already used, guess again.
         guess = rnd(n);
        }
      a[i] = guess;
    }
}

So in total, the time complexity would be O(n³), Thus We can say that it would be proportional to $\tfrac{T}{n^{3}}$

So the solution is: Option E

Thanks: