Given an array **arr[]** consisting of** N** integers representing **N** rods each with a disk of radius **arr[i]**, the task is to check if it is possible to move all disks to a single rod based on the condition that a disk at **i ^{th}** rod can be moved to

**j**rod only if:

^{th}**abs****(i – j) = 1**and**i**rod has only a single disk.^{th}- The disk at
**i**rod has radii less than the top disk of the^{th}**j**rod or the^{th}**j**rod is empty.^{th}

**Examples:**

Input:arr[] = {1, 3, 5, 2}, N = 4Output:YESExplanation:

One of the possible ways is:

First move the disk of radii 3 at rod 2 to the top of rod 3.

The array arr[] modifies to {1, 0, (5, 3), 2}.

Move the disk of radii 2 at rod 4 to the top of rod 3. The array arr[] modifies to {1, 0, (5, 3, 2), 0}.

Move the disk of radii 1 at rod 1 to top of the rod 2. The array arr[] modifies to {0, 1, (5, 3, 2), 0}.

Now, move the disk of radii 1 at rod 2 to the top of rod 3. The array arr[] modifies to {0, 0, (5, 3, 2, 1), 0}.

Input:arr[] = {4, 1, 2}, N = 3Output:NO

**Approach: **The given problem can be solved based on the following observations:

- It can be observed that if there exists an index
isuch thatarr[i] < arr[i – 1] and arr[i] < arr[i + 1],then it is impossible to move all the disks at a single rod.- Therefore, the task is reduced to finding if there exists any index
isuch thatarr[i] < arr[i – 1] and arr[i] < arr[i + 1].

Follow the steps below to solve the problem:

- Initialize a variable, say
**flag = false**, to store if any such index exists in the array or not. - Traverse the array over the indices
**[1, N – 2]**. For every**i**^{th}index, check if**arr[i] < arr[i – 1] and arr[i] < arr[i + 1]**, then set**flag = true**and break. - Print
**“YES”**if**flag**is**false**. Otherwise, print**“NO”**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if it is possible` `// to move all disks to a single rod` `bool` `check(` `int` `a[], ` `int` `n)` `{` ` ` `// Stores if it is possible to move` ` ` `// all disks to a single rod` ` ` `bool` `flag = 0;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 1; i < n - 1; i++) {` ` ` `// If i-th element is smaller than` ` ` `// both its adjacent elements` ` ` `if` `(a[i + 1] > a[i]` ` ` `&& a[i] < a[i - 1])` ` ` `flag = 1;` ` ` `}` ` ` `// If flag is true` ` ` `if` `(flag)` ` ` `return` `false` `;` ` ` `// Otherwise` ` ` `else` ` ` `return` `true` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 3, 5, 2 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `if` `(check(arr, N))` ` ` `cout << ` `"YES"` `;` ` ` `else` ` ` `cout << ` `"NO"` `;` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG` `{` `// Function to check if it is possible` `// to move all disks to a single rod` `static` `boolean` `check(` `int` `a[], ` `int` `n)` `{` ` ` ` ` `// Stores if it is possible to move` ` ` `// all disks to a single rod` ` ` `boolean` `flag = ` `false` `;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `1` `; i < n - ` `1` `; i++)` ` ` `{` ` ` `// If i-th element is smaller than` ` ` `// both its adjacent elements` ` ` `if` `(a[i + ` `1` `] > a[i]` ` ` `&& a[i] < a[i - ` `1` `])` ` ` `flag = ` `true` `;` ` ` `}` ` ` `// If flag is true` ` ` `if` `(flag)` ` ` `return` `false` `;` ` ` `// Otherwise` ` ` `else` ` ` `return` `true` `;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `1` `, ` `3` `, ` `5` `, ` `2` `};` ` ` `int` `N = arr.length;` ` ` `if` `(check(arr, N))` ` ` `System.out.print(` `"YES"` `);` ` ` `else` ` ` `System.out.print(` `"NO"` `);` `}` `}` `// This code is contributed by code_hunt.` |

## Python3

`# Python 3 program for the above approach` `# Function to check if it is possible` `# to move all disks to a single rod` `def` `check(a, n) :` ` ` ` ` `# Stores if it is possible to move` ` ` `# all disks to a single rod` ` ` `flag ` `=` `0` ` ` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(` `1` `, n ` `-` `1` `):` ` ` ` ` `# If i-th element is smaller than` ` ` `# both its adjacent elements` ` ` `if` `(a[i ` `+` `1` `] > a[i]` ` ` `and` `a[i] < a[i ` `-` `1` `]) :` ` ` `flag ` `=` `1` ` ` ` ` `# If flag is true` ` ` `if` `(flag !` `=` `0` `) :` ` ` `return` `False` ` ` ` ` `# Otherwise` ` ` `else` `:` ` ` `return` `True` `# Driver Code` `arr ` `=` `[ ` `1` `, ` `3` `, ` `5` `, ` `2` `]` `N ` `=` `len` `(arr)` ` ` `if` `(check(arr, N) !` `=` `0` `):` ` ` `print` `(` `"YES"` `)` `else` `:` ` ` `print` `(` `"NO"` `)` ` ` ` ` `# This code is contributed by splevel62.` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to check if it is possible` `// to move all disks to a single rod` `static` `bool` `check(` `int` `[] a, ` `int` `n)` `{` ` ` ` ` `// Stores if it is possible to move` ` ` `// all disks to a single rod` ` ` `bool` `flag = ` `false` `;` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 1; i < n - 1; i++)` ` ` `{` ` ` `// If i-th element is smaller than` ` ` `// both its adjacent elements` ` ` `if` `(a[i + 1] > a[i]` ` ` `&& a[i] < a[i - 1])` ` ` `flag = ` `true` `;` ` ` `}` ` ` `// If flag is true` ` ` `if` `(flag)` ` ` `return` `false` `;` ` ` `// Otherwise` ` ` `else` ` ` `return` `true` `;` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `int` `[] arr = { 1, 3, 5, 2 };` ` ` `int` `N = arr.Length;` ` ` `if` `(check(arr, N))` ` ` `Console.Write(` `"YES"` `);` ` ` `else` ` ` `Console.Write(` `"NO"` `);` ` ` `}` `}` `// This code is contributed by susmitakundugoaldanga.` |

## Javascript

`<script>` `// javascript program to implement` `// the above approach` `// Function to check if it is possible` `// to move all disks to a single rod` `function` `check(a , n)` `{` ` ` ` ` `// Stores if it is possible to move` ` ` `// all disks to a single rod` ` ` `flag = ` `false` `;` ` ` `// Traverse the array` ` ` `for` `(i = 1; i < n - 1; i++)` ` ` `{` ` ` `// If i-th element is smaller than` ` ` `// both its adjacent elements` ` ` `if` `(a[i + 1] > a[i]` ` ` `&& a[i] < a[i - 1])` ` ` `flag = ` `true` `;` ` ` `}` ` ` `// If flag is true` ` ` `if` `(flag)` ` ` `return` `false` `;` ` ` `// Otherwise` ` ` `else` ` ` `return` `true` `;` `}` `// Driver Code` `var` `arr = [ 1, 3, 5, 2 ];` `var` `N = arr.length;` `if` `(check(arr, N))` ` ` `document.write(` `"YES"` `);` `else` ` ` `document.write(` `"NO"` `);` `// This code contributed by Princi Singh` `</script>` |

**Output:**

YES

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.