We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Greedy
  4. Jim and the Orders
  5. Discussions

Jim and the Orders

Sort by

recency

|

544 Discussions

|

  • patrickgao2020
     + 0 comments

    I got it in 2 lines!

    def jimOrders(orders):
    orders = sorted([[orders[i][0] + orders[i][1] + 1, i + 1] for i in range(len(orders))])
    return [str(order[1]) for order in orders]

  • CS_2212256_T
     + 0 comments
    import java.io.*;
import java.util.*;
import java.lang.*;

public class Solution {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        List<AbstractMap.SimpleEntry<Integer,Integer>> entryList = new LinkedList<>();
        int n = input.nextInt();
        
        //Builds a list of key value pairs
        for(int i = 0; i < n; i++)
        {
            entryList.add(new AbstractMap.SimpleEntry<Integer,Integer>(i+1,input.nextInt() + input.nextInt()));
        }        
        
        //Sorts the list of entries according to value
        Collections.sort(entryList, (p1,p2) -> (p1.getValue()).compareTo(p2.getValue()));
        
        //Print the sorted list of entries
        StringBuilder output = new StringBuilder("");
        for (AbstractMap.SimpleEntry<Integer,Integer> entry : entryList) {
            output.append(entry.getKey() + " ");
        }
        System.out.println(output);
    }
}

  • alban_tyrex
     + 0 comments

    Here is my c++ solution, you can watch the explanation video here : https://youtu.be/ISg5mFFafws

    vector<int> jimOrders(vector<vector<int>> orders) {
    vector<vector<int>> temp;
    for(int i = 0; i < orders.size(); i++){
        int deliver = orders[i][0] + orders[i][1];
        temp.push_back({deliver, i+1});
    }
    sort(temp.begin(), temp.end());
    vector<int> result;
    for(auto element: temp)result.push_back(element[1]);
    
    return result;
}

  • jitendergoyal
     + 0 comments

    unorthodox java solution but i assume very less space complexity

    class Result {

    /*
 * Complete the 'jimOrders' function below.
 *
 * The function is expected to return an INTEGER_ARRAY.
 * The function accepts 2D_INTEGER_ARRAY orders as parameter.
 */

public static List<Integer> jimOrders(List<List<Integer>> orders) {
// Write your code here


long[] val=new long[orders.size()];
for(int i=0;i<orders.size();i++){
    long temp=orders.get(i).get(0)+orders.get(i).get(1);
    val[i]=temp*10000 +(i+1);

}
Arrays.sort(val);
System.out.println(Arrays.toString(val));
ArrayList<Integer> list=new ArrayList<>();
for(long i:val){
    list.add((int)(i%10000));
}

return list;
}

    }

  • dorirgob
     + 0 comments

    Java:

    public static List<Integer> jimOrders(List<List<Integer>> orders) {
  int n = orders.size();
  List<List<Integer>> delivery = new ArrayList<>();
  List<Integer> customers = new ArrayList<>();

  for (int i = 0; i < n; i++) {
    int orderNumber = orders.get(i).get(0);
    int prepTime = orders.get(i).get(1);
    int deliverytime = orderNumber + prepTime;
    delivery.add(Arrays.asList(i + 1, deliverytime));
  }
  Collections.sort(delivery, new Comparator<List<Integer>>() {
    @Override
    public int compare(List<Integer> o1, List<Integer> o2) {
      if (o1.get(1) != o2.get(1)) {
        return o1.get(1).compareTo(o2.get(1));
      } else {
        return o1.get(0).compareTo(o2.get(0));
      }
    }
  });
  for (List<Integer> l : delivery) {
    customers.add(l.get(0));
  }
  System.out.println(customers);
  return customers;
}