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.
  • HackerRank Home

    HackerRank

  • |
  • Prepare
  • Certify
  • Compete
  • Hiring developers?
  1. Prepare
  2. Algorithms
  3. Greedy
  4. Jim and the Orders
  5. Discussions

Jim and the Orders

Problem
Submissions
Leaderboard
Discussions
Editorial

Sort 482 Discussions, By:

recency

Please Login in order to post a comment

  • ercanbeyen
    7 days ago+ 0 comments

    Here is my Java 15 solution:

    import java.util.*;
    import java.util.stream.*;
    
    
    class Result {
        
        private static HashMap<Integer, Integer> createOrderMap(int[][] orders) {
            HashMap<Integer, Integer> map = new HashMap<>();
            
            for (int i = 0; i < orders.length; i++) {
                int customerNumber = i + 1;
                int deliverTime = orders[i][0] + orders[i][1];
                map.put(customerNumber, deliverTime);
            }
            
            return map;
        }
    
        public static List<Integer> jimOrders(int[][] orders) {
            Map<Integer, Integer> orderMap = createOrderMap(orders);
            
            return orderMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue())
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());
        }
    }
    
    public class Solution {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int[][] array = new int[n][2];
            
            for (int i = 0; i < n; i++) {
                int orderNumber = scanner.nextInt();
                int preparationTime = scanner.nextInt();
                int[] orderPreparationArray = { orderNumber, preparationTime };
                array[i] = orderPreparationArray;
            }
            
            scanner.close();
            List<Integer> result = Result.jimOrders(array);
            result.forEach(element -> System.out.print(element + " "));
        }
    }
    
    0|
    Permalink
  • ysmayur19921
    1 week ago+ 0 comments

    Simple C++ Solution:

    static bool cmp(const vector<long long>& vec1,const vector<long long>& vec2){
        if(vec1[1] < vec2[1]){
            return (vec1[1] < vec2[1]);
        }else {
            return (vec1[0] < vec2[0]) and (vec1[1] == vec2[1]);
        }
    }
    vector<int> jimOrders(vector<vector<int>>& orders) {
        int index = 1;
        vector<vector<long long>> vec;
        vector<int> res;
        for(auto& num:orders){
            vector<long long> tmp;
            tmp.push_back(index);
            tmp.push_back(num[0]+num[1]);
            vec.push_back(tmp);
            index++;    
        }
        sort(vec.begin(),vec.end(),cmp);
        for(auto& result:vec){
            res.push_back(result[0]);
        }
        return res;
    }
    
    0|
    Permalink
  • nguyentrunglinh1
    2 weeks ago+ 0 comments

    python

    def jimOrders(orders):
        # Write your code here
        orders = sorted(enumerate([sum(i) for i in orders],1),key = lambda ele: (ele[1],ele[0]))
        return [i for i,j in orders]
    
    0|
    Permalink
  • sngrisa
    1 month ago+ 0 comments

    Java 8:

    static HashMap<Integer,Integer> map(List<List<Integer>> list){
            HashMap<Integer, Integer> hashMap = new HashMap<>();
            for(int i = 0 ; i < list.size(); i++){
                hashMap.put(i+1 , list.get(i).get(0)+list.get(i).get(1));
            }
            return hashMap;
        }
        
        static List<Entry<Integer, Integer>> orderHashMap(List<List<Integer>> list){
            List<Entry<Integer, Integer>> listMap = new ArrayList<>(map(list).entrySet());
            listMap.sort(Entry.comparingByValue());
            return listMap;
        }
    
    
        public static List<Integer> jimOrders(List<List<Integer>> orders) {
            List<Integer> listTimes = new ArrayList<>();
            orderHashMap(orders).forEach(element->{listTimes.add(element.getKey());});
            return listTimes;
        }
    
    0|
    Permalink
  • parthpathak2019
    1 month ago+ 0 comments

    java

    public static List jimOrders(List> orders) { // Write your code here LinkedHashMap map = new LinkedHashMap<>();

            int i=0;
            while(i<orders.size()){
                int sum = orders.get(i).get(0) + orders.get(i).get(1);
                map.put(i+1, sum);
                i++;
            }
    
            List<Map.Entry<Integer,Integer>> list = new ArrayList<>(map.entrySet());
            Collections.sort(list,new Comparator<Map.Entry<Integer,Integer>>() {
                public int compare(Map.Entry<Integer,Integer> o1, 
                Map.Entry<Integer,Integer> o2){
    
                 return o1.getValue()-o2.getValue();   
                }
            });
            List<Integer> ans = new ArrayList<>();
            i=0;
            for(Map.Entry<Integer,Integer> m : list){
                //System.out.println(m.getKey() +" "+m.getValue());
                ans.add(m.getKey());
            }
            return ans;
    }
    
    0|
    Permalink
Load more conversations

Need Help?


View editorial
View top submissions
  • Blog
  • Scoring
  • Environment
  • FAQ
  • About Us
  • Support
  • Careers
  • Terms Of Service
  • Privacy Policy