Question

This question has been answered before, but no codes given as the answer were right. please help.

In the mathematical theory of sets, a set is defined as a collection of distinct items of the same type. In some programming languages, sets are built-in data types; unfortunately, this is not the case in C++. However, we can simulate a set using a one-dimensional array.

Some operations can be performed on sets. We will consider three(3) of them: union, intersection and difference. These are binary operations requiring two sets as operands. The union of two sets, A and B, is a set that contains all elements in both A and B. The intersection of two sets, A and B, is a set that contains elements common to both A and B. The difference of two sets, A and B, is a set that contains only the elements in A but not in B and excluding the common elements in A and B.  

For example, if A and B are two sets of integers defined as A = {5, 7, 8, 10} and B = {3, 9, 10}, then their union is the set {3, 5, 7, 8, 9, 10}, their intersection is the set {10}, their difference of A and B ( A - B) is the set {5, 7, 8}.  

Write a program that computes the union, intersection, and difference of two sets stored in two one-dimensional arrays. Populate the arrays from the following input files:  

inputA.dat

0 1 -3 5 -11 6 8 9 11 17 15 7 4 12

inputB.dat

0 -1 3 7 -6 16 5 11 12 4 21 13

The output should be displayed on screen and in an output file.  Prompt user for file names. No duplicates are allowed in union, intersection or difference.

The following functions must be used:

void readfile_array(ifstream& a, ifstream& b, int arraya[], int& asize, int arrayb[], int& bsize);

void printarray(int array[], int size, ofstream& o);

int diff (int a[], int b[], int dif[], int asize, int bsize);

int duplicates (int array[], int d[], int size);

int intersection (int a[], int b[], int asize, int bsize, int inter[]);

int arrayunion (int a[], int b[], int asize, int bsize, int aunions[]);

void sort (int array[], int n);  

SAMPLE OUTPUT:

Enter filenames=>inputA.dat

inputB.dat

out.dat

Array Elements in File A

0 1 -3 5 -11 6 8 9 11 17 15 7 4 12

Array Elements in File B

0 -1 3 7 -6 16 5 11 12 4 21 13

Sorted ArrayA

-11 -3 0 1 4 5 6 7 8 9 11 12 15 17

Sorted ArrayB

-6 -1 0 3 4 5 7 11 12 13 16 21

Difference from ArrayA and ArrayB

-11 -3 1 6 8 9 15 17

Number of elements in intersection = 6

0 4 5 7 11 12

Number of elements in union = 26

-6 -1 0 3 4 5 7 11 12 13 16 21 -11 -3 0 1 4 5 6 7 8 9 11 12 15 17

Sorted intersection

0 4 5 7 11 12

Sorted union

-11 -6 -3 -1 0 0 1 3 4 4 5 5 6 7 7 8 9 11 11 12 12 13 15 16 17 21

The Intersection of A and B (no duplicates)

0 4 5 7 11 12

The Union of A and B(no duplicates)

-11 -6 -3 -1 0 1 3 4 5 6 7 8 9 11 12 13 15 16 17 21

Answer 1

#include<iostream>
#include<conio.h>
#include<fstream>
#include<algorithm>
using namespace std;

int countArray(string& file_name)
{   fstream myfile(file_name.c_str(), std::ios_base::in);
   int iter;
   int count=0;
while (myfile >> iter)
{
       count++;
}
   myfile.close();
   return count;
}
int diff(int a[], int b[], int dif[], int asize, int bsize)
{
   int diffCount = 0;
   for(int i =0;i<asize;i++)
   {
       int flag = 0;
       for(int j=0;j<bsize;j++)
       {
           if(a[i] == b[j])
           {
               flag = 1;
           }  
       }
       if(flag == 0)
       {
           dif[diffCount] = a[i];
           diffCount++;
       }  
   }
   return diffCount;
}
int intersection (int a[], int b[], int asize, int bsize, int inter[])
{
   int tempValue = 0;
   int interCount = 0;
   for(int i =0;i<asize;i++)
   {
       int flag = 0;
       for(int j=0;j<bsize;j++)
       {
           if(a[i] == b[j])
           {
               flag = 1;
               tempValue = b[j];
           }  
       }
       if(flag == 1)
       {
           inter[interCount] = tempValue;
           interCount++;
       }  
   }
   return interCount;
}
void readfile_array(fstream& a, fstream& b, int arraya[], int& asize, int arrayb[], int& bsize)
{
int iter1;
   int countA=0;
while (a >> iter1)
{
       arraya[countA] = iter1;
       countA++;
}
   a.close();

int iter2;
   int countB=0;
while (b >> iter2)
{
       arrayb[countB] = iter2;
       countB++;
}
   b.close();
}
void printarray(int array[], int size, ofstream& o)
{
   if(o)
   {
           for(int i = 0;i<size;i++)
           {
               o << array[i];
               o << " ";
           }  
   }  
}
void sort (int array[], int n)
{
   int temp;
for(int i=0;i<n;i++)
   {
       for(int j=0;j<n;j++)
       {
           if(array[j]>array[j+1])
           {
               temp=array[j];
               array[j]=array[j+1];
               array[j+1]=temp;
           }
       }
   }
}
bool duplicates(int array[],int size,int n){
   int i;
   for(i=0;i<size;i++){
   if(array[i]==n)
return true;         
   }
   return false;
}

int arrayunion (int a[], int b[], int asize, int bsize, int aunions[])
{  
   int unionCount =0;
int i;
   for(int k=0;k<asize;k++)
   {
       aunions[k]=a[k];
       unionCount++;
   }
   int bIndex = 0;
   for(int k=asize;k<asize+bsize;k++)
   {
       if(!(duplicates(a,asize,b[bIndex])))
       {  
           aunions[k] =b[bIndex];
           bIndex++;
           unionCount++;
       }
   }
   return unionCount;
}
int arrayunionwithduplicates (int a[], int b[], int asize, int bsize, int aunions[])
{  
int i,unionCount=0;
   for(int k=0;k<asize;k++)
   {
       aunions[k]=a[k];
       unionCount++;
   }
   int bIndex = 0;
   for(int k=asize;k<asize+bsize;k++)
   {  
           aunions[k] =b[bIndex];
           bIndex++;
   }
}
int main()
{
cout<<"\n\n\t\tSET OPERATIONS\n\n";
string inputFileNameA = "inputA.dat";
string inputFileNameB = "inputB.dat";
string outputFileName = "out.data";
int arrayASize = countArray(inputFileNameA);
int arrayBSize = countArray(inputFileNameB);
int A[arrayASize];
int B[arrayBSize];
int dif[arrayASize];
int inter[arrayASize];
int aunionswithduplicates[arrayASize+arrayBSize];
int aunions[arrayASize+arrayBSize];
fstream myfile1(inputFileNameA.c_str(), std::ios_base::in);
fstream myfile2(inputFileNameB.c_str(), std::ios_base::in);
readfile_array(myfile1,myfile2,A,arrayASize,B,arrayBSize);
ofstream f(outputFileName.c_str());

f <<"\nArray Elements in File A:\n ";
printarray(A,arrayASize,f);

f << "\nArray Elements in File B:\n ";
printarray(B,arrayBSize,f);

f << "\n Sorted ArrayA\n";
sort(A,arrayASize);
printarray(A,arrayASize,f);

f << "\n Sorted ArrayB\n";
sort(B,arrayBSize);
printarray(B,arrayBSize,f);

f << "\n Difference from ArrayA and ArrayB\n";
int difCount = diff(A,B,dif,arrayASize,arrayBSize);
printarray(dif,difCount,f);

int interCount = intersection(A,B,arrayASize,arrayBSize,inter);
f << "\n Number of elements in intersection: "<<interCount<< "\n";
printarray(inter,interCount,f);

arrayunionwithduplicates(A,B,arrayASize,arrayBSize,aunionswithduplicates);
f << "\n Number of elements in Union: "<<arrayASize+arrayBSize<< "\n";
printarray(aunionswithduplicates,arrayASize+arrayBSize,f);

f << "\n Sorted Intersection \n";
sort(inter,interCount);
printarray(inter,interCount,f);

f << "\n Sorted Union \n";
sort(aunionswithduplicates,arrayASize+arrayBSize);
printarray(aunionswithduplicates,arrayASize+arrayBSize,f);

intersection(A,B,arrayASize,arrayBSize,inter);
f << "\n The Intersection of A and B(no duplicates) \n";
printarray(inter,interCount,f);

int unionCount = arrayunion(A,B,arrayASize,arrayBSize,aunions);
f << "\n The Union of A and B(no duplicates) \n";
sort(aunions,unionCount);
printarray(aunions,unionCount,f);
return 0;
}