Find last element after deleting every second element in array of n integers
Given a circular array of size n containing integers from 1 to n. Find the last element that would remain in the list after erasing every second element starting from the first element.
Example:
Input: 5
Output: 3
Explanation
Element in circular array are:
1 2 3 4 5
Starting from first element i.e, '1'
delete every second element like this,
1 0 3 4 5
1 0 3 0 5
0 0 3 0 5
0 0 3 0 0
For demonstration purpose erased element
would be treated as '0'.
Thus at the end of list, the last element
remains is 3.
Input: 10
Output: 5
The Naive approach is to remove every second element from the array until the size of the array becomes equals to ‘1’. The time complexity of this approach is O(n2) which would not be feasible for a large value of ‘n’.
The Efficient approach is to use recursion. Let’s consider n to be even. In one traversal, numbers 2, 4, 6 … N will be removed and we start again from 1. Thus, exactly n/2 numbers are removed, and we start as if from 1 in an array of N/2 containing only odd digits 1, 3, 5, … n/2.
Thus, by this intuition, their recursive formula can be written as,
If n is even:
solve(n) = 2 * solve(n/2) - 1
else
solve(n) = 2 * solve((n-1) / 2) + 1
Base condition would occur when n = 1, then
answer would be 1.
Implementation:
C++
#include<iostream>
using namespace std;
int removeAlternate( int n)
{
if (n == 1)
return 1;
if (n % 2 == 0)
return 2
* removeAlternate(n / 2)
- 1;
else
return 2
* removeAlternate(((n - 1) / 2))
+ 1;
}
int main()
{
int n = 5;
cout << removeAlternate(n) << "\n" ;
n = 10;
cout << removeAlternate(n) << "\n" ;
return 0;
}
|
Java
import java.util.*;
class Circular {
public static int removeAlternate( int n)
{
if (n == 1 )
return 1 ;
if (n % 2 == 0 )
return 2
* removeAlternate(n / 2 )
- 1 ;
else
return 2 *
removeAlternate(((n - 1 ) / 2 ))
+ 1 ;
}
public static void main(String[] args)
{
int n = 5 ;
System.out.print(removeAlternate(n));
n = 10 ;
System.out.print( "\n" + removeAlternate(n));
}
}
|
Python3
def removeAlternate(n):
if (n = = 1 ):
return 1
if (n % 2 = = 0 ):
return 2
* removeAlternate(n / 2 )
- 1
else :
return 2
* removeAlternate(((n - 1 ) / 2 ))
+ 1
n = 5
print (removeAlternate(n))
n = 10
print (removeAlternate(n))
|
C#
using System;
class Circular {
public static int removeAlternate( int n)
{
if (n == 1)
return 1;
if (n % 2 == 0)
return 2
* removeAlternate(n / 2)
- 1;
else
return 2
* removeAlternate(((n - 1) / 2))
+ 1;
}
public static void Main()
{
int n = 5;
Console.WriteLine(removeAlternate(n));
n = 10;
Console.WriteLine(removeAlternate(n));
}
}
|
PHP
<?php
function removeAlternate( $n )
{
if ( $n == 1)
return 1;
if ( $n % 2 == 0)
return 2 * removeAlternate( $n / 2) - 1;
else
return 2 * removeAlternate((( $n - 1) /
2)) + 1;
}
$n = 5;
echo removeAlternate( $n ) , "\n" ;
$n = 10;
echo removeAlternate( $n ) , "\n" ;
?>
|
Javascript
<script>
function removeAlternate(n)
{
if (n == 1)
return 1;
if (n % 2 == 0)
return 2
* removeAlternate(n / 2)
- 1;
else
return 2
* removeAlternate(((n - 1) / 2))
+ 1;
}
let n = 5;
document.write(removeAlternate(n) + "<br>" );
n = 10;
document.write(removeAlternate(n) + "<br>" );
</script>
|
Time complexity: O(log(n))
Auxiliary space: O(1)
Most Another Approach:
Another approach is by observing the pattern in which the numbers repeat. I observed that the output were all odd numbers incremented by 2 every time the n value increased by one and the value got reset to ‘1’ at the powers of 2.
For example, The outputs were 1 1 3 1 3 5 7 1 3 5 7 9 11 13 15 1 respectively for the value of n ranging from 1 to 16.
Hence this approach uses the closest value of the power of 2 less than or equal to the given input.
Implementation:
C++
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int nearestPowerof2( int n)
{
int p = ( int )log2(n);
return p;
}
int circularElimination( int n)
{
int power=nearestPowerof2(n);
int result=1+2*(n- pow (2,power));
return result;
}
int main() {
int n=5;
int result=circularElimination(n);
cout<<result<< "\n" ;
n=10;
result=circularElimination(n);
cout<<result<< "\n" ;
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int highestPowerof2( int n)
{
int p = ( int )(Math.log(n) / Math.log( 2 ));
return p;
}
static int circularElimination( int n)
{
int power = highestPowerof2(n);
int res = 1 + 2 * ( int )(n - Math.pow( 2 , power));
return res;
}
public static void main(String[] args)
{
int n = 5 ;
System.out.println(circularElimination(n));
n = 10 ;
System.out.println(circularElimination(n));
}
}
|
Python3
import math
def nearestPowerof2(n):
p = int (math.log2(n))
return p
def circularElimination(n):
power = nearestPowerof2(n);
result = ( 1 + 2 *
(n - pow ( 2 ,power)))
return result
n = 5
result = circularElimination(n)
print (result)
n = 10
result = circularElimination(n)
print (result)
|
C#
using System;
class GFG{
static int highestPowerof2( int n)
{
int p = ( int )(Math.Log(n) /
Math.Log(2));
return p;
}
static int circularElimination( int n)
{
int power = highestPowerof2(n);
int res = 1 + 2 * ( int )(
n - Math.Pow(2, power));
return res;
}
public static void Main( string [] args)
{
int n = 5;
Console.WriteLine(circularElimination(n));
n = 10;
Console.WriteLine(circularElimination(n));
}
}
|
Javascript
<script>
function highestPowerof2(n)
{
let p = parseInt(Math.log(n) / Math.log(2), 10);
return p;
}
function circularElimination(n)
{
let power = highestPowerof2(n);
let res = 1 + 2 * (n - Math.pow(2, power));
return res;
}
let n = 5;
document.write(circularElimination(n) + "</br>" );
n = 10;
document.write(circularElimination(n));
</script>
|
Time Complexity: O(1)
Space Complexity: O(1)
Last Updated :
29 Jul, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...