Day 51 - getting more greedy

Author: mandliya

README.md

@@ -4,9 +4,9 @@
 
 | Current Status|     Stats     |
 | :------------: | :----------: |
-| Total Problems | 70 |
-| Current Streak | 50 |
-| Longest Streak | 50 ( August 17, 2015 - October 5, 2015 ) |
+| Total Problems | 71 |
+| Current Streak | 51 |
+| Longest Streak | 51 ( August 17, 2015 - October 6, 2015 ) |
 
 </center>
 
@@ -134,3 +134,4 @@ Include contains single header implementation of data structures and some algori
 | Problem | Solution |
 | :------------ | :----------: |
 | Given two integer arrays, A and B, each containing N integers. You are free to permute the order of the elements in the arrays.Is there an permutation A', B' possible of A and B, such that, A'<sub>i</sub>+B'<sub>i</sub> ≥ K for all i, where A'<sub>i<sub> denotes the i<sup>th<sup> element in the array A' and B'<sub>i</sub> denotes i<sup>th</sup> element in the array B'.| [two_arrays.cpp](greedy_problems/two_arrays.cpp)|
+|John is taking orders. The i<sup>th</sup> order is placed by the i<sup>th</sup> customer at t<sub>i</sub> time and it takes d<sub>i</sub> time to procees. What is the order in which the customers will get their orders? (see more details in solutions's comments)|[orders_order.cpp](greedy_problems/orders_order.cpp)|

greedy_problems/orders_order.cpp

@@ -0,0 +1,57 @@
+/*
+ * John is taking orders. 
+ * The ith order is placed by the ith customer at ti time and it takes di time to procees. 
+ * What is the order in which the customers will get their orders?
+ *
+ * Input
+ * On the first line you will get n, the number of orders.
+ * Then n lines will follow. On the (i+1)th line, you will get ti and di separated by a single space.
+ *
+ * Output
+ * Print the order ( as single space separated integers ) in which the burger customers get their orders. 
+ * If two customers get the order at the same time,
+ * then print the smallest numbered order first.(remember, the customers are numbered 1 to n).
+ *
+ * Approach :
+ * By greedy approach, we can conclude the customer who ordered first and his order duration is smaller will get his order first.
+ * So we will sort the orders based on time at which order was taken, + duration it will take to fulfill that order.
+ */
+
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+struct order {
+  int index;
+  int time;
+  int duration;
+};
+
+bool compareFunc(order & o1, order & o2) {
+    if ( (o1.time + o1.duration) < (o2.time + o2.duration) ) {
+        return true;
+    } else if ( o1.time + o1.duration == o2.time + o2.duration ) {
+        if (o1.index < o2.index) {
+            return true;
+        }
+    }
+    return false;
+}
+
+int main() {
+    int N;
+    cin >> N ;
+    order * orders = new order[N];
+    for (int i = 0; i < N; ++i) {
+        orders[i].index = i+1;
+        cin >> orders[i].time;
+        cin >> orders[i].duration;
+    }
+    sort(orders, orders+N, compareFunc);
+    for( int i = 0; i < N; ++i) {
+        std::cout << orders[i].index << " ";
+    }
+    std::cout << std::endl;
+    return 0;
+}
+