Answer to Question #187742 in C++ for Asif Mujeeb

Question

: Overlapping rectangles – A rectangle is identified by its four coordinates, Make a structure to hold data for every rectangle, there is bare minimum information that 

you to store for each rectangle i.e. its coordinates. You can also improvise and make additional members 

in the structure if you think it will help in doing any of the following tasks. Write the following functions:

1. Generate n number of rectangles

2. Find and return the area of all the rectangles, given the rectangles in the above format 

3. Sort and return all rectangles in the ascending order based on their area. 

4. Find the set of rectangles that overlap the largest rectangle 

5. Write a function main (as a controller) to call the above functions in the correct order to identify 

the set of rectangles that overlap the largest rectangle

Answer 1

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


class Point{
   private:
       int x;
       int y;
   public:

       Point(){
           x=0;
           y=0;
       }

       Point(int _x,int _y){
           x=_x;
           y=_y;
       }

       void setX(int _x){
           x=_x;
       }
       int getX(){
           return x;
       }

       void setY(int _y){
           y=_y;
       }
       int getY(){
           return y;
       }

       void print(){
           cout<<"("<<x<<","<<y<<")";
       }
};

class Rectangle{
   private:
       Point *point1;
       Point *point2;
       Point *point3;
       Point *point4;
   public:

       Rectangle(){
           point1=NULL;
           point2=NULL;
           point3=NULL;
           point4=NULL;
       }


       void setPoint1(Point *p){
           point1=p;
       }

       void setPoint2(Point *p){
           point2=p;
       }

       void setPoint3(Point *p){
           point3=p;
       }

       void setPoint4(Point *p){
           point4=p;
       }



       Point* getPoint1(){
           return(point1);
       }

       Point* getPoint2(){
           return(point2);
       }

       Point* getPoint3(){
           return(point3);
       }

       Point* getPoint4(){
           return(point4);
       }

       double area(){
           double w=sqrt(pow(point1->getX()-point2->getX(),2)+pow(point1->getY()-point2->getY(),2));
           double l=sqrt(pow(point1->getX()-point4->getX(),2)+pow(point1->getY()-point4->getY(),2));

           return (w*l);
       }

       void print(){
           point1->print();
           cout<<" , ";
           point2->print();
           cout<<" , ";
           point3->print();
           cout<<" , ";
           point4->print();
           cout<<"\tArea is "<<area()<<endl;
       }
};


void generateRect(Rectangle *rect,int n){
   for(int i=0;i<n;i++){
       cout<<"Enter top point of rectangle "<<(i+1)<<" : ";
       int x;
       cin>>x;
       cout<<"Enter left point of rectangle "<<(i+1)<<" : ";
       int y;
       cin>>y;
       cout<<"Enter width of rectangle "<<(i+1)<<" : ";
       int w;
       cin>>w;
       cout<<"Enter length of rectangle "<<(i+1)<<" : ";
       int l;
       cin>>l;

       Point *point1=new Point(x,y);
       Point *point2=new Point(x+w,y);
       Point *point3=new Point(x+w,y+l);
       Point *point4=new Point(x,y+l);

       rect[i].setPoint1(point1);
       rect[i].setPoint2(point2);
       rect[i].setPoint3(point3);
       rect[i].setPoint4(point4);

       cout<<"Rectangle "<<(i+1)<<" created\n\n";
   }
}

void printAreaOfRectangle(Rectangle *rect,int n){
   for(int i=0;i<n;i++){
       cout<<"Area of Rectangle "<<(i+1)<<" is "<<rect[i].area()<<endl;
   }
}

void printRectangles(Rectangle *rect,int n){
   for(int i=0;i<n;i++){
       rect[i].print();
   }
}

void sort(Rectangle *rect,int n){
   for (int i = 0; i < n-1; i++) {
       for (int j = 0; j < n-i-1; j++) {
           if (rect[j].area() > rect[j+1].area()) {
               Rectangle tmp=rect[j];
               rect[j]=rect[j+1];
               rect[j+1]=tmp;
           }
       }
   }
}


   bool isOverlap(Rectangle rect1,Rectangle rect2){
       Point *l1=rect1.getPoint4();
       Point *r1=rect1.getPoint2();
       Point *l2=rect2.getPoint4();
       Point *r2=rect2.getPoint2();

       if (l1->getX() == r1->getX() || l1->getY() == r2->getY() || l2->getX() == r2->getX() || l2->getY() == r2->getY()) {
       return false;
       }


       if (l1->getX() >= r2->getX() || l2->getX() >= r1->getX()){
       return false;
           }

       if (l1->getY() <= r2->getY() || l2->getY() <= r1->getY()){
           return false;
           }

       return true;
       }


void calcOverlaps(Rectangle *rect,int *lst,int n){
   for(int i=0;i<n;i++){
       for(int j=0;j<n;j++){
           if(i!=j){
               if(isOverlap(rect[i],rect[j])==true){
                   lst[i]++;
               }
           }
       }
   }
}

int main(){
   int n;
   cout<<"Enter the value of N : ";
   cin>>n;


   Rectangle *rect=new Rectangle[n];
   int *overlaps=new int[n];


   for(int i=0;i<n;i++){
       overlaps[i]=0;
   }

   generateRect(rect,n);

   cout<<"Display rectangles---\n";
   printRectangles(rect,n);

   sort(rect,n);

   cout<<"Display rectangles after sorting ---\n";
   printRectangles(rect,n);


   calcOverlaps(rect,overlaps,n);


   for(int i=0;i<n;i++){
       cout<<"Number of overlaps of rectangle "<<(i+1)<<" is "<<overlaps[i]<<endl;
   }

   return 0;
}