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. Hash Tables: Ice Cream Parlor
  2. Discussions

Hash Tables: Ice Cream Parlor

Sort by

recency

|

673 Discussions

|

  • rajivaiyer
     + 1 comment

    Here's my Java 8 solution, passing all tests, for Max Score of 35:

    class Result {
    
    private static class IceCreamIdCostBinding {

        private int id;
        private int cost;

        // Constructor
        public IceCreamIdCostBinding(int id, int cost) {
            this.id = id;
            this.cost = cost;
        }

        // Getter for id
        public int getId() {
            return id;
        }

        // Getter for cost
        public int getCost() {
            return cost;
        }
        
        public String toString() {
            return "{ id = >" + id + "< | cost = >" + cost + "< }";
        }
    }

    /*
     * Complete the 'whatFlavors' function below.
     *
     * The function accepts following parameters:
     *  1. INTEGER_ARRAY cost
     *  2. INTEGER money
     */

    public static void whatFlavors(List<Integer> cost, int money) {
        // Write your code here
        List<IceCreamIdCostBinding> iceCreamIdCostBindingsLst = new ArrayList<>();
        for (int cIdx = 0 ; cIdx < cost.size() ; cIdx++) {
            iceCreamIdCostBindingsLst.add(new IceCreamIdCostBinding(
                                                  (cIdx + 1), cost.get(cIdx)));
        }

        iceCreamIdCostBindingsLst.sort(
            Comparator.comparingInt(IceCreamIdCostBinding::getCost));

        int sortedArrEndIdx = 
            Collections.binarySearch(
                iceCreamIdCostBindingsLst,
                new IceCreamIdCostBinding(0, money),
                Comparator.comparingInt(IceCreamIdCostBinding::getCost));

        // If value not found, binarySearch returns (-(insertion point) - 1)
        if (sortedArrEndIdx < 0) {
            sortedArrEndIdx = (iceCreamIdCostBindingsLst.size() - 1);
        } else {
            sortedArrEndIdx--;
        }
        
        for (int cIdx = 0 ; cIdx < sortedArrEndIdx ; cIdx++) {
            int remainingMoney = 
                (money - iceCreamIdCostBindingsLst.get(cIdx).getCost());

            List<IceCreamIdCostBinding> searchSubLst = 
                iceCreamIdCostBindingsLst.subList((cIdx + 1), (sortedArrEndIdx + 1));
            
            int remMoneySubLstIdx = 
                Collections.binarySearch(
                    searchSubLst,
                    new IceCreamIdCostBinding(0, remainingMoney),
                    Comparator.comparingInt(IceCreamIdCostBinding::getCost));

            if (remMoneySubLstIdx >= 0) {
                int iceCreamID1 = 
                    iceCreamIdCostBindingsLst.get(cIdx).getId();
                int iceCreamID2 = 
                    searchSubLst.get(remMoneySubLstIdx).getId();

                System.out.println(Math.min(iceCreamID1, iceCreamID2) + 
                                   " " + Math.max(iceCreamID1, iceCreamID2));

                break;
            }
        }
        
    }

}

  • citrusjuicebox
     + 0 comments

    Simple O(n) Python solution

        index = {}
    for i0, v in enumerate(cost):   # print diff if it exists
        if i1 := index.get(money - v): print(i1, i0 + 1)
        else: index[v] = i0 + 1     # else add value to index

  • rkphotographicl1
     + 0 comments
    public static void whatFlavors(List<Integer> cost, int money) {
// Write your code here
Map<Integer, List<Integer>> costByIndex = new HashMap<>();
for(int i =0;i<cost.size();i++){
    int balance = money-cost.get(i);
    List<Integer> ids;
    if(costByIndex.containsKey(balance)){
        ids = costByIndex.get(balance);
    }else ids = new ArrayList<>();
    ids.add(i+1);
    costByIndex.put(balance, ids);
}


 for(int i =0;i<cost.size();i++){
    int balance = cost.get(i);
     if(costByIndex.containsKey(balance)&& (costByIndex.get(balance).get(0)!=(i+1))){
        int val1 = Math.min(i+1,costByIndex.get(balance).get(0));
        int val2 = Math.max(i+1,costByIndex.get(balance).get(0));
        System.out.println(val1+" "+val2);
        break;
    }
}

  • schmiddla
     + 0 comments

    JS - only using array

    function whatFlavors(cost, money) {
  // Write your code here
  for (let i = 0; i < cost.length; i++) {
    const flavor1 = cost[i];
    if (flavor1 < money) {
        // only check indexes after the current one (i)
        const idxFlavor2 = cost.indexOf(money - flavor1, i + 1);
        
        // check if "corresponding" price exists, if true: print and exit
        if (idxFlavor2 > i) {
            console.log(i + 1 + ' ' + (idxFlavor2 + 1));
            // we done, loop can be aborted
            return;
        }
    }
  }
}

  • shrutimadan649
     + 0 comments

    JAVA Solution:

        int[] arr=cost.stream().mapToInt(Integer::intValue).toArray();
Arrays.sort(arr);
int start=0;
int end=arr.length-1;
while(start<end){
    if(arr[start]+arr[end]>money){
        end--;
    }
    else if(arr[start]+arr[end]<money){
        start++;
    }
    else{
        TreeSet<Integer> res=new TreeSet<>();
        res.add(cost.indexOf(arr[start])+1);
        int pos2=cost.indexOf(arr[end])+1;;
        if(arr[start]==arr[end]){
            cost.remove(cost.indexOf(arr[start]));
        pos2=cost.indexOf(arr[end])+2;
        }
        res.add(pos2);


        System.out.print(res.first()+" "+res.last());
        System.out.println();
        break;
    }
}