Merge branch 'master' of https://github.com/CodeSurfer3022/HackerRank

Author: chandraprakash-dev

LANGUAGE PROFICIENCY/C++/Other Concepts/AttendingWorkshops.cpp

@@ -0,0 +1,69 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+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 *tmp = new(Available_Workshops);
+    Workshops ws;
+    
+    tmp -> n = n;
+    for (int i=0;i<n;i++) {
+        ws.start_time = start_time[i];
+        ws.duration = duration[i];
+        ws.end_time = start_time[i]+duration[i];
+        tmp -> w.push_back(ws);   
+    }
+
+    return tmp;    
+}
+
+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;
+}
+

LANGUAGE PROFICIENCY/C++/Other Concepts/ClassTemplateSpecialization.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+using namespace std;
+enum class Fruit { apple, orange, pear };
+enum class Color { red, green, orange };
+
+template <typename T> struct Traits;
+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";
+    }
+}
+

LANGUAGE PROFICIENCY/C++/Other Concepts/ClassTemplates.cpp

@@ -0,0 +1,49 @@
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+#include <cassert>
+using namespace std;
+
+template <class T>
+class AddElements {
+    T element;
+    public:
+    AddElements(T val) : element(val){}
+    T add(T val) {
+        return element + val;
+    }
+    T concatenate(T val) {
+        return element + val;
+    }
+};
+
+int main () {
+  int n,i;
+  cin >> n;
+  for(i=0;i<n;i++) {
+    string type;
+    cin >> type;
+    if(type=="float") {
+        double element1,element2;
+        cin >> element1 >> element2;
+        AddElements<double> myfloat (element1);
+        cout << myfloat.add(element2) << endl;
+    }
+    else if(type == "int") {
+        int element1, element2;
+        cin >> element1 >> element2;
+        AddElements<int> myint (element1);
+        cout << myint.add(element2) << endl;
+    }
+    else if(type == "string") {
+        string element1, element2;
+        cin >> element1 >> element2;
+        AddElements<string> mystring (element1);
+        cout << mystring.concatenate(element2) << endl;
+    }
+  }
+  return 0;
+}
+

LANGUAGE PROFICIENCY/C++/Other Concepts/OperatorOverloading.cpp

@@ -0,0 +1,56 @@
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+class Matrix{
+    public:
+    vector<vector<int>> a;
+    Matrix& operator +(const Matrix &y) {
+        for(int m = 0; m < y.a.size(); m++) 
+            for(int n = 0; n < y.a[0].size(); n ++) {
+                a[m][n] = a[m][n] + y.a[m][n];
+            }
+        return *this;   
+    }     
+};
+
+int main () {
+   int cases,k;
+   cin >> cases;
+   for(k=0;k<cases;k++) {
+      Matrix x;
+      Matrix y;
+      Matrix result;
+      int n,m,i,j;
+      cin >> n >> m;
+      for(i=0;i<n;i++) {
+         vector<int> b;
+         int num;
+         for(j=0;j<m;j++) {
+            cin >> num;
+            b.push_back(num);
+         }
+         x.a.push_back(b);
+      }
+      for(i=0;i<n;i++) {
+         vector<int> b;
+         int num;
+         for(j=0;j<m;j++) {
+            cin >> num;
+            b.push_back(num);
+         }
+         y.a.push_back(b);
+      }
+      result = x+y;
+      for(i=0;i<n;i++) {
+         for(j=0;j<m;j++) {
+            cout << result.a[i][j] << " ";
+         }
+         cout << endl;
+      }
+   }  
+   return 0;
+}
+

LANGUAGE PROFICIENCY/C++/Other Concepts/OverloadOperators.cpp

@@ -0,0 +1,61 @@
+//Operator Overloading
+
+#include<iostream>
+
+using namespace std;
+
+class Complex
+{
+public:
+    int a,b;
+    void input(string s)
+    {
+        int v1=0;
+        int i=0;
+        while(s[i]!='+')
+        {
+            v1=v1*10+s[i]-'0';
+            i++;
+        }
+        while(s[i]==' ' || s[i]=='+'||s[i]=='i')
+        {
+            i++;
+        }
+        int v2=0;
+        while(i<s.length())
+        {
+            v2=v2*10+s[i]-'0';
+            i++;
+        }
+        a=v1;
+        b=v2;
+    }
+};
+
+//Overload operators + and << for the class complex
+//+ should add two complex numbers as (a+ib) + (c+id) = (a+c) + i(b+d)
+//<< should print a complex number in the format "a+ib"
+
+Complex operator + (Complex x, Complex y) {
+    x.a += y.a;
+    x.b += y.b;
+    return x;
+}
+
+ostream& operator << (ostream& out, Complex x) {
+    out << x.a << "+i" << x.b;
+    return out;
+}
+
+int main()
+{
+    Complex x,y;
+    string s1,s2;
+    cin>>s1;
+    cin>>s2;
+    x.input(s1);
+    y.input(s2);
+    Complex z=x+y;
+    cout<<z<<endl;
+}
+

LANGUAGE PROFICIENCY/C++/Other Concepts/PreprocessorSolution.cpp

@@ -0,0 +1,34 @@
+#define toStr(x) #x
+#define io(s) cin >> s
+#define foreach(list, index) for(int index = 0; index < list.size(); index++)
+#define FUNCTION(name, op) void name(int &x, int y){ if(!(x op y)) x = y; }
+#define INF 1e9
+
+#include <iostream>
+#include <vector>
+using namespace std;
+
+#if !defined toStr || !defined io || !defined FUNCTION || !defined INF
+#error Missing preprocessor definitions
+#endif 
+
+FUNCTION(minimum, <)
+FUNCTION(maximum, >)
+
+int main(){
+	int n; cin >> n;
+	vector<int> v(n);
+	foreach(v, i) {
+		io(v)[i];
+	}
+	int mn = INF;
+	int mx = -INF;
+	foreach(v, i) {
+		minimum(mn, v[i]);
+		maximum(mx, v[i]);
+	}
+	int ans = mx - mn;
+	cout << toStr(Result =) <<' '<< ans;
+	return 0;
+
+}

LANGUAGE PROFICIENCY/C++/STL/DequeStl.cpp

@@ -0,0 +1,46 @@
+#include <iostream>
+#include <deque> 
+using namespace std;
+
+void printKMax(int arr[], int n, int k){
+	deque<int> d;
+    for(int i=0;i<k;i++)
+    {
+        while(!d.empty() && arr[i]>=arr[d.back()]){
+            d.pop_back();
+        }
+        d.push_back(i);
+    }
+    for(int i=k;i<n;i++)
+    {
+        cout<<arr[d[0]]<<" ";
+        while(!d.empty() && d[0]<=i-k)
+        {
+            d.pop_front();
+        }
+        while(!d.empty() && arr[i]>=arr[d.back()])
+        {
+            d.pop_back();
+        }
+        d.push_back(i);
+    }
+    cout<<arr[d[0]]<<" \n";
+}
+
+int main(){
+    ios_base::sync_with_stdio(false); 
+    cin.tie(0);
+	int t;
+	cin >> t;
+	while(t>0) {
+		int n,k;
+    	cin >> n >> k;
+    	int i;
+    	int arr[n];
+    	for(i=0;i<n;i++)
+      		cin >> arr[i];
+    	printKMax(arr, n, k);
+    	t--;
+  	}
+  	return 0;
+}

LANGUAGE PROFICIENCY/C++/STL/LowerBoundStl.cpp

@@ -0,0 +1,33 @@
+#include <cmath>
+#include <cstdio>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+
+int main() {
+    int size, a;
+    cin >> size;
+    vector <int> v;
+
+    for(int i = 0; i < size; i ++) {
+        cin >> a;
+        v.push_back(a);
+    }
+
+    int q;
+    cin >> q;
+
+    for(int i = 0; i < q; i ++) {
+        int n;
+        cin >> n;
+        vector<int> :: iterator low = lower_bound(v.begin(), v.end(), n);
+        if (v[low - v.begin()] == n)
+            cout << "Yes" << " " << low - v.begin() + 1 << endl;
+        else 
+            cout << "No" << " " << low - v.begin() + 1 << endl;
+    }
+    return 0;
+}
+