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. Array Manipulation
  2. Discussions

Array Manipulation

Sort by

recency

|

26 Discussions

|

  • fencullen
     + 0 comments

    How was I every supposed to come up with that? ;-;

  • trip2ken
     + 0 comments

    Java 8 - This solution does require a sort and then a full pass through the queries, but the memory overhead is less and still meet so the time requirments.

        public static long arrayManipulation(int n, List<List<Integer>> queries) {
        long result = Integer.MIN_VALUE;
        
        queries.sort((q1,q2)->Integer.compare(q1.get(0), q2.get(0)));
        
        PriorityQueue<List<Integer>> expireQueue = new PriorityQueue<>(
            (q1,q2)->Integer.compare(q1.get(1), q2.get(1))
        ) ;
        long runningTotal = 0;
        
        for (List<Integer> query: queries) {
            int idx = query.get(0);            
            expireQueue.offer(query);
            
            runningTotal += query.get(2);
            
            while(expireQueue.peek().get(1)<idx) 
                runningTotal -= expireQueue.poll().get(2) ;
            
            if (runningTotal>result)
                result = runningTotal;
        }
        return result ;
    }

  • yashdeora98294
     + 0 comments

    here is hackerrank array manipulation problem solution in Python Java c++ c and javascript

  • hjiron
     + 0 comments

    Java

        public static long arrayManipulation(int n, List<List<Integer>> queries) {
        Map<Integer, Long> sum = new TreeMap<>(); // order by key
        for (List<Integer> list : queries) {
            int a = list.get(0);
            int b = list.get(1);
            long k = list.get(2);
            sum.put(a, sum.getOrDefault(a, 0L) + k);
            sum.put(b + 1, sum.getOrDefault(b + 1, 0L) - k);
        }

        long max = 0L;
        long current = 0L;
        for (long value : sum.values()) {
            current += value;
            max = Math.max(max, current);
        }
        return max;

    }

  • gtai_quant
     + 0 comments
    def arrayManipulation(n, queries):
    """Finds the maximum value in an array after multiple range updates.

    Uses a difference array to efficiently track changes.

    Args:
        n (int): Array size.
        queries (list of list): List of [start, end, value] updates.

    Returns:
        int: Maximum value after all updates.
    """

    diff = [0] * (n + 2)  # Difference array (1-indexed with extra cell)

    for start, end, value in queries:
        diff[start] += value  # Increase at start
        diff[end + 1] -= value  # Cancel effect after end

    max_num = 0  # Track maximum value
    curr_sum = 0  # Track current prefix sum
    for i in range(1, n + 1):
        if diff[i] == 0:  # Skip if no change
            continue
        curr_sum += diff[i]  # Update prefix sum
        max_num = max(max_num, curr_sum)  # Update maximum

    return max_num