Open In App

Modify array by removing (arr[i] + arr[i + 1])th element exactly K times

Last Updated : 23 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an array arr[] consisting of first N natural numbers, where arr[i] = i ( 1-based indexing ) and a positive integer K, the task is to print the array arr[] obtained after removing every (arr[i] + arr[i + 1])th element from the array in every ith operation exactly K times.

Examples:

Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8}, K = 2
Output: 1 2 4 5 7
Explanation:
Initially, the array arr[] is {1, 2, 3, 4, 5, 6, 7, 8}.
Operation 1: Delete every (A[1] + A[2])th element, i.e., every 3rd element from the array arr[]. Now the array modifies to {1, 2, 4, 5, 7, 8}.
Operation 2: Delete every (A[2] + A[3])th element, i.e., every 6th element from the array arr[]. Now the array modifies to {1, 2, 4, 5, 7}.
After performing the above operations, the array obtained is {1, 2, 4, 5, 7}.

Input: N = 10, K = 3
Output: 1 2 4 5 7 10

 

Approach: The given problem can be solved by performing the given operation exactly K times by deleting every (arr[i] + arr[i + 1])th term from the array in every ith operation. Follow the steps below to solve the problem:

  • Iterate over the range [0, K - 1] using the variable i, and perform the following steps:
    • Initialize an auxiliary array B[] to stores the elements of the array arr[] after each deletion operation.
    • Traverse the given array arr[] and if the current index is not divisible by the value (arr[i] + arr[i + 1]) then insert that element in the array B[].
    • After the above steps, insert all the elements of the array B[] in the array arr[].
  • After completing the above steps, print the array arr[] as the resultant array.

Below is the implementation of the above approach:

C++ 
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to modify array by removing
// every K-th element from the array
vector<int> removeEveryKth(vector<int> l, int k)
{

    for (int i = 0; i < l.size(); i++)
    {
        // Check if current element
        // is the k-th element
        if (i % k == 0)
            l[i] = 0;
    }
  
    // Stores the elements after
    // removing every kth element
    vector<int> arr;
    arr.push_back(0);

    for (int i = 1; i < l.size(); i++)
    {
      
        // Append the current element
        // if it is not k-th element
        if (l[i] != 0)
            arr.push_back(l[i]);
      }
  
    // Return the new array after
    // removing every k-th element
    return arr;
}

// Function to print the array
void printArray(vector<int> l)
{

    // Traverse the array l[]
    for (int i = 1; i < l.size(); i++)
        cout << l[i] << " ";
      cout << endl;
}

// Function to print the array after
// performing the given operations
// exactly k times
void printSequence(int n, int k)
{

    // Store first N natural numbers
    vector<int> l(n+1);

    for (int i = 0; i < n + 1; i++) l[i]=i;
    int x = 1;

    // Iterate over the range [0, k-1]
    for (int i = 0; i < k; i++)
    {

        // Store sums of the two
        // consecutive terms
        int p = l[x] + l[x + 1];

        // Remove every p-th
        // element from the array
        l = removeEveryKth(l, p);

        // Increment x by 1 for
        // the next iteration
        x += 1;
      }

    // Print the resultant array
    printArray(l);
}

// Driver Code
int main()
{
    // Given arrays
    int N = 8;
    int K = 2;

    //Function Call
    printSequence(N, K);

}

// This code is contributed by mohit kumar  29
Java 
// java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

public class GFG {

    // Function to modify array by removing
    // every K-th element from the array
    static int[] removeEveryKth(int l[], int k)
    {

        for (int i = 0; i < l.length; i++) {
            // Check if current element
            // is the k-th element
            if (i % k == 0)
                l[i] = 0;
        }

        // Stores the elements after
        // removing every kth element
        ArrayList<Integer> list = new ArrayList<>();
        list.add(0);

        for (int i = 1; i < l.length; i++) {

            // Append the current element
            // if it is not k-th element
            if (l[i] != 0)
                list.add(l[i]);
        }

        // Return the new array after
        // removing every k-th element
        return list.stream().mapToInt(i -> i).toArray();
    }

    // Function to print the array
    static void printArray(int l[])
    {

        // Traverse the array l[]
        for (int i = 1; i < l.length; i++)
            System.out.print(l[i] + " ");
        System.out.println();
    }

    // Function to print the array after
    // performing the given operations
    // exactly k times
    static void printSequence(int n, int k)
    {

        // Store first N natural numbers
        int l[] = new int[n + 1];

        for (int i = 0; i < n + 1; i++)
            l[i] = i;
        int x = 1;

        // Iterate over the range [0, k-1]
        for (int i = 0; i < k; i++) {

            // Store sums of the two
            // consecutive terms
            int p = l[x] + l[x + 1];

            // Remove every p-th
            // element from the array
            l = removeEveryKth(l, p);

            // Increment x by 1 for
            // the next iteration
            x += 1;
        }

        // Print the resultant array
        printArray(l);
    }

    // Driver Code
    public static void main(String[] args)
    {

        // Given arrays
        int N = 8;
        int K = 2;

        // Function Call
        printSequence(N, K);
    }
}

// This code is contributed by Kingash.
Python3 
# Python approach for the above approach

# Function to modify array by removing
# every K-th element from the array
def removeEveryKth(l, k):
  
    for i in range(0, len(l)):
      
        # Check if current element
        # is the k-th element
        if i % k == 0:
            l[i] = 0

    # Stores the elements after
    # removing every kth element
    arr = [0]
    
    for i in range(1, len(l)):
        
        # Append the current element
        # if it is not k-th element
        if l[i] != 0:
            arr.append(l[i])

    # Return the new array after
    # removing every k-th element
    return arr

# Function to print the array
def printArray(l):
  
    # Traverse the array l[]
    for i in range(1, len(l)):
        print(l[i], end =" ")

    print()

# Function to print the array after
# performing the given operations
# exactly k times
def printSequence(n, k):

    # Store first N natural numbers
    l = [int(i) for i in range(0, n + 1)]

    x = 1

    # Iterate over the range [0, k-1]
    for i in range(0, k):

        # Store sums of the two
        # consecutive terms
        p = l[x] + l[x + 1]

        # Remove every p-th
        # element from the array
        l = removeEveryKth(l, p)
        
        # Increment x by 1 for
        # the next iteration
        x += 1
    
    # Print the resultant array
    printArray(l)

# Driver Code
N = 8
K = 2

# Function Call
printSequence(N, K)
C# 
// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {

    // Function to modify array by removing
    // every K-th element from the array
    static List<int> removeEveryKth(List<int> l, int k)
    {

        for (int i = 0; i < l.Count; i++) {
            // Check if current element
            // is the k-th element
            if (i % k == 0)
                l[i] = 0;
        }

        // Stores the elements after
        // removing every kth element
        List<int> arr = new List<int>();
        arr.Add(0);

        for (int i = 1; i < l.Count; i++) {

            // Append the current element
            // if it is not k-th element
            if (l[i] != 0)
                arr.Add(l[i]);
        }

        // Return the new array after
        // removing every k-th element
        return arr;
    }

    // Function to print the array
    static void printArray(List<int> l)
    {

        // Traverse the array l[]
        for (int i = 1; i < l.Count; i++)
            Console.Write(l[i] + " ");
        Console.WriteLine();
    }

    // Function to print the array after
    // performing the given operations
    // exactly k times
    static void printSequence(int n, int k)
    {

        // Store first N natural numbers
        List<int> l = new List<int>();

        for (int i = 0; i < n + 1; i++)
            l.Add(i);
        int x = 1;

        // Iterate over the range [0, k-1]

        for (int i = 0; i < k; i++) {

            // Store sums of the two
            // consecutive terms
            int p = l[x] + l[x + 1];

            // Remove every p-th
            // element from the array
            l = removeEveryKth(l, p);

            // Increment x by 1 for
            // the next iteration
            x += 1;
        }

        // Print the resultant array
        printArray(l);
    }

    // Driver Code
    public static void Main()
    {
      
        // Given arrays
        int N = 8;
        int K = 2;

        // Function Call
        printSequence(N, K);
    }
}

// This code is contributed by ukasp.
JavaScript 
 <script>
 
        // Javascript program for the above approach

        // Function to modify array by removing
        // every K-th element from the array
        function removeEveryKth(l, k) {

            for (let i = 0; i < l.length; i++) {
                // Check if current element
                // is the k-th element
                if (i % k == 0)
                    l[i] = 0;
            }

            // Stores the elements after
            // removing every kth element
            let arr = [0];

            for (let i = 1; i < l.length; i++) {

                // Append the current element
                // if it is not k-th element
                if (l[i] != 0)
                    arr.push(l[i]);
            }

            // Return the new array after
            // removing every k-th element
            return arr;
        }

        // Function to print the array
        function printArray(l) {

            // Traverse the array l[]
            for (let i = 1; i < l.length; i++)
                document.write(l[i] + " ");

        }

        // Function to print the array after
        // performing the given operations
        // exactly k times
        function printSequence(n, k) {

            // Store first N natural numbers
            let l = [0];

            for (let i = 0; i < n + 1; i++) l[i] = i;
            let x = 1;

            // Iterate over the range [0, k-1]
            for (let i = 0; i < k; i++) {

                // Store sums of the two
                // consecutive terms
                let p = l[x] + l[x + 1];

                // Remove every p-th
                // element from the array
                l = removeEveryKth(l, p);

                // Increment x by 1 for
                // the next iteration
                x += 1;
            }

            // Print the resultant array
            printArray(l);
        }

        // Driver Code

        // Given arrays
        let N = 8;
        let K = 2;

        //Function Call
        printSequence(N, K);

        // This code is contributed by Hritik
        
    </script>

Output: 
1 2 4 5 7

 

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


S
spp____
Improve
Article Tags :
Practice Tags :

Similar Reads

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
Lightbox