Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Insert duplicate of K adjacent to it for it’s every occurrence in array

  • Difficulty Level : Expert
  • Last Updated : 10 Aug, 2021

Given an array arr consisting of N integers and an integer K, the task is to insert an adjacent K for every occurrence of it in the original sequence and then truncate the array to the original length using an O(1) auxiliary space.

Examples:  

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 0, 2, 3, 0, 4, 5, 0}, K = 0 
Output: {1, 0, 0, 2, 3, 0, 0, 4} 
Explanation: 
The given array {1, 0, 2, 3, 0, 4, 5, 0} is modified to {1, 0, 0, 2, 3, 0, 0, 4] after insertion of two 0’s and truncation of extra elements.



Input: arr[] = {7, 5, 8}, K = 8 
Output: {7, 5, 8} 
Explanation: 
After inserting an adjacent 8 into the array, it got truncated to restore the original size of the array.  

Approach 1: Using STL functions 
This problem can be solved by using built-in functions pop_back() and insert() .

Below is the implementation of the above approach: 

C++




// C++ implementation to update each entry of zero
// with two zero entries adjacent to each other
#include <bits/stdc++.h>
using namespace std;
 
// Function to update each entry of zero
// with two zero entries adjacent to each other
vector<int> duplicateK(vector<int>& arr)
{
    int N = arr.size();
    for(int i=0;i<N;i++)
    {
        if(arr[i] == 0)
        {
            // Insert an adjacent 0
            arr.insert(arr.begin() + i + 1, 0);
 
            i++;
 
            // Pop the last element
            arr.pop_back();
        }
    }
     
    return arr;
}
 
// Driver code
int main(int argc, char* argv[])
{
    vector<int> arr
= { 1, 0, 2, 3, 0, 4, 5, 0  };
 
    vector<int> ans = duplicateK(arr);
 
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
 
    return 0;
}

Java




// Java implementation to update each
// entry of zero with two zero entries
// adjacent to each other
import java.util.*;
 
class GFG{
 
// Function to update each entry of
// zero with two zero entries
// adjacent to each other
static Vector<Integer> duplicateK(Vector<Integer> arr)
{
    int N = arr.size();
    for(int i = 0; i < N; i++)
    {
       if(arr.get(i) == 0)
       {
            
           // Insert an adjacent 0
           arr.add(i + 1, 0);
            
           i++;
            
           // Pop the last element
           arr.remove(arr.size() - 1);
       }
    }
    return arr;
}
 
// Driver code
public static void main(String[] args)
{
    Integer []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
     
    Vector<Integer> vec = new Vector<Integer>();;
    for(int i = 0; i < arr.length; i++)
       vec.add(arr[i]);
         
    Vector<Integer> ans = duplicateK(vec);
 
    for(int i = 0; i < ans.size(); i++)
       System.out.print(ans.get(i) + " ");
}
}
 
// This code is contributed by gauravrajput1

C#




// C# implementation to update each
// entry of zero with two zero entries
// adjacent to each other
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to update each entry of
// zero with two zero entries
// adjacent to each other
static List<int> duplicateK(List<int> arr)
{
    int N = arr.Count;
    for(int i = 0; i < N; i++)
    {
        if(arr[i] == 0)
        {
                 
            // Insert an adjacent 0
            arr.Insert(i + 1, 0);
                 
            i++;
                 
            // Pop the last element
            arr.RemoveAt(arr.Count - 1);
        }
    }
    return arr;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
     
    List<int> vec = new List<int>();;
    for(int i = 0; i < arr.Length; i++)
    vec.Add(arr[i]);
         
    List<int> ans = duplicateK(vec);
 
    for(int i = 0; i < ans.Count; i++)
    Console.Write(ans[i] + " ");
}
}
 
// This code is contributed by gauravrajput1

Javascript




<script>
 
// Javascript implementation to update each entry of zero
// with two zero entries adjacent to each other
 
// Function to update each entry of zero
// with two zero entries adjacent to each other
function duplicateK(arr)
{
    var N = arr.length;
    for(var i=0;i<N;i++)
    {
        if(arr[i] == 0)
        {
            // Insert an adjacent 0
            arr.splice(i+1, 0, 0);
            i++;
 
            // Pop the last element
            arr.pop();
        }
    }
     
    return arr;
}
 
// Driver code
 
var arr=[ 1, 0, 2, 3, 0, 4, 5, 0 ];
 
var ans = duplicateK(arr);
 
for (var i = 0; i < ans.length; i++)
    document.write( ans[i] + " ");
 
</script>

Output: 

1 0 0 2 3 0 0 4 

Approach 2: Using Two Pointer Technique 

  • Since each K needs to be updated with two K entries adjacent to each other, the array will increase in length by an amount equal to the number of K that are present in the original array arr[].
  • Find the total number of K, then we assume we have an array with enough space to accommodate every element.
  • Initialize a variable write_idx that will point to the index at the end of this imaginary array and another pointer curr at the end of the current array, which is arr[N-1].
  • Iterate from the end and for each element we assume that we are copying the element to its current position, but copy only if the write_idx < N, and keep updating the write_idx each time. For an element with a value of zero, write it twice.

Below is the implementation of the above approach: 

C++




// C++ implementation to update each entry of zero
// with two zero entries adjacent to each other
#include <bits/stdc++.h>
using namespace std;
 
// Function to update each entry of zero
// with two zero entries adjacent to each other
vector<int> duplicateZeros(vector<int>& arr)
{
    const int N = arr.size();
 
    // Find the count of total number of zeros
    int cnt = count(arr.begin(), arr.end(), 0);
 
    // Variable to store index where elements
    // will be written in the final array
    int write_idx = N + cnt - 1;
 
    // Variable to point the current index
    int curr = N - 1;
 
    while (curr >= 0 && write_idx >= 0) {
        // Keep the current element to its correct
        // position, if that is within the size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
 
        write_idx -= 1;
 
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0) {
            if (write_idx < N)
                arr[write_idx] = 0;
 
            write_idx -= 1;
        }
 
        --curr;
    }
 
    // Return the final result
    return arr;
}
 
// Driver code
int main(int argc, char* argv[])
{
    vector<int> arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
 
    vector<int> ans = duplicateZeros(arr);
 
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
 
    return 0;
}

Java




// Java implementation to update
// each entry of zero with two zero
// entries adjacent to each other
class GFG{
 
// Function to update each
// entry of zero with two zero
// entries adjacent to each other
static int[] duplicateZeros(int []arr)
{
     
    int N = arr.length;
     
    // Find the count of
    // total number of zeros
    int cnt = count(arr, 0);
     
    // Variable to store index
    // where elements will be
    // written in the final array
    int write_idx = N + cnt - 1;
     
    // Variable to point the current index
    int curr = N - 1;
     
    while (curr >= 0 && write_idx >= 0)
    {
         
        // Keep the current element
        // to its correctposition, if
        // that is within the size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
     
        write_idx -= 1;
     
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0)
        {
            if (write_idx < N)
                arr[write_idx] = 0;
                 
            write_idx -= 1;
        }
        --curr;
    }
     
    // Return the final result
    return arr;
}
 
static int count(int []arr, int num)
{
    int ans = 0;
    for(int i : arr)
     
       if(i == num)
          ans++;
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
    int []ans = duplicateZeros(arr);
 
    for(int i = 0; i < ans.length; i++)
       System.out.print(ans[i] + " ");
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 implementation to update each entry of zero
# with two zero entries adjacent to each other
 
# Function to update each entry of zero
# with two zero entries adjacent to each other
def duplicateZeros(arr):
 
    N = len(arr)
 
    # Find the count of total number of zeros
    cnt = arr.count(0)
 
    # Variable to store index where elements
    # will be written in the final array
    write_idx = N + cnt - 1
 
    # Variable to point the current index
    curr = N - 1
 
    while (curr >= 0 and write_idx >= 0):
         
        # Keep the current element to its correct
        # position, if that is within the size N
        if (write_idx < N):
            arr[write_idx] = arr[curr]
 
        write_idx -= 1
 
        # Check if the current element is also
        # zero then again write its duplicate
        if (arr[curr] == 0):
            if (write_idx < N):
                arr[write_idx] = 0
 
            write_idx -= 1
 
        curr -= 1
 
    # Return the final result
    return arr
 
# Driver Code
arr = [ 1, 0, 2, 3, 0, 4, 5, 0 ]
 
ans = duplicateZeros(arr)
for i in range(len(ans)):
    print(ans[i], end = " ")
     
# This code is contributed by divyamohan123

C#




// C# implementation to update
// each entry of zero with two zero
// entries adjacent to each other
using System;
 
class GFG{
 
// Function to update each
// entry of zero with two zero
// entries adjacent to each other
static int[] duplicateZeros(int []arr)
{
    int N = arr.Length;
     
    // Find the count of
    // total number of zeros
    int cnt = count(arr, 0);
     
    // Variable to store index
    // where elements will be
    // written in the readonly array
    int write_idx = N + cnt - 1;
     
    // Variable to point the
    // current index
    int curr = N - 1;
     
    while (curr >= 0 && write_idx >= 0)
    {
         
        // Keep the current element
        // to its correctposition, if
        // that is within the size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
     
        write_idx -= 1;
     
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0)
        {
            if (write_idx < N)
                arr[write_idx] = 0;
                 
            write_idx -= 1;
        }
        --curr;
    }
     
    // Return the readonly result
    return arr;
}
 
static int count(int []arr, int num)
{
    int ans = 0;
    foreach(int i in arr)
    {
        if(i == num)
           ans++;
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
    int []ans = duplicateZeros(arr);
 
    for(int i = 0; i < ans.Length; i++)
       Console.Write(ans[i] + " ");
}
}
 
// This code is contributed by Amit Katiyar

Javascript




<script>
 
// JavaScript implementation to update each entry of zero
// with two zero entries adjacent to each other
 
// Function to update each entry of zero
// with two zero entries adjacent to each other
function duplicateZeros(arr)
{
    const N = arr.length;
 
    // Find the count of total number of zeros
    let cnt = 0;
    for(let i = 0; i < arr.length; ++i){
        if(arr[i] == 0)
            cnt++;
    }
 
    // Variable to store index where elements
    // will be written in the final array
    let write_idx = N + cnt - 1;
 
    // Variable to point the current index
    let curr = N - 1;
 
    while (curr >= 0 && write_idx >= 0) {
        // Keep the current element to its correct
        // position, if that is within the size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
 
        write_idx -= 1;
 
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0) {
            if (write_idx < N)
                arr[write_idx] = 0;
 
            write_idx -= 1;
        }
 
        --curr;
    }
 
    // Return the final result
    return arr;
}
 
// Driver code
    let arr = [ 1, 0, 2, 3, 0, 4, 5, 0 ];
 
    let ans = duplicateZeros(arr);
 
    for (let i = 0; i < ans.length; i++)
        document.write(ans[i] + " ");
 
 
// This code is contributed by Surbhi Tyagi.
 
</script>
Output: 
1 0 0 2 3 0 0 4

 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :