Print alternate elements of an array
Last Updated :
26 Apr, 2023
Given an array, arr[] of size N, the task is to print the elements of the given array present at odd indices (1-based indexing).
Examples:
Input: arr[] = {1, 2, 3, 4, 5}
Output: 1 3 5
Explanation:
Array element present at odd positions are: {1, 3, 5}.
Therefore, the required output is 1 3 5.
Input: arr[] = {-5, 1, 4, 2, 12}
Output: -5 4 12
Naive Approach: The simplest approach to solve this problem is to traverse the given array and check if the position of the current element is odd or not. If found to be true, then print the current element.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void printAlter( int arr[], int N)
{
for ( int currIndex = 0;
currIndex < N; currIndex++) {
if (currIndex % 2 == 0) {
cout << arr[currIndex] << " " ;
}
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
printAlter(arr, N);
}
|
C
#include <stdio.h>
void printAlter( int arr[], int N)
{
for ( int currIndex = 0;
currIndex < N; currIndex++) {
if (currIndex % 2 == 0) {
printf ( "%d " , arr[currIndex]);
}
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
printAlter(arr, N);
}
|
Java
import java.io.*;
class GFG{
static void printAlter( int [] arr, int N)
{
for ( int currIndex = 0 ;
currIndex < N;
currIndex++)
{
if (currIndex % 2 == 0 )
{
System.out.print(arr[currIndex] + " " );
}
}
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
printAlter(arr, N);
}
}
|
Python3
def printAlter(arr, N):
for currIndex in range ( 0 , N):
if (currIndex % 2 = = 0 ):
print (arr[currIndex], end = " " )
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
printAlter(arr, N)
|
C#
using System;
class GFG{
static void printAlter( int [] arr, int N)
{
for ( int currIndex = 0;
currIndex < N;
currIndex++)
{
if (currIndex % 2 == 0)
{
Console.Write(arr[currIndex] + " " );
}
}
}
public static void Main()
{
int [] arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
printAlter(arr, N);
}
}
|
Javascript
function printAlter(arr, N)
{
for ( var currIndex = 0; currIndex < N; currIndex++)
{
if (currIndex % 2 == 0)
{
document.write(arr[currIndex] + " " );
}
}
}
var arr = [ 1, 2, 3, 4, 5 ]
var N = arr.length;
printAlter(arr, N);
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Recursive Approach : Here is the recursive solution of the same idea, to print the alternate elements, we have to increase the index with +2.
Following is the implementation.
C++
#include <bits/stdc++.h>
using namespace std;
void solve( int arr[], int N, int i)
{
if (i == N) {
return ;
}
if (i == N - 1) {
cout << arr[i] << " " ;
return ;
}
cout << arr[i] << " " ;
solve(arr, N, i + 2);
}
void printAlter( int arr[], int N)
{
solve(arr, N, 0);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int N = sizeof (arr) / sizeof (arr[0]);
printAlter(arr, N);
}
|
Java
import java.util.*;
public class Main {
static void solve( int arr[], int N, int i)
{
if (i == N) {
return ;
}
if (i == N - 1 ) {
System.out.print(arr[i] + " " );
return ;
}
System.out.print(arr[i] + " " );
solve(arr, N, i + 2 );
}
static void printAlter( int arr[], int N)
{
solve(arr, N, 0 );
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
int N = arr.length;
printAlter(arr, N);
}
}
|
Python3
def solve(arr, N, i):
if i = = N:
return
if i = = N - 1 :
print (arr[i], end = " " )
return
print (arr[i], end = " " )
solve(arr, N, i + 2 )
def printAlter(arr, N):
solve(arr, N, 0 )
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
N = len (arr)
printAlter(arr, N)
|
C#
using System;
class Program {
static void solve( int [] arr, int N, int i)
{
if (i == N) {
return ;
}
if (i == N - 1) {
Console.Write(arr[i] + " " );
return ;
}
Console.Write(arr[i] + " " );
solve(arr, N, i + 2);
}
static void printAlter( int [] arr, int N)
{
solve(arr, N, 0);
}
static void Main()
{
int [] arr = { 1, 2, 3, 4, 5, 6, 7 };
int N = arr.Length;
printAlter(arr, N);
}
}
|
Javascript
function solve(arr, N, i) {
if (i == N) {
return ;
}
if (i == N - 1) {
ans.push(arr[i]);
return ;
}
ans.push(arr[i]);
solve(arr, N, i + 2);
}
function printAlter(arr, N) {
solve(arr, N, 0);
}
let arr = [1, 2, 3, 4, 5, 6, 7];
let N = arr.length;
let ans = [];
printAlter(arr, N);
console.log(ans.join( " " ));
|
Time Complexity: O(N)
Auxiliary Space: O(N), for recursive call stack
Efficient Approach: To optimize the above approach, the idea is to traverse only those elements of the given array which are present at odd positions. Follow the steps below to solve the problem:
- Iterate a loop with a loop variable currIndex from 0 to N.
- Print the value of arr[currIndex] and increment the value of currIndex by 2 until currIndex exceeds N.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void printAlter( int arr[], int N)
{
for ( int currIndex = 0;
currIndex < N; currIndex += 2) {
cout << arr[currIndex] << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
printAlter(arr, N);
}
|
C
#include <stdio.h>
void printAlter( int arr[], int N)
{
for ( int currIndex = 0;
currIndex < N; currIndex += 2) {
printf ( "%d " , arr[currIndex]);
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
printAlter(arr, N);
}
|
Java
import java.io.*;
class GFG{
static void printAlter( int [] arr, int N)
{
for ( int currIndex = 0 ;
currIndex < N;
currIndex += 2 )
{
System.out.print(arr[currIndex] + " " );
}
}
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
printAlter(arr, N);
}
}
|
Python3
def printAlter(arr, N):
for currIndex in range ( 0 , N, 2 ):
print (arr[currIndex], end = " " )
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
printAlter(arr, N)
|
C#
using System;
class GFG{
static void printAlter( int [] arr, int N)
{
for ( int currIndex = 0;
currIndex < N;
currIndex += 2)
{
Console.Write(arr[currIndex] + " " );
}
}
public static void Main()
{
int [] arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
printAlter(arr, N);
}
}
|
Javascript
<script>
function printAlter(arr, N)
{
for ( var currIndex = 0;
currIndex < N; currIndex += 2)
{
document.write( arr[currIndex] + " " );
}
}
var arr= [ 1, 2, 3, 4, 5 ];
var N = 5;
printAlter(arr, N);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Method 3: Using Slicing in Python:
Slice by using python list slicing by setting step value to 2.
Below is the implementation:
C++
#include <iostream>
using namespace std;
void PrintAlter( int arr[], int N)
{
for ( int i = 0; i < N; i += 2) {
cout << arr[i] << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int N = sizeof (arr) / sizeof (arr[0]);
PrintAlter(arr, N);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static void PrintAlter( int [] arr, int N)
{
for ( int i = 0 ; i < N; i += 2 ) {
System.out.print(arr[i] + " " );
}
}
public static void main (String[] args) {
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int N = arr.length;
PrintAlter(arr, N);
}
}
|
Python3
def printAlter(arr, N):
print ( * arr[:: 2 ])
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ]
N = len (arr)
printAlter(arr, N)
|
C#
using System;
class Program {
static void PrintAlter( int [] arr, int N)
{
for ( int i = 0; i < N; i += 2) {
Console.Write(arr[i] + " " );
}
}
static void Main( string [] args)
{
int [] arr = { 1, 2, 3, 4, 5 };
int N = arr.Length;
PrintAlter(arr, N);
}
}
|
Javascript
function printAlter(arr, N) {
console.log(...arr.filter((_, i) => i % 2 === 0));
}
const arr = [1, 2, 3, 4, 5];
const N = arr.length;
printAlter(arr, N);
|
Time Complexity: O(N)
Space Complexity: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...