Check if a number has digits in the given Order

Last Updated : 24 Jun, 2024

Given a number N. The task is to check if the digits of the number follow any of the below order:

The digits are in strictly increasing order.
Or, the digits are in strictly decreasing order.
Or, the digits follow strictly increasing order first and then strictly decreasing.

If the number follows any of the above order then print YES otherwise print NO.

Examples:

Input : N = 415
Output : NO
Input : N = 123454321
Output : YES

Traverse the number from right to left by extracting each digit one by one. Keep a pointer to tell that whether the current sequence is descending or ascending sequence, -1 denotes strictly ascending and 1 denotes strictly descending sequence. At first the sequence should be strictly increasing as we are going from right to left. As we encounter a digit which is lesser than the previous digit, change the flag to decreasing(i.e -1) and while in increasing order we get any digit which is equal to the previous digit we directly print NO.

Below is the implementation of the above approach:

C++

// CPP program to check if the digits are in
// the given order
#include<bits/stdc++.h>
using namespace std;

// Check if the digits follow the correct order
bool isCorrectOrder(int n)
{
    bool flag = true;
    
    // to store the previous digit
    int prev = -1; 
    
    // pointer to tell what type of sequence 
    // are we dealing with
    int type = -1; 

    while(n != 0)
    {
        if(type ==-1)
        {
            if(prev ==-1)
            {
                prev = n % 10;
                n = n/10;
                continue;
            }
            // check if we have same digit 
            // as the previous digit
            if(prev == n % 10) 
            {   
                flag = false;
                break;
            }
            // checking the peak point of the number
            if(prev > n % 10) 
            {  
                type = 1;
                prev = n % 10;
                n = n/10;
                continue;
            }
            
            prev = n % 10;
            n = n / 10;
        }
        else
        {   
            // check if we have same digit
            // as the previous digit
            if(prev == n % 10) 
            {   
                flag = false;
                break;
            }
            // check if the digit is greater than 
            // the previous one 
            // If true, then break from the loop as 
            // we are in descending order part
            if(prev < n % 10) 
            {           
                flag = false;
                break;
            }
             
            prev = n % 10;
            n = n / 10;
        }
    }

    return flag;
}

// Driver code
int main()
{
    int n = 123454321;
    
    if(isCorrectOrder(n))
        cout<<"YES";
    else
        cout<<"NO";
    
    return 0;
}

Java

// Java program to check if the digits are in
// the given order
import java.io.*;

class GFG {

// Check if the digits follow the correct order
static boolean isCorrectOrder(int n)
{
    boolean flag = true;
    
    // to store the previous digit
    int prev = -1; 
    
    // pointer to tell what type of sequence 
    // are we dealing with
    int type = -1; 

    while(n != 0)
    {
        if(type ==-1)
        {
            if(prev ==-1)
            {
                prev = n % 10;
                n = n/10;
                continue;
            }
            // check if we have same digit 
            // as the previous digit
            if(prev == n % 10) 
            { 
                flag = false;
                break;
            }
            // checking the peak point of the number
            if(prev > n % 10) 
            { 
                type = 1;
                prev = n % 10;
                n = n/10;
                continue;
            }
            
            prev = n % 10;
            n = n / 10;
        }
        else
        { 
            // check if we have same digit
            // as the previous digit
            if(prev == n % 10) 
            { 
                flag = false;
                break;
            }
            // check if the digit is greater than 
            // the previous one 
            // If true, then break from the loop as 
            // we are in descending order part
            if(prev < n % 10) 
            {         
                flag = false;
                break;
            }
            
            prev = n % 10;
            n = n / 10;
        }
    }

    return flag;
}

// Driver code

    public static void main (String[] args) {
        int n = 123454321;
    
    if(isCorrectOrder(n))
        System.out.println("YES");
    else
        System.out.println("NO");
    }
}

 // This code is contributed by ajit

Python

# Python3 program to check if the 
# digits are in the given order 

# Check if the digits follow 
# the correct order 
def isCorrectOrder(n): 

    flag = True; 
    
    # to store the previous digit 
    prev = -1; 
    
    # pointer to tell what type of 
    # sequence are we dealing with 
    type = -1; 

    while(n != 0):
        if(type ==-1):
            if(prev ==-1):
                prev = n % 10; 
                n = int(n / 10); 
                continue; 
            
            # check if we have same digit 
            # as the previous digit 
            if(prev == n % 10): 
                flag = False; 
                break; 
            
            # checking the peak point 
            # of the number 
            if(prev > n % 10):
                type = 1; 
                prev = n % 10; 
                n = int(n / 10); 
                continue; 
            
            prev = n % 10; 
            n = int(n / 10); 
        else:
            
            # check if we have same digit 
            # as the previous digit 
            if(prev == n % 10):
                flag = False; 
                break; 
            
            # check if the digit is greater 
            # than the previous one 
            # If true, then break from the 
            # loop as we are in descending
            # order part 
            if(prev < n % 10): 
                flag = False; 
                break; 
            
            prev = n % 10; 
            n = int(n / 10); 

    return flag; 

# Driver code 
n = 123454321; 

if(isCorrectOrder(n)): 
    print("YES"); 
else:
    print("NO"); 

# This Code is contributed by mits

// C# program to check if the 
// digits are in the given order
using System;

class GFG 
{

// Check if the digits follow
// the correct order
static bool isCorrectOrder(int n)
{
    bool flag = true;
    
    // to store the previous digit
    int prev = -1; 
    
    // pointer to tell what type of 
    // sequence are we dealing with
    int type = -1; 

    while(n != 0)
    {
        if(type == -1)
        {
            if(prev == -1)
            {
                prev = n % 10;
                n = n / 10;
                continue;
            }
            
            // check if we have same digit 
            // as the previous digit
            if(prev == n % 10) 
            { 
                flag = false;
                break;
            }
            
            // checking the peak point 
            // of the number
            if(prev > n % 10) 
            { 
                type = 1;
                prev = n % 10;
                n = n / 10;
                continue;
            }
            
            prev = n % 10;
            n = n / 10;
        }
        else
        { 
            // check if we have same digit
            // as the previous digit
            if(prev == n % 10) 
            { 
                flag = false;
                break;
            }
            
            // check if the digit is greater 
            // than the previous one 
            // If true, then break from the
            // loop as we are in descending
            // order part
            if(prev < n % 10) 
            {     
                flag = false;
                break;
            }
            
            prev = n % 10;
            n = n / 10;
        }
    }

    return flag;
}

// Driver code
public static void Main () 
{
    int n = 123454321;
    
    if(isCorrectOrder(n))
        Console.WriteLine("YES");
    else
        Console.WriteLine("NO");
}
}

// This code is contributed by Shashank

JavaScript

<script>

// JavaScript program to check if the digits are in 
// the given order 
  
// Check if the digits follow the correct order 
function isCorrectOrder(n) 
{ 
    let flag = true; 
      
    // to store the previous digit 
    let prev = -1;  
      
    // pointer to tell what type of sequence  
    // are we dealing with 
    let type = -1;  
  
    while(n != 0) 
    { 
        if(type ===-1) 
        { 
            if(prev ===-1) 
            { 
                prev = n % 10; 
                n = Math.floor(n/10); 
                continue; 
            } 
            // check if we have same digit  
            // as the previous digit 
            if(prev == n % 10)  
            {    
                flag = false; 
                break; 
            } 
            // checking the peak point of the number 
            if(prev > n % 10)  
            {   
                type = 1; 
                prev = n % 10; 
                n = Math.floor(n/10); 
                continue; 
            } 
              
            prev = n % 10; 
            n = Math.floor(n / 10); 
        } 
        else
        {    
            // check if we have same digit 
            // as the previous digit 
            if(prev == n % 10)  
            {    
                flag = false; 
                break; 
            } 
            // check if the digit is greater than  
            // the previous one  
            // If true, then break from the loop as  
            // we are in descending order part 
            if(prev < n % 10)  
            {            
                flag = false; 
                break; 
            } 
               
            prev = n % 10; 
            n = Math.floor(n / 10); 
        } 
    } 
  
    return flag; 
} 
  
// Driver code 

    let n = 123454321; 
      
    if(isCorrectOrder(n)) 
        document.write("YES"); 
    else
        document.write("NO"); 
      

// This code is contributed by Surbhi Tyagi

</script>

PHP

<?php
// PHP program to check if the 
// digits are in the given order 

// Check if the digits follow 
// the correct order 
function isCorrectOrder($n) 
{ 
    $flag = true; 
    
    // to store the previous digit 
    $prev = -1; 
    
    // pointer to tell what type of 
    // sequence are we dealing with 
    $type = -1; 

    while($n != 0) 
    { 
        if($type ==-1) 
        { 
            if($prev ==-1) 
            { 
                $prev = $n % 10; 
                $n = (int)$n / 10; 
                continue; 
            } 
            
            // check if we have same digit 
            // as the previous digit 
            if($prev == $n % 10) 
            { 
                $flag = false; 
                break; 
            } 
            
            // checking the peak point 
            // of the number 
            if($prev > $n % 10) 
            { 
                $type = 1; 
                $prev = $n % 10; 
                $n = (int)$n / 10; 
                continue; 
            } 
            
            $prev = $n % 10; 
            $n = (int)$n / 10; 
        } 
        else
        { 
            // check if we have same digit 
            // as the previous digit 
            if($prev == $n % 10) 
            { 
                $flag = false; 
                break; 
            } 
            
            // check if the digit is greater 
            // than the previous one 
            // If true, then break from the 
            // loop as we are in descending
            // order part 
            if($prev < $n % 10) 
            {     
                $flag = false; 
                break; 
            } 
            
            $prev = $n % 10; 
            $n = (int) $n / 10; 
        } 
    } 

    return $flag; 
} 

// Driver code 
$n = 123454321; 

if(isCorrectOrder($n)) 
    echo "YES"; 
else
    echo "NO"; 

// This Code is contributed by ajit
?>

Output

YES

Time Complexity: O(logN)

Auxiliary Space: O(1), since no extra space has been taken.

Check if a number is magic (Recursive sum of digits is 1)

indrajit1

Improve

Article Tags :

Practice Tags :

Check if a number has digits in the given Order

Similar Reads

Thank You!

What kind of Experience do you want to share?