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. Search
  4. Ice Cream Parlor
  5. Discussions

Ice Cream Parlor

Sort by

recency

|

966 Discussions

|

  • alban_tyrex
     + 0 comments

    Here is my c++ solution, you can watch the explanation here : https://youtu.be/WvLuA-LCsb0

    vector<int> icecreamParlor(int m, vector<int> arr) {
    map<int, int> mp;
    for (int i = 0; i < arr.size(); i++) {
        int complement = m - arr[i];
        if (mp.count(complement)) {
            return {mp[complement] + 1, i + 1};
        }
        mp[arr[i]] = i;
    }
    return {};
}

  • daviddeboaa
     + 0 comments

    Solution in Python with time complexity O(n)

    def icecreamParlor(m, arr):
    indices = []
    prices = {}
    for i, p in enumerate(arr):
        compl = m - p
        if compl in prices:
            indices = [prices[compl] + 1, i + 1]
        prices[p] = i
    print(prices)
    return sorted(indices)

  • patrickgao2020
     + 0 comments

    Here is my Python solution!

    def icecreamParlor(m, arr):
    for f1 in range(len(arr)):
        for f2 in range(f1 + 1, len(arr)):
            if arr[f1] + arr[f2] == m:
                return sorted([f1 + 1, f2 + 1])

  • jasminenarula_i1
     + 0 comments

    Solution in Java:

            Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < arr.size(); i++) {
            int complement = m - arr.get(i);

            if (map.containsKey(complement)) {
                return Arrays.asList(map.get(complement) + 1, i + 1);
            }

            map.put(arr.get(i),i);
        }

        return Arrays.asList(-1, -1); 
}

  • zaidnsour12
     + 0 comments

    Solution with time complexity O(nlogn) it's consider effcient with large Lists and there is possible to sorting one time but Iam a little bit lazy :)

    public static List<Integer> icecreamParlor(int m, List<Integer> arr) {
    int n = arr.size();
    Integer[] indices = new Integer[n];
    
    for (int i = 0; i < n; i++) {
        indices[i] = i;
    }
    
    Arrays.sort(indices, Comparator.comparingInt(i -> arr.get(i)));
    Collections.sort(arr);
    
    int i = 0, j = n - 1;
    while(i <= j){
      if( arr.get(i) + arr.get(j)  > m)
        j--;
      else if(arr.get(i) + arr.get(j)  < m)
        i++;
      else{
        int firstIndex = indices[i] + 1;
        int secondIndex = indices[j] + 1;
        List<Integer>result = Arrays.asList(firstIndex, secondIndex);
        Collections.sort(result);
        return result;
        }  
      }
    return new ArrayList();
    }