Given an array arr[] of size N, the task is to perform the following operation exactly N times,
Create an empty list of integers b[] and in the ith operation,
- Append arr[i] to the end of b[].
- Reverse the elements in b[].
Finally, print the contents of the list b[] after the end of all operations.
Examples:
Input: arr[] = {1, 2, 3, 4}
Output: 4 2 1 3
| Operation | b[] |
|---|
| 1 | {1} |
| 2 | {2, 1} |
| 3 | {3, 1, 2} |
| 4 | {4, 2, 1, 3} |
Input: arr[] = {1, 2, 3}
Output: 3 1 2
Approach: We need some observations to solve this problem. Suppose the number of elements in the array is even. Say our array is {4, 8, 6, 1, 7, 9}.
| Operation | b[] |
|---|
| 1 | {4} |
| 2 | {8, 4} |
| 3 | {6, 4, 8} |
| 4 | {1, 8, 4, 6} |
| 5 | {7, 6, 4, 8, 1} |
| 6 | {9, 1, 8, 4, 6, 7} |
After carefully observing, we conclude that for even size of elements in the array the numbers which are at even positions (index 1 based) are reversed and added at the beginning and the numbers which are at the odd positions are kept in same order and added in the end.
While for odd-sized arrays, the elements at odd positions are reversed and added at the beginning while elements in the array at even positions are kept same and added in the end.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void solveEven(int n, int* arr, int* b)
{
int left = n - 1;
for (int i = 0; i < (n / 2); ++i) {
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 0;
for (int i = n / 2; i <= n - 1; ++i) {
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
void solveOdd(int n, int* arr, int* b)
{
int left = n - 1;
for (int i = 0; i < (n / 2) + 1; ++i) {
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 1;
for (int i = (n / 2) + 1; i <= n - 1; ++i) {
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
void solve(int n, int* arr)
{
int b[n];
if (n % 2 == 0)
solveEven(n, arr, b);
else
solveOdd(n, arr, b);
for (int i = 0; i <= n - 1; ++i) {
cout << b[i] << " ";
}
}
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof(arr) / sizeof(arr[0]);
solve(n, arr);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static void solveEven(int n, int arr[], int b[])
{
int left = n - 1;
for (int i = 0; i < (n / 2); ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 0;
for (int i = n / 2; i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
static void solveOdd(int n, int arr[], int b[])
{
int left = n - 1;
for (int i = 0; i < (n / 2) + 1; ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 1;
for (int i = (n / 2) + 1; i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
static void solve(int n, int arr[])
{
int b[] = new int[n];
if (n % 2 == 0)
solveEven(n, arr, b);
else
solveOdd(n, arr, b);
for (int i = 0; i <= n - 1; ++i)
{
System.out.print( b[i] + " ");
}
}
public static void main (String[] args)
{
int []arr = { 1, 2, 3, 4 };
int n = arr.length;
solve(n, arr);
}
}
|
Python3
def solveEven(n, arr, b):
left = n - 1
for i in range((n // 2)):
b[i] = arr[left]
left = left - 2
if (left < 0):
break
right = 0
for i in range(n // 2, n, 1):
b[i] = arr[right]
right = right + 2
if (right > n - 2):
break
def solveOdd(n, arr, b):
left = n - 1
for i in range(n // 2 + 1):
b[i] = arr[left]
left = left - 2
if (left < 0):
break
right = 1
for i in range(n // 2 + 1, n, 1):
b[i] = arr[right]
right = right + 2
if (right > n - 2):
break
def solve(n, arr):
b = [0 for i in range(n)]
if (n % 2 == 0):
solveEven(n, arr, b)
else:
solveOdd(n, arr, b)
for i in range(n):
print(b[i], end = " ")
if __name__ == '__main__':
arr = [1, 2, 3, 4]
n = len(arr)
solve(n, arr)
|
C#
using System;
class GFG
{
static void solveEven(int n, int []arr,
int []b)
{
int left = n - 1;
for (int i = 0; i < (n / 2); ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 0;
for (int i = n / 2; i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
static void solveOdd(int n, int []arr, int []b)
{
int left = n - 1;
for (int i = 0; i < (n / 2) + 1; ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
int right = 1;
for (int i = (n / 2) + 1; i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
static void solve(int n, int []arr)
{
int []b = new int[n];
if (n % 2 == 0)
solveEven(n, arr, b);
else
solveOdd(n, arr, b);
for (int i = 0; i <= n - 1; ++i)
{
Console.Write( b[i] + " ");
}
}
public static void Main ()
{
int []arr = { 1, 2, 3, 4 };
int n = arr.Length;
solve(n, arr);
}
}
|
Javascript
<script>
function solveEven(n, arr, b)
{
let left = n - 1;
for (let i = 0; i < parseInt(n / 2, 10); ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
let right = 0;
for (let i = parseInt(n / 2, 10); i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
function solveOdd(n, arr, b)
{
let left = n - 1;
for (let i = 0; i < parseInt(n / 2, 10) + 1; ++i)
{
b[i] = arr[left];
left = left - 2;
if (left < 0)
break;
}
let right = 1;
for (let i = parseInt(n / 2, 10) + 1; i <= n - 1; ++i)
{
b[i] = arr[right];
right = right + 2;
if (right > n - 2)
break;
}
}
function solve(n, arr)
{
let b = new Array(n);
if (n % 2 == 0)
solveEven(n, arr, b);
else
solveOdd(n, arr, b);
for (let i = 0; i <= n - 1; ++i)
{
document.write( b[i] + " ");
}
}
let arr = [ 1, 2, 3, 4 ];
let n = arr.length;
solve(n, arr);
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(n)
Efficient Approach:
The last Element of Array will be reversed only once. Last but one element will be reversed twice. Hence it goes to the last position in final result array ie b. Hence we can fill b array by iterating the original array from the end and placing elements at the not filled first index and not filled the last index. The same idea is implemented below.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int* solve(int arr[], int n)
{
static int b[4];
int p = 0;
for (int i = n - 1; i >= 0; i--)
{
b[p] = arr[i--];
if (i >= 0)
b[n - 1 - p] = arr[i];
p++;
}
return b;
}
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof(arr)/sizeof(arr[0]);
int *b ;
b = solve(arr, n);
for(int i = 0; i < n; i++)
cout << b[i] << " ";
}
|
Java
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
static int[] solve(int[] arr, int n) {
int[] b = new int[n];
int p = 0;
for (int i = n - 1; i >= 0; i--) {
b[p] = arr[i--];
if (i >= 0)
b[n - 1 - p] = arr[i];
p++;
}
return b;
}
public static void main(String[] args)
{
int []arr = { 1, 2, 3, 4 };
int n = arr.length;
int[] b = solve(arr, n);
System.out.println(Arrays.toString(b));
}
}
|
C#
using System;
class GFG
{
static int[] solve(int[] arr, int n)
{
int[] b = new int[n];
int p = 0;
for (int i = n - 1; i >= 0; i--)
{
b[p] = arr[i--];
if (i >= 0)
b[n - 1 - p] = arr[i];
p++;
}
return b;
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4 };
int n = arr.Length;
int[] b = solve(arr, n);
Console.WriteLine("[" + String.Join(",", b) + "]");
}
}
|
Python3
def solve(arr, n):
b = [0 for i in range(n)]
p = 0
i = n - 1
while i >= 0:
b[p] = arr[i]
i -= 1
if (i >= 0):
b[n - 1 - p] = arr[i]
p += 1
i -= 1
return b
arr = [1, 2, 3, 4]
n = len(arr)
b = solve(arr, n)
print(b)
|
Javascript
<script>
function solve(arr , n) {
var b = Array(n).fill(0);
var p = 0;
for (i = n - 1; i >= 0; i--) {
b[p] = arr[i--];
if (i >= 0)
b[n - 1 - p] = arr[i];
p++;
}
return b;
}
var arr = [ 1, 2, 3, 4 ];
var n = arr.length;
var b = solve(arr, n);
document.write("["+ b.toString()+ "]");
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(1)