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.
Loading...
  1. Practice
  2. Data Structures
  3. Arrays
  4. Array Manipulation
  5. Discussions

Array Manipulation

  • krishnna + 1 comment

    check it out here, you will get all your doubts solved https://www.geeksforgeeks.org/difference-array-range-update-query-o1/

    • tejaspatil + 1 comment

      Below link will also help to understand theory behind it. https://www.geeksforgeeks.org/constant-time-range-add-operation-array/

      • codam + 7 comments

        Same solution in Javascript

            var arr = [];
    var max = 0;
    // init each element of arr to 0
    for (let l = 0; l < n; l++) {
        arr[l] = 0;
    }
    // for each sum operation in queries
    for (let i = 0; i < queries.length; i++) {
       // update arr with number to add at index=queries[i][0]  and number to remove at index=queries[i][0]+1 => this will allow us to build each element of the final array by summing all elements before it. The aim of this trick is to lower time complexity
        arr[queries[i][0]-1] += queries[i][2];
        if (queries[i][1] < arr.length) {
            arr[queries[i][1]] -= queries[i][2];
        }
    }
    for (let j = 1; j < n; j++) {
        arr[j] += arr[j-1];
    }
    for (let k = 0; k < arr.length; k++) {
        max = Math.max(max, arr[k]);
    }
    //max = Math.max(...arr); // not working for big arrays
    return max;
        • kamnijais + 1 comment

          Hey, I did the code in Java8 and my code is getting failed for input type - where only single value is present in a row of array. meaning only left index value is provided and right and k value is missing from array. So can you help me how to solve this issue?

          • h1017691668 + 0 comments

            you could post your code,and we can check it out

        • mevtew + 1 comment

          simpler in es6:

          function arrayManipulation(n, queries) { let arr = new Array(2*n).fill(0); let max = 0;

          queries.forEach((item) => {
    arr[item[0]] += item[2];
    arr[item[1] + 1] -= item[2];
});

arr.reduce((prev, curr, idx) => {
    const sum = prev + curr;
    if (sum > max) {
        max = sum;
    }

    return sum;
})

return max;

          }

          • Rockyfive + 1 comment

            I did something pretty similar, just with a little bit more readable forEach:

            const arr = new Array(n).fill(0);
let result = 0;

queries.forEach(([a, b, k]) => {
    arr[a - 1] += k;
    if (b < arr.length) {
        arr[b] -= k;
    }
});

arr.reduce((a, b) => {
    const acc = a + b;
    result = Math.max(result, acc);
    return acc;
}, 0);

return result;
            • susahin80 + 1 comment

              This produces wrong answer in some of the tests.

              • Kanahaiya + 0 comments

                Hi,

                try this. Here is the video tutorial for my solution O(n+m) complexity.

                https://www.youtube.com/watch?v=hDhf04AJIRs&list=PLSIpQf0NbcCltzNFrOJkQ4J4AAjW3TSmA

                Would really appreciate your feedback like and comment etc. on my video.

        • jpeavey451 + 0 comments

          Your last for loop isn't needed. You can move Math.max to the previous for loop.

        • lyons_mr + 0 comments
          [deleted]
        • tyler_e_austin + 0 comments
          [deleted]
        • tyler_e_austin + 0 comments

          Added some ES6 syntax suger...

          const arrayManipulation2 = (n, queries) => {
  const arr = new Array(n).fill(0);
  let max = 0;
  for (let i = queries.length - 1; i >= 0; i--) {
    const [a, b, k] = queries[i];
    arr[a - 1] += k;
    if (b < arr.length) {
      arr[b] -= k;
    }
  }
  for (let j = 1; j < n; j++) {
    arr[j] += arr[j - 1];
  }
  for (let k = arr.length - 1; k >= 0; k--) {
    max = Math.max(max, arr[k]);
  }
  return max;
};
        • shubhanksrivast1 + 0 comments

          Got stuck because of this

          max = Math.max(...arr); // not working for big arrays

          Thanks man!