Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

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

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

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:

Below is the implementation of the above approach:

// C++ Program to implement
// the above approach

#include <bits/stdc++.h>
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);
}

import java.util.*;

public class Main {

    // Print the required final sequence
    static void printSequence(int[] A, int n, int k) {
        // Stores the array element-index pairs
        Map<Integer, Set<Integer>> mp = new HashMap<>();

        // Stores the required sequence
        List<Integer> 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.computeIfAbsent(sol.get(i), key -> new HashSet<>()).add(i);
            } else {
                // Iterator to the first index containing sol[i]
                Iterator<Integer> idxx = mp.get(sol.get(i)).iterator();

                int idx = idxx.next();

                // Remove that occurrence
                idxx.remove();

                // Increment by K
                sol.set(idx, sol.get(idx) + k);

                // Insert the incremented element at that index
                mp.computeIfAbsent(sol.get(idx), key -> new HashSet<>()).add(idx);
                mp.computeIfAbsent(sol.get(i), key -> new HashSet<>()).add(i);
            }
        }

        // Print the final sequence
        for (int x : sol) {
            System.out.print(x + " ");
        }
    }

    // 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);
    }
}

# Python3 Program to implement the above approach

import collections

def printSequence(A, n, k):
    # Stores the array element-index pairs
    mp = collections.defaultdict(set)

    # Stores the required sequence
    sol = []

    # Insert all array elements
    for x in A:
        sol.append(x)

    for i in range(n):
        # If current element has not occurred previously
        if sol[i] not in mp or len(mp[sol[i]]) == 0:
            mp[sol[i]].add(i)
        # Otherwise
        else:
            # Get the first index containing sol[i]
            idx = mp[sol[i]].pop()

            # Increment by K
            sol[idx] += k

            # Insert the incremented element at that index
            mp[sol[idx]].add(idx)
            mp[sol[i]].add(i)

    # Print the final sequence
    print(" ".join(map(str, sol)))

# Driver Code
N = 5
K = 6
A = [1, 4, 1, 1, 4]
printSequence(A, N, K)

using System;
using System.Collections.Generic;

class Program {
  static void Main(string[] args) {
    int N = 5;
    int K = 6;
    List<int> A = new List<int> { 1, 4, 1, 1, 4 };
    printSequence(A, N, K);
  }

  static void printSequence(List<int> A, int n, int k) {
    // Stores the array element-index pairs
    Dictionary<int, HashSet<int>> mp = new Dictionary<int, HashSet<int>>();

    // Stores the required sequence
    List<int> sol = new List<int>();

    // Insert all array elements
    foreach (int x in A)
      sol.Add(x);

    for (int i = 0; i < n; i++) {
      // If current element has not occurred previously
      if (!mp.ContainsKey(sol[i]) || mp[sol[i]].Count == 0) {
        mp[sol[i]] = new HashSet<int>();
        mp[sol[i]].Add(i);
      }

      // Otherwise
      else {
        // Iterator to the first index containing sol[i]
        var idxx = mp[sol[i]].GetEnumerator();
        idxx.MoveNext();
        int idx = idxx.Current;

        // Remove that occurrence
        mp[sol[i]].Remove(idx);

        // Increment by K
        sol[idx] += k;

        // Insert the incremented element at that index
        if (!mp.ContainsKey(sol[idx])) {
          mp[sol[idx]] = new HashSet<int>();
        }
        mp[sol[idx]].Add(idx);
        mp[sol[i]].Add(i);
      }
    }

    // Print the final sequence
    foreach (int x in sol) {
      Console.Write(x + " ");
    }
  }
}

<script>

// Javascript program to implement
// the above approach

// Print the required final sequence
function printSequence(A, n, k)
{
    
    // Stores the array element-index pairs
    var mp = new Map();

    // Stores the required sequence
    var sol = [];

    // Insert all array elements
    A.forEach(x => {
        sol.push(x);
    });

    for(var i = 0; i < n; i++) 
    {
        
        // If current element has
        // not occurred previously
        if (!mp.has(sol[i]) || 
             mp.get(sol[i]).size == 0) 
        {
            var tmp = new Set();
            tmp.add(i)
            mp.set(sol[i],tmp)
        }

        // Otherwise
        else
        {
            
            // Iterator to the first index
            // containing sol[i]
            var idxx = [...mp.get(sol[i])].sort(
                (a, b) => a - b)[0];

            var idx = idxx;

            // Remove that occurrence
            var x = mp.get(sol[i]);
            x.delete(idxx);
            mp.set(sol[i], x);

            // Increment by K
            sol[idx] += k;

            // Insert the incremented
            // element at that index
            if (!mp.has(sol[idx]))
                mp.set(sol[idx], new Set())
                
            x = mp.get(sol[idx]);
            x.add(idx);
            mp.set(sol[idx], x);

            x = mp.get(sol[i]);
            x.add(i);
            mp.set(sol[i], x);
        }
    }

    // Print the final sequence
    sol.forEach(x => {
        document.write(x + " ");
    });
}

// Driver Code
var N = 5;
var K = 6;
var A = [ 1, 4, 1, 1, 4 ];

printSequence(A, N, K);

// This code is contributed by importantly

</script>

Output
7 10 7 1 4

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


 

Article Tags :
Arrays
DSA
Hash
Searching
Recommended Articles
1. Group multiple occurrence of array elements ordered by first occurrence
2. Find array sum after incrementing by K adjacent elements of every positive element M times
3. Print Array after moving first occurrence of given element to end in given Array for Q queries
4. Modify array by making all array elements equal to 0 by subtracting K^i from an array element in every i-th step
5. Construct array B as last element left of every suffix array obtained by performing given operations on every suffix of given array
6. Minimize replacements to make every element in an array exceed every element in another given array
7. Modify array by replacing every array element with minimum possible value of arr[j] + |j - i|
8. Lexicographically largest array possible from first N natural numbers such that every repetition is present at distance equal to its value from its previous occurrence
9. Find starting index for every occurrence of given array B in array A using Z-Algorithm
10. Partition array into two subarrays with every element in the right subarray strictly greater than every element in left subarray
11. Modify given array by reducing each element by its next smaller element
12. Modify a Linked List to contain last occurrences of every duplicate element
13. Check if a Zero Array can be converted to a given Array by incrementing some elements with X^i
14. Maximize the smallest array element by incrementing all elements in a K-length subarray by 1 exactly M times
15. Count operations to sort the Array by incrementing each element of increasing subsegment by 1
16. Modify a given array by replacing each element with the sum or product of their digits based on a given condition
17. Modify array to another given array by replacing array elements with the sum of the array
18. Modify array to another given array by replacing array elements with the sum of the array | Set-2
19. Queries to search for an element in an array and modify the array based on given conditions
20. Modify sequence of first N natural numbers to a given array by replacing pairs with their GCD
21. Count occurrences of substring X before every occurrence of substring Y in a given string
22. How to Find First Occurrence of an Element in a Set in C++?
23. Insert duplicate of K adjacent to it for it's every occurrence in array
24. Maximize first element of Array by deleting first or adding a previously deleted element
25. Largest element smaller than current element on left for every element in Array