In this HackerRank Attending Workshops problem in c++ programming you need to Implement 2 functions:

  1. Available_Workshops* initialize (int start_time[], int duration[], int n) Creates an Available_Workshops object and initializes its elements using the elements in the start_time[] and duration[] parameters (both are of size n). Here, start_time[i] and duration[i] are the respective start time and duration for the  workshop. This function must return a pointer to an Available_Workshops object.
  2. int CalculateMaxWorkshops(Available_Workshops* ptr) Returns the maximum number of workshops the student can attend—without overlap. The next workshop cannot be attended until the previous workshop ends.

HackerRank Attending workshops solution in c++ programming


HackerRank Attending workshops problem solution in c++ programming.

#include<bits/stdc++.h>

using namespace std;

//Define the structs Workshops and Available_Workshops.
//Implement the functions initialize and CalculateMaxWorkshops
struct Workshops{
    friend ostream &operator<<(ostream &os, const Workshops &obj);
    int start_time;
    int end_time;
    int duration;

    bool operator<(const Workshops &rhs){
    return (this->end_time < rhs.end_time);
    }
};

ostream &operator<<(ostream &os, const Workshops &obj){
    os << obj.start_time << ": " << obj.end_time << ": "
    << obj.duration << "\n";
    return os;
}

struct Available_Workshops{
    int n;
    vector<Workshops> vec;
};

Available_Workshops* initialize(int start_time[], int duration[], int num)
{
    Available_Workshops *avail = new Available_Workshops;
    avail->n = num;
    Workshops test;
    for(int i{0}; i < num; i++){
        test.start_time = start_time[i];
        test.duration = duration[i];
        test.end_time = start_time[i] + duration[i];
        avail->vec.push_back(test);
    }
    sort(avail->vec.begin(), avail->vec.end());
    return avail;
}

int CalculateMaxWorkshops(Available_Workshops *test){
    int w_count = 1;
    int test_end_time = test->vec.at(0).end_time;
    for(int i{1}; i < test->n; i++){
        if(test_end_time <= test->vec.at(i).start_time){
            w_count++;
            test_end_time = test->vec.at(i).end_time;
        }
    }
    return w_count;
}

int main(int argc, char *argv[]) {
    int n; // number of workshops
    cin >> n;
    // create arrays of unknown size n
    int* start_time = new int[n];
    int* duration = new int[n];

    for(int i=0; i < n; i++){
        cin >> start_time[i];
    }
    for(int i = 0; i < n; i++){
        cin >> duration[i];
    }

    Available_Workshops * ptr;
    ptr = initialize(start_time,duration, n);
    cout << CalculateMaxWorkshops(ptr) << endl;
    return 0;
}

Second solution

#include<bits/stdc++.h>

using namespace std;
typedef struct Workshops
{
    int s,d,e;
}Workshops;

typedef struct Available_Workshops
{
    int n;
    Workshops *shops;
    Available_Workshops(int t)
    {
        n = t;
        shops = (Workshops*)malloc(t*sizeof(Workshops));
    }
}Available_Workshops;

bool comp(const Workshops &a, const Workshops &b)
{
    if(a.e < b.e)
        return true;
    return false;
}
Available_Workshops* initialize (int start_time[], int duration[] ,int N) 
{
    Available_Workshops* node = new Available_Workshops(N);
    for(int i =0 ; i< node->n; i++)
    {
        (node->shops)[i].s = start_time[i];
        (node->shops)[i].d = duration[i];
        (node->shops)[i].e = start_time[i] + duration[i];
    }
    return node;
}

int CalculateMaxWorkshops (Available_Workshops* ptr) 
{
    sort(ptr->shops, ptr->shops + ptr->n, comp);
    int ans = 1, t;
    for(int i = 0 ; i < ptr->n; i++)
    {
        if(i == 0)
        {
            t = (ptr->shops[i]).e;    
            continue;
        }
        if((ptr->shops[i]).s>=t)
        {
            ans++;
            t = (ptr->shops[i]).e;
        }
    }
    return ans;
}

int main()
{
    int n;
    cin>>n;
    int start_time[n],duration[n];
    for(int i=0;i<n;i++)
    {
        cin>>start_time[i];
    }
    for(int i=0;i<n;i++)
    {
        cin>>duration[i];
    }

    Available_Workshops* ptr;
    ptr=initialize(start_time,duration,n);
    cout<<CalculateMaxWorkshops(ptr)<<endl;
    return 0;
}