#include <iostream>
#include <vector>
/*****Aakash Vikrant
KIET GROUP OF INSTITUTIONS*****/
using namespace std;
class HotelRoom {
public: HotelRoom(int bedrooms, int bathrooms) : bedrooms_(bedrooms), bathrooms_(bathrooms) {}
virtual int get_price() {
return 50*bedrooms_ + 100*bathrooms_;
}
private: int bedrooms_; int bathrooms_;
};
class HotelApartment : public HotelRoom {
public: HotelApartment(int bedrooms, int bathrooms) : HotelRoom(bedrooms, bathrooms) {}
int get_price() {
return HotelRoom::get_price() + 100;
}
};
int main() {
int n;
cin >> n;
vector<HotelRoom*> rooms;
for (int i = 0; i < n; ++i) {
string room_type;
int bedrooms;
int bathrooms;
cin >> room_type >> bedrooms >> bathrooms;
if (room_type == "standard") {
rooms.push_back(new HotelRoom(bedrooms, bathrooms));
} else {
rooms.push_back(new HotelApartment(bedrooms, bathrooms));
}
}
int total_profit = 0;
for (auto room : rooms) {
total_profit += room->get_price();
}
cout << total_profit << endl;
for (auto room : rooms) {
delete room;
}
rooms.clear();
return 0;
}
#include <vector>
/*****Aakash Vikrant
KIET GROUP OF INSTITUTIONS*****/
using namespace std;
class HotelRoom {
public: HotelRoom(int bedrooms, int bathrooms) : bedrooms_(bedrooms), bathrooms_(bathrooms) {}
virtual int get_price() {
return 50*bedrooms_ + 100*bathrooms_;
}
private: int bedrooms_; int bathrooms_;
};
class HotelApartment : public HotelRoom {
public: HotelApartment(int bedrooms, int bathrooms) : HotelRoom(bedrooms, bathrooms) {}
int get_price() {
return HotelRoom::get_price() + 100;
}
};
int main() {
int n;
cin >> n;
vector<HotelRoom*> rooms;
for (int i = 0; i < n; ++i) {
string room_type;
int bedrooms;
int bathrooms;
cin >> room_type >> bedrooms >> bathrooms;
if (room_type == "standard") {
rooms.push_back(new HotelRoom(bedrooms, bathrooms));
} else {
rooms.push_back(new HotelApartment(bedrooms, bathrooms));
}
}
int total_profit = 0;
for (auto room : rooms) {
total_profit += room->get_price();
}
cout << total_profit << endl;
for (auto room : rooms) {
delete room;
}
rooms.clear();
return 0;
}
May 26, 2020
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<math.h>
#include<string.h>
/*****Aakash Vikrant
*Kiet Group of Institutions**/
int main()
{
int hh, mm, ss ;
char t12[3];
scanf("%d:%d:%d%s", &hh, &mm, &ss, t12);
if (strcmp(t12,"PM")==0 && hh!=12)
{
hh += 12 ;
}
if (strcmp(t12,"AM")==0 && hh==12)
{
hh = 0 ;
}
printf("%02d:%02d:%02d", hh, mm, ss);
return 0;
}
#include<conio.h>
#include<dos.h>
#include<math.h>
#include<string.h>
/*****Aakash Vikrant
*Kiet Group of Institutions**/
int main()
{
int hh, mm, ss ;
char t12[3];
scanf("%d:%d:%d%s", &hh, &mm, &ss, t12);
if (strcmp(t12,"PM")==0 && hh!=12)
{
hh += 12 ;
}
if (strcmp(t12,"AM")==0 && hh==12)
{
hh = 0 ;
}
printf("%02d:%02d:%02d", hh, mm, ss);
return 0;
}
May 27, 2020
#include <iostream>
/*****Aakash Vikrant
**Kiet Group of Institutions**/
int main()
{
int c, n, max = 0;
std::cin.ignore();
while(std::cin >> n)
max < n ? c = !!(max = n) : c += max == n;
std::cout << c;
return 0;
}
/*****Aakash Vikrant
**Kiet Group of Institutions**/
int main()
{
int c, n, max = 0;
std::cin.ignore();
while(std::cin >> n)
max < n ? c = !!(max = n) : c += max == n;
std::cout << c;
return 0;
}
May 27, 2020
Attending Workshops in C++
#include<bits/stdc++.h>
using namespace std;
/*****Aakash Vikrant
**Kiet Group of Institutions**/
//Define the structs Workshops and Available_Workshops.
//Implement the functions initialize and CalculateMaxWorkshops
struct Workshops
{
int start_time;
int duration;
int end_time;
};
struct Available_Workshops
{
int n;
vector <Workshops> w;
};
Available_Workshops *initialize(int *start_time, int *duration, int n)
{
Available_Workshops *paw=new(Available_Workshops);
Workshops ws;
paw->n=n;
for (int i=0;i<n;i++)
{
//construct a Workshops
ws.start_time=start_time[i];
ws.duration=duration[i];
ws.end_time=start_time[i]+duration[i];
paw->w.push_back(ws);
}
return paw;
}
bool compare(Workshops w1, Workshops w2)
{
return (w1.end_time < w2.end_time);
}
int CalculateMaxWorkshops(Available_Workshops* ptr)
{
// sort workshops by end_time
sort(ptr->w.begin(),ptr->w.end(),compare);
// interval scheduling
int last_processed_time=-1;
int maxWorkshops=0;
for (int i=0;i<ptr->n;i++)
{
if (ptr->w[i].start_time >= last_processed_time)
{
last_processed_time=ptr->w[i].end_time;
maxWorkshops++;
}
}
return maxWorkshops;
}
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;
}
#include<bits/stdc++.h>
using namespace std;
/*****Aakash Vikrant
**Kiet Group of Institutions**/
//Define the structs Workshops and Available_Workshops.
//Implement the functions initialize and CalculateMaxWorkshops
struct Workshops
{
int start_time;
int duration;
int end_time;
};
struct Available_Workshops
{
int n;
vector <Workshops> w;
};
Available_Workshops *initialize(int *start_time, int *duration, int n)
{
Available_Workshops *paw=new(Available_Workshops);
Workshops ws;
paw->n=n;
for (int i=0;i<n;i++)
{
//construct a Workshops
ws.start_time=start_time[i];
ws.duration=duration[i];
ws.end_time=start_time[i]+duration[i];
paw->w.push_back(ws);
}
return paw;
}
bool compare(Workshops w1, Workshops w2)
{
return (w1.end_time < w2.end_time);
}
int CalculateMaxWorkshops(Available_Workshops* ptr)
{
// sort workshops by end_time
sort(ptr->w.begin(),ptr->w.end(),compare);
// interval scheduling
int last_processed_time=-1;
int maxWorkshops=0;
for (int i=0;i<ptr->n;i++)
{
if (ptr->w[i].start_time >= last_processed_time)
{
last_processed_time=ptr->w[i].end_time;
maxWorkshops++;
}
}
return maxWorkshops;
}
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;
}
June 10, 2020
C++ Class Template Specialization

By Aakash Vikrant June 06, 2020
#include <iostream>
using namespace std;
enum class Fruit { apple, orange, pear };
enum class Color { red, green, orange };
/*****Aakash Vikrant**
*Kiet Group of Institutions**/
template <typename T> struct Traits;
// Define specializations for the Traits class template here.
template <>
struct Traits<Fruit>{
static string name(int index)
{
switch(index)
{
case 0:return "apple";
case 1: return "orange" ;
case 2: return "pear";
}
return "unknown";
}
};
template <>
struct Traits<Color>
{
static string name(int index)
{
switch(index)
{
case 0:return "red";
case 1: return "green" ;
case 2: return "orange";
}
return "unknown";
}
};
int main()
{
int t = 0; std::cin >> t;
for (int i=0; i!=t; ++i)
{
int index1; std::cin >> index1;
int index2; std::cin >> index2;
cout << Traits<Color>::name(index1) << " ";
cout << Traits<Fruit>::name(index2) << "\n";
}
}

By Aakash Vikrant June 06, 2020
#include <iostream>
using namespace std;
enum class Fruit { apple, orange, pear };
enum class Color { red, green, orange };
/*****Aakash Vikrant**
*Kiet Group of Institutions**/
template <typename T> struct Traits;
// Define specializations for the Traits class template here.
template <>
struct Traits<Fruit>{
static string name(int index)
{
switch(index)
{
case 0:return "apple";
case 1: return "orange" ;
case 2: return "pear";
}
return "unknown";
}
};
template <>
struct Traits<Color>
{
static string name(int index)
{
switch(index)
{
case 0:return "red";
case 1: return "green" ;
case 2: return "orange";
}
return "unknown";
}
};
int main()
{
int t = 0; std::cin >> t;
for (int i=0; i!=t; ++i)
{
int index1; std::cin >> index1;
int index2; std::cin >> index2;
cout << Traits<Color>::name(index1) << " ";
cout << Traits<Fruit>::name(index2) << "\n";
}
}
June 10, 2020
Time Conversion in Algorithm
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<math.h>
#include<string.h>
/*****Aakash Vikrant
*Kiet Group of Institutions**/
int main()
{
int hh, mm, ss ;
char t12[3];
scanf("%d:%d:%d%s", &hh, &mm, &ss, t12);
if (strcmp(t12,"PM")==0 && hh!=12)
{
hh += 12 ;
}
if (strcmp(t12,"AM")==0 && hh==12)
{
hh = 0 ;
}
printf("%02d:%02d:%02d", hh, mm, ss);
return 0;
}
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<math.h>
#include<string.h>
/*****Aakash Vikrant
*Kiet Group of Institutions**/
int main()
{
int hh, mm, ss ;
char t12[3];
scanf("%d:%d:%d%s", &hh, &mm, &ss, t12);
if (strcmp(t12,"PM")==0 && hh!=12)
{
hh += 12 ;
}
if (strcmp(t12,"AM")==0 && hh==12)
{
hh = 0 ;
}
printf("%02d:%02d:%02d", hh, mm, ss);
return 0;
}
June 10, 2020
Post Transition in C
#include <stdio.h>
#include <stdlib.h>
#define MAX_STRING_LENGTH 6
/*****Aakash Vikrant
**Kiet Group of Institutions**/
struct package
{
char* id;
int weight;
};
typedef struct package package;
struct post_office
{
int min_weight;
int max_weight;
package* packages;
int packages_count;
};
typedef struct post_office post_office;
struct town
{
char* name;
post_office* offices;
int offices_count;
};
typedef struct town town;
void print_all_packages(town t)
{
printf("%s:\n", t.name);
for (int i = 0; i < t.offices_count; i++)
{
printf("\t%d:\n", i);
for (int j = 0; j < t.offices[i].packages_count; j++)
{
printf("\t\t%s\n", t.offices[i].packages[j].id);
}
}
}
int is_movable(post_office po, int w)
{
if (w >= po.min_weight && w <= po.max_weight)
return 1;
else
return 0;
}
void send_all_acceptable_packages(town *s, int si, town *t, int ti)
{
int i, j;
i = 0;
while (i < s->offices[si].packages_count)
{
if (is_movable(t->offices[ti], s->offices[si].packages[i].weight))
{
int *tp = &t->offices[ti].packages_count;
t->offices[ti].packages = (package *) realloc(t->offices[ti].packages, (*tp+1) * sizeof(package));
t->offices[ti].packages[(*tp)++] = s->offices[si].packages[i];
int *sp = &s->offices[si].packages_count;
for (j = i; j < *sp-1; j++)
{
s->offices[si].packages[j] = s->offices[si].packages[j+1];
}
s->offices[si].packages = (package *) realloc(s->offices[si].packages, (*sp-1) * sizeof(package));
(*sp)--;
}
else i++;
}
}
town town_with_most_packages(town *towns, int towns_count)
{
int max = 0 , r = 0, i;
for (i = 0; i < towns_count; i++)
{
int packages_count = 0;
for (int j = 0; j < towns[i].offices_count; j++)
{
packages_count += towns[i].offices[j].packages_count;
}
if (packages_count > max)
{
max = packages_count;
r = i;
}
}
return towns[r];
}
town *find_town(town *towns, int towns_count, char *name)
{
for (int i = 0; i < towns_count; i++)
{
if (!strcmp(name, towns[i].name))
return &towns[i];
}
return NULL;
}
int main()
{
int towns_count;
scanf("%d", &towns_count);
town* towns = malloc(sizeof(town)*towns_count);
for (int i = 0; i < towns_count; i++)
{
towns[i].name = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].name);
scanf("%d", &towns[i].offices_count);
towns[i].offices = malloc(sizeof(post_office)*towns[i].offices_count);
for (int j = 0; j < towns[i].offices_count; j++)
{
scanf("%d%d%d", &towns[i].offices[j].packages_count, &towns[i].offices[j].min_weight, &towns[i].offices[j].max_weight);
towns[i].offices[j].packages = malloc(sizeof(package)*towns[i].offices[j].packages_count);
for (int k = 0; k < towns[i].offices[j].packages_count; k++)
{
towns[i].offices[j].packages[k].id = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].offices[j].packages[k].id);
scanf("%d", &towns[i].offices[j].packages[k].weight);
}
}
}
int queries;
scanf("%d", &queries);
char town_name[MAX_STRING_LENGTH];
while (queries--)
{
int type;
scanf("%d", &type);
switch (type)
{
case 1:
scanf("%s", town_name);
town* t = find_town(towns, towns_count, town_name);
print_all_packages(*t);
break;
case 2:
scanf("%s", town_name);
town* source = find_town(towns, towns_count, town_name);
int source_index;
scanf("%d", &source_index);
scanf("%s", town_name);
town* target = find_town(towns, towns_count, town_name);
#include <stdio.h>
#include <stdlib.h>
#define MAX_STRING_LENGTH 6
/*****Aakash Vikrant
**Kiet Group of Institutions**/
struct package
{
char* id;
int weight;
};
typedef struct package package;
struct post_office
{
int min_weight;
int max_weight;
package* packages;
int packages_count;
};
typedef struct post_office post_office;
struct town
{
char* name;
post_office* offices;
int offices_count;
};
typedef struct town town;
void print_all_packages(town t)
{
printf("%s:\n", t.name);
for (int i = 0; i < t.offices_count; i++)
{
printf("\t%d:\n", i);
for (int j = 0; j < t.offices[i].packages_count; j++)
{
printf("\t\t%s\n", t.offices[i].packages[j].id);
}
}
}
int is_movable(post_office po, int w)
{
if (w >= po.min_weight && w <= po.max_weight)
return 1;
else
return 0;
}
void send_all_acceptable_packages(town *s, int si, town *t, int ti)
{
int i, j;
i = 0;
while (i < s->offices[si].packages_count)
{
if (is_movable(t->offices[ti], s->offices[si].packages[i].weight))
{
int *tp = &t->offices[ti].packages_count;
t->offices[ti].packages = (package *) realloc(t->offices[ti].packages, (*tp+1) * sizeof(package));
t->offices[ti].packages[(*tp)++] = s->offices[si].packages[i];
int *sp = &s->offices[si].packages_count;
for (j = i; j < *sp-1; j++)
{
s->offices[si].packages[j] = s->offices[si].packages[j+1];
}
s->offices[si].packages = (package *) realloc(s->offices[si].packages, (*sp-1) * sizeof(package));
(*sp)--;
}
else i++;
}
}
town town_with_most_packages(town *towns, int towns_count)
{
int max = 0 , r = 0, i;
for (i = 0; i < towns_count; i++)
{
int packages_count = 0;
for (int j = 0; j < towns[i].offices_count; j++)
{
packages_count += towns[i].offices[j].packages_count;
}
if (packages_count > max)
{
max = packages_count;
r = i;
}
}
return towns[r];
}
town *find_town(town *towns, int towns_count, char *name)
{
for (int i = 0; i < towns_count; i++)
{
if (!strcmp(name, towns[i].name))
return &towns[i];
}
return NULL;
}
int main()
{
int towns_count;
scanf("%d", &towns_count);
town* towns = malloc(sizeof(town)*towns_count);
for (int i = 0; i < towns_count; i++)
{
towns[i].name = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].name);
scanf("%d", &towns[i].offices_count);
towns[i].offices = malloc(sizeof(post_office)*towns[i].offices_count);
for (int j = 0; j < towns[i].offices_count; j++)
{
scanf("%d%d%d", &towns[i].offices[j].packages_count, &towns[i].offices[j].min_weight, &towns[i].offices[j].max_weight);
towns[i].offices[j].packages = malloc(sizeof(package)*towns[i].offices[j].packages_count);
for (int k = 0; k < towns[i].offices[j].packages_count; k++)
{
towns[i].offices[j].packages[k].id = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf("%s", towns[i].offices[j].packages[k].id);
scanf("%d", &towns[i].offices[j].packages[k].weight);
}
}
}
int queries;
scanf("%d", &queries);
char town_name[MAX_STRING_LENGTH];
while (queries--)
{
int type;
scanf("%d", &type);
switch (type)
{
case 1:
scanf("%s", town_name);
town* t = find_town(towns, towns_count, town_name);
print_all_packages(*t);
break;
case 2:
scanf("%s", town_name);
town* source = find_town(towns, towns_count, town_name);
int source_index;
scanf("%d", &source_index);
scanf("%s", town_name);
town* target = find_town(towns, towns_count, town_name);
September 3, 2020