# Modify given array by incrementing first occurrence of every element by K

• Difficulty Level : Hard
• Last Updated : 01 Jul, 2022

Given an array arr[] consisting of N integers, read every element of the array one by one and perform the following operations:

• If the current element arr[i] had previously occurred in the array, increase its first occurrence by K.
• Otherwise, insert arr[i] into the sequence

The task is to print the final sequence of integers obtained by performing the above operations

Examples:

Input: arr[] = {1, 2, 3, 2, 3}, K = 1
Output: [1, 4, 3, 2, 3]
Explanation:

Arrival : 1
Since 1 is the first element in the stream, simply insert it into the solution.
Therefore, b[] = [1]

Arrival: 2
Since 2 is not existing in the array, simply insert it into the solution.
Therefore, b[] = [1, 2]

Arrival: 3
Since 3 is not existing in the array, simply insert it into the solution.
Therefore, b[] = [1, 2, 3]

Arrival: 2
Since 2 already exists, increasing its first occurrence by K(=1)modifies the array b[] to [1, 3, 3, 2]

Arrival: 3
Since 3 already exists, increasing its first occurrence by K(=1)modifies the array b[] to [1, 4, 3, 2, 3]

Input: arr[] = {1, 4, 1, 1, 4}, K = 6
Output: [7, 10, 7, 1, 4]

Naive Approach: The simplest approach to solve the problem is to traverse the array, and for every array element arr[i], traverse in the range [0, i – 1] to check if arr[i] is already present in the array or not. If found to be true, increase the first occurrence of arr[i] by K.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized using Hashing. Follow the steps below to solve the problem:

• Traverse the array and store the occurrence of every array element in a Map paired with the index of its occurrence in increasing order.
• If arr[i] is found to be already present in the Map, remove the first occurrence of arr[i] from the Map. Insert that index paired with arr[i] + K as the key back into the Map.
• Repeat the above steps for all array elements. Once, the entire array is traversed, obtain the sequence of integers from the Map and print the final sequence.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Print the required final sequence``void` `printSequence(vector<``int``>& A,``                   ``int` `n, ``int` `k)``{``    ``// Stores the array element-index pairs``    ``unordered_map<``int``, set<``int``> > mp;` `    ``// Stores the required sequence``    ``vector<``int``> sol;` `    ``// Insert all array elements``    ``for` `(``int` `x : A)``        ``sol.push_back(x);` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``// If current element has``        ``// not occurred previously``        ``if` `(mp.find(sol[i]) == mp.end()``            ``|| mp[sol[i]].size() == 0) {``            ``mp[sol[i]].insert(i);``        ``}` `        ``// Otherwise``        ``else` `{` `            ``// Iterator to the first index``            ``// containing sol[i]``            ``auto` `idxx = mp[sol[i]].begin();` `            ``int` `idx = *idxx;` `            ``// Remove that occurrence``            ``mp[sol[i]].erase(idxx);` `            ``// Increment by K``            ``sol[idx] += k;` `            ``// Insert the incremented``            ``// element at that index``            ``mp[sol[idx]].insert(idx);``            ``mp[sol[i]].insert(i);``        ``}``    ``}` `    ``// Print the final sequence``    ``for` `(``int` `x : sol) {``        ``cout << x << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ``int` `K = 6;``    ``vector<``int``> A = { 1, 4, 1, 1, 4 };``    ``printSequence(A, N, K);``}`

## Java

 `// Java Program to implement the above approach``import` `java.util.*;` `public` `class` `Main {``    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``5``;``        ``int` `K = ``6``;``        ``int``[] A = { ``1``, ``4``, ``1``, ``1``, ``4` `};``        ``printSequence(A, N, K);``    ``}` `    ``// Print the required final sequence``    ``public` `static` `void` `printSequence(``int``[] A, ``int` `n, ``int` `k)``    ``{``        ``// Stores the array element-index pairs``        ``HashMap > mp``            ``= ``new` `HashMap<>();` `        ``// Stores the required sequence``        ``ArrayList sol = ``new` `ArrayList<>();` `        ``// Insert all array elements``        ``for` `(``int` `x : A) {``            ``sol.add(x);``        ``}``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``// If current element has``            ``// not occurred previously``            ``if` `(!mp.containsKey(sol.get(i))``                ``|| mp.get(sol.get(i)).size() == ``0``) {``                ``mp.put(sol.get(i),``                       ``new` `ArrayList<>(Arrays.asList(i)));``            ``}``            ``// Otherwise``            ``else` `{``                ``// first index containing sol[i]``                ``int` `idx = mp.get(sol.get(i)).get(``0``);` `                ``// Remove that occurrence``                ``mp.get(sol.get(i)).remove((Integer)idx);` `                ``// Increment by K``                ``sol.set(idx, sol.get(idx) + k);` `                ``// Insert the incremented``                ``// element at that index``                ``mp.putIfAbsent(``                    ``sol.get(idx),``                    ``new` `ArrayList<>(Arrays.asList()));``                ``mp.get(sol.get(idx)).add((Integer)idx);` `                ``mp.putIfAbsent(``                    ``sol.get(i),``                    ``new` `ArrayList<>(Arrays.asList()));``                ``mp.get(sol.get(i)).add((Integer)i);``            ``}``        ``}``        ``// Print the final sequence``        ``for` `(``int` `x : sol) {``            ``System.out.print(x + ``" "``);``        ``}``    ``}``}` `// This code is contributed by Tapesh (tapeshdua420)`

## Javascript

 ``

Output:

`7 10 7 1 4`

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up