Question

Someone once said, "if you gave everyone in the world a million dollars and if you waited long enough then 1 person would have all the money and everyone else would have nothing". You are going to write a program to test truthfullness of that statement.

1. Declare an N element integer array where N equals 10. Name the array assets.
2. Assign M to each element of the array assets where M equals 100.
3. Assign N to nActive, the number of array elements greater than 0.

Repeat the following actions until nActive equals 1:

1. Generate 2 distinct random numbers, idx1 and idx2, between 0 and nActive –
2. Generate 1 random number, facevalue, between 0 and 1.
3. if facevalue equals 0 then transfer 1 from the smaller of the two array elements at idx1 and idx2 to the larger of the two array elements at idx1 and idx2. (transfer means subtract 1 from one array element and add 1 to the other array element)
4. if facevalue equals 1 then transfer 1 from the larger of the two array elements at idx1 and idx2 to the smaller of the two array elements at idx1 and idx2.
5. After transfering 1 between the two array elements at idx1 and idx2, one of the array elements at idx1 and idx2 may equal 0. When this occurs subtract 1 from nActive, the number of non-zero array elements and make sure that the program does not select this zero-value array element again. The easiest way to prevent the program's selecting the zero-value array element is to exchange the zero-value array elemement at idx1 or idx2 with the last non-zero array element. When the program starts the last non-zero array element is at nActive – 1.

   

using this code

#include "fixed1dintarray.h"

fixed1dintarray::fixed1dintarray(int newnelts)

{

    if (newnelts < 2)

        newnelts = 16;

    size = newnelts;

    nelts = 0;

    elts = new int[size];

}

bool fixed1dintarray::isEmpty()

{

    return nelts == 0;

}

bool fixed1dintarray::isFull()

{

    return nelts == size;

}

int fixed1dintarray::getsize()

{

    return size;

}

int fixed1dintarray::getnelts()

{

    return nelts;

}

bool fixed1dintarray::getelt(int where, int& elt)

{

    bool isgood = 0 <= where && where < nelts;

    if (isgood)

        elt = elts[where];

    return isgood;

}

bool fixed1dintarray::member(int value)

{

    return find(value) >= 0;

}

int fixed1dintarray::find(int value)

{

    int pos = 0;

    //while(!(pos < nelts || elts[pos] == value))

    //until(pos == nelts || elts[pos] == value)

    while (pos < nelts && elts[pos] != value)

        pos++;

    if (pos < nelts)

        return pos;

    else

        return -1;

}

bool fixed1dintarray::insat(int where, int elt)

{

    if (isFull())

        return false;

    if (where < 0 || nelts < where)

        return false;

    for (int pos = nelts - 1; pos >= where; pos--)

        elts[pos + 1] = elts[pos];

    elts[where] = elt;

    nelts++;

    return true;

}

bool fixed1dintarray::append(int elt)

{

    return insat(nelts, elt);

}

bool fixed1dintarray::delat(int where)

{

    if (where < 0 || nelts <= where)

        return false;

    for (int pos = where + 1; pos < nelts; pos++)

        elts[pos - 1] = elts[pos];

    return false;

}

bool fixed1dintarray::delelt(int elt)

{

    int where = find(elt);

    return delat(where);

}

void fixed1dintarray::show()

{

    for (int i = 0; i < nelts; i++)

        cout << elts[i] << ' ';

}

Answer 1

PROGRAM :

#include<iostream>
#include <cstdlib>
using namespace std;

int main()
{
int assets[10];
int nActive=10;
int idx1,idx2,facevalue,transfer=0,threshold=1000000000;
for(int i=0;i<nActive;i++)
assets[nActive]=100;
while(nActive>1)
{
idx1= (rand() % nActive);
idx2= (rand() % nActive);
if(idx1!=idx2)
{
facevalue= (rand() % 2);
if(facevalue==0)
{
if(idx1<idx2)
{
assets[idx1]--;
assets[idx2]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx1]==0)
{
assets[idx1]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
else
{
assets[idx2]--;
assets[idx1]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx2]==0)
{
assets[idx2]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
}
else
{
if(idx1>idx2)
{
assets[idx1]--;
assets[idx2]++;
transfer++;

if(transfer>threshold)
break;
if(assets[idx1]==0)
{
assets[idx1]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
else
{
assets[idx2]--;
assets[idx1]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx2]==0)
{
assets[idx2]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
}
}
}
if(transfer>threshold)
cout<<"Even after 1 Billion transfers,"<< nActive<<"persons have non-zero dollars. So statement is not correct"<<endl;
else
cout<<"The statement is correct"<<endl;
return 0;

}

The same program with class can be rewritten as follow.

#include<iostream>
#include <cstdlib>
using namespace std;
class Test
{
public:
static void check()
{
int assets[10];
int nActive=10;
int idx1,idx2,facevalue,transfer=0,threshold=1000000000;
for(int i=0;i<nActive;i++)
assets[nActive]=100;
while(nActive>1)
{
idx1= (rand() % nActive);
idx2= (rand() % nActive);
if(idx1!=idx2)
{
facevalue= (rand() % 2);
if(facevalue==0)
{
if(idx1<idx2)
{
assets[idx1]--;
assets[idx2]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx1]==0)
{
assets[idx1]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
else
{
assets[idx2]--;
assets[idx1]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx2]==0)
{
assets[idx2]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
}
else
{
if(idx1>idx2)
{
assets[idx1]--;
assets[idx2]++;
transfer++;

if(transfer>threshold)
break;
if(assets[idx1]==0)
{
assets[idx1]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
else
{
assets[idx2]--;
assets[idx1]++;
transfer++;
if(transfer>threshold)
break;
if(assets[idx2]==0)
{
assets[idx2]=assets[nActive-1];
assets[nActive-1]=0;
nActive--;
  
}
}
}
}
}
if(transfer>threshold)
cout<<"Even after 1 Billion transfers,"<< nActive<<"persons have non-zero dollars. So statement is not correct"<<endl;
else
cout<<"The statement is correct"<<endl;
}
};

int main()
{
Test::check();
return 0;

}