Given an array arr[](1-based indexing) consisting of N integers, the task is to find the last element remaining element after repeated removal of array element at perfect square indices.
Examples:
Input: arr[] = {1, 2, 3, 4, 5}
Output: 5
Explanation:
Following the removal of array element at perfect square indices that are performed:
- Removing array elements at indices 1 and 4 modifies the array to {2, 3, 5}.
- Removing array elements at indices 1 modifies the array to {3, 5}.
- Removing array elements at indices 1 modifies the array to {5}.
After performing the above operations, the array element remains is 5. Therefore, print 5.
Input: arr[] = {2, 3, 4, 4, 2, 4, -3, 1, 1}
Output: -3
Naive Approach: The given problem can be solved by removing the array elements at perfect square indices and then copy all the elements to the new array. Keep performing this step until only one element remains in the array. After completing the above steps, print the last element that remains.
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: The above approach can also be optimized by finding the potential last remaining array elements until that element is not present at perfect square indices. Follow the steps below to solve the given problem:
- Initialize a variable, say ans as N that stores the last remaining indices after performing the given operations.
- Iterate until the value of N is greater than 1 and perform the following steps:
- Find the count of elements that can be discarded, say D as sqrt(N).
- If the square of D is N then N can’t be the last remaining element as it is removed. So decrement the value of ans by 1 as the next potential remaining indices.
- Decrement the value of N by D.
- After completing the above steps, print the element at index (D – 1) as the remaining possible element.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find last remaining index // after repeated removal of perfect // square indices int findRemainingIndex( int N)
{ // Initialize the ans variable as N
int ans = N;
// Iterate a while loop and discard
// the possible values
while (N > 1) {
// Total discarded values
int discard = int ( sqrt (N));
// Check if this forms a
// perfect square
if (discard * discard == N) {
// Decrease answer by 1
ans--;
}
// Subtract the value from
// the current value of N
N -= discard;
}
// Return the value remained
return ans;
} // Function to find last remaining element // after repeated removal of array element // at perfect square indices void findRemainingElement( int arr[], int N)
{ // Find the remaining index
int remainingIndex = findRemainingIndex(N);
// Print the element at that
// index as the result
cout << arr[remainingIndex - 1];
} // Driver Code signed main()
{ int arr[] = { 2, 3, 4, 4, 2, 4, -3, 1, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
findRemainingElement(arr, N);
return 0;
} |
// Java implementation of the above approach import java.util.*;
import java.lang.*;
import java.lang.Math;
class GFG {
// Function to find last remaining index // after repeated removal of perfect // square indices static int findRemainingIndex( int N)
{ // Initialize the ans variable as N
int ans = N;
// Iterate a while loop and discard
// the possible values
while (N > 1 ) {
// Total discarded values
int discard = ( int )(Math.sqrt(N));
// Check if this forms a
// perfect square
if (discard * discard == N) {
// Decrease answer by 1
ans--;
}
// Subtract the value from
// the current value of N
N -= discard;
}
// Return the value remained
return ans;
} // Function to find last remaining element // after repeated removal of array element // at perfect square indices static void findRemainingElement( int arr[], int N)
{ // Find the remaining index
int remainingIndex = findRemainingIndex(N);
// Print the element at that
// index as the result
System.out.print(arr[remainingIndex - 1 ]);
} // Driver Code
public static void main(String[] args)
{
// Given input
int arr[] = { 2 , 3 , 4 , 4 , 2 , 4 , - 3 , 1 , 1 };
int N = 9 ;
findRemainingElement(arr, N);
}
} // This code is contributed by dwivediyash |
# Python 3 program for the above approach from math import sqrt
# Function to find last remaining index # after repeated removal of perfect # square indices def findRemainingIndex(N):
# Initialize the ans variable as N
ans = N
# Iterate a while loop and discard
# the possible values
while (N > 1 ):
# Total discarded values
discard = int (sqrt(N))
# Check if this forms a
# perfect square
if (discard * discard = = N):
# Decrease answer by 1
ans - = 1
# Subtract the value from
# the current value of N
N - = discard
# Return the value remained
return ans
# Function to find last remaining element # after repeated removal of array element # at perfect square indices def findRemainingElement(arr, N):
# Find the remaining index
remainingIndex = findRemainingIndex(N)
# Print the element at that
# index as the result
print (arr[remainingIndex - 1 ])
# Driver Code if __name__ = = '__main__' :
arr = [ 2 , 3 , 4 , 4 , 2 , 4 , - 3 , 1 , 1 ]
N = len (arr)
findRemainingElement(arr, N)
# This code is contributed by SURENDRA_GANGWAR.
|
// C# program for the above approach using System;
class GFG {
// Function to find last remaining index // after repeated removal of perfect // square indices static int findRemainingIndex( int N)
{ // Initialize the ans variable as N
int ans = N;
// Iterate a while loop and discard
// the possible values
while (N > 1) {
// Total discarded values
int discard = ( int )(Math.Sqrt(N));
// Check if this forms a
// perfect square
if (discard * discard == N) {
// Decrease answer by 1
ans--;
}
// Subtract the value from
// the current value of N
N -= discard;
}
// Return the value remained
return ans;
} // Function to find last remaining element // after repeated removal of array element // at perfect square indices static void findRemainingElement( int [] arr, int N)
{ // Find the remaining index
int remainingIndex = findRemainingIndex(N);
// Print the element at that
// index as the result
Console.Write(arr[remainingIndex - 1]);
} // Driver Code
public static void Main()
{
// Given input
int [] arr = { 2, 3, 4, 4, 2, 4, -3, 1, 1 };
int N = 9;
findRemainingElement(arr, N);
}
} // This code is contributed by code_hunt. |
<script> // JavaScript Program to implement
// the above approach
// Function to find last remaining index
// after repeated removal of perfect
// square indices
function findRemainingIndex(N) {
// Initialize the ans variable as N
let ans = N;
// Iterate a while loop and discard
// the possible values
while (N > 1) {
// Total discarded values
let discard = Math.floor(Math.sqrt(N));
// Check if this forms a
// perfect square
if (discard * discard == N) {
// Decrease answer by 1
ans--;
}
// Subtract the value from
// the current value of N
N -= discard;
}
// Return the value remained
return ans;
}
// Function to find last remaining element
// after repeated removal of array element
// at perfect square indices
function findRemainingElement(arr, N) {
// Find the remaining index
let remainingIndex = findRemainingIndex(N);
// Print the element at that
// index as the result
document.write(arr[remainingIndex - 1]);
}
// Driver Code
let arr = [2, 3, 4, 4, 2, 4, -3, 1, 1];
let N = arr.length;
findRemainingElement(arr, N);
// This code is contributed by Potta Lokesh </script>
|
-3
Time Complexity: O(sqrt(N))
Auxiliary Space: O(1)