The Wayback Machine - https://web.archive.org/web/20210419052807/https://www.geeksforgeeks.org/ugly-numbers/
Skip to content
Related Articles

Related Articles

Ugly Numbers
  • Difficulty Level : Medium
  • Last Updated : 12 Apr, 2021

Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the first 11 ugly numbers. By convention, 1 is included. 
Given a number n, the task is to find n’th Ugly number.

Examples:  

Input  : n = 7
Output : 8

Input  : n = 10
Output : 12

Input  : n = 15
Output : 24

Input  : n = 150
Output : 5832

Method 1 (Simple) 
Loop for all positive integers until ugly number count is smaller than n, if an integer is ugly than increment ugly number count.
To check if a number is ugly, divide the number by greatest divisible powers of 2, 3 and 5, if the number becomes 1 then it is an ugly number otherwise not. 

For example, let us see how to check for 300 is ugly or not. Greatest divisible power of 2 is 4, after dividing 300 by 4 we get 75. Greatest divisible power of 3 is 3, after dividing 75 by 3 we get 25. Greatest divisible power of 5 is 25, after dividing 25 by 25 we get 1. Since we get 1 finally, 300 is ugly number.

Below is the implementation of the above approach:



C++




// CPP program to find nth ugly number
#include <stdio.h>
#include <stdlib.h>
 
// This function divides a by greatest divisible
//  power of b
int maxDivide(int a, int b)
{
    while (a % b == 0)
        a = a / b;
    return a;
}
 
// Function to check if a number is ugly or not
int isUgly(int no)
{
    no = maxDivide(no, 2);
    no = maxDivide(no, 3);
    no = maxDivide(no, 5);
 
    return (no == 1) ? 1 : 0;
}
 
// Function to get the nth ugly number
int getNthUglyNo(int n)
{
    
    int i = 1;
     
    // ugly number count
    int count = 1;
 
    // Check for all integers untill ugly count
    //  becomes n
    while (n > count) {
        i++;
        if (isUgly(i))
            count++;
    }
    return i;
}
 
// Driver Code
int main()
{
    // Function call
    unsigned no = getNthUglyNo(150);
    printf("150th ugly no. is %d ", no);
    getchar();
    return 0;
}
Java



// Java program to find nth ugly number
class GFG {
 
    /*This function divides a by greatest
    divisible power of b*/
    static int maxDivide(int a, int b)
    {
        while (a % b == 0)
            a = a / b;
        return a;
    }
 
    /* Function to check if a number
    is ugly or not */
    static int isUgly(int no)
    {
        no = maxDivide(no, 2);
        no = maxDivide(no, 3);
        no = maxDivide(no, 5);
 
        return (no == 1) ? 1 : 0;
    }
 
    /* Function to get the nth ugly
    number*/
    static int getNthUglyNo(int n)
    {
        int i = 1;
 
        // ugly number count
        int count = 1;
 
        // check for all integers
        // until count becomes n
        while (n > count) {
            i++;
            if (isUgly(i) == 1)
                count++;
        }
        return i;
    }
 
    /* Driver Code*/
    public static void main(String args[])
    {
        int no = getNthUglyNo(150);
       
        // Function call
        System.out.println("150th ugly "
                           + "no. is " + no);
    }
}
 
// This code has been contributed by
// Amit Khandelwal (Amit Khandelwal 1)
Python3



# Python3 code to find nth ugly number
 
# This function divides a by greatest
# divisible power of b
 
 
def maxDivide(a, b):
    while a % b == 0:
        a = a / b
    return a
 
# Function to check if a number
# is ugly or not
def isUgly(no):
    no = maxDivide(no, 2)
    no = maxDivide(no, 3)
    no = maxDivide(no, 5)
    return 1 if no == 1 else 0
 
# Function to get the nth ugly number
def getNthUglyNo(n):
    i = 1
     
    # ugly number count
    count = 1 
 
    # Check for all integers untill
    # ugly count becomes n
    while n > count:
        i += 1
        if isUgly(i):
            count += 1
    return i
 
 
# Driver code
no = getNthUglyNo(150)
print("150th ugly no. is ", no)
 
# This code is contributed by "Sharad_Bhardwaj".
C#



// C# program to find nth ugly number
using System;
 
class GFG {
 
    /*This function divides a by
    greatest divisible power of b*/
    static int maxDivide(int a, int b)
    {
        while (a % b == 0)
            a = a / b;
        return a;
    }
 
    /* Function to check if a number
    is ugly or not */
    static int isUgly(int no)
    {
        no = maxDivide(no, 2);
        no = maxDivide(no, 3);
        no = maxDivide(no, 5);
 
        return (no == 1) ? 1 : 0;
    }
 
    /* Function to get the nth ugly
    number*/
    static int getNthUglyNo(int n)
    {
        int i = 1;
 
        // ugly number count
        int count = 1;
 
        // Check for all integers
        // until count becomes n
        while (n > count) {
            i++;
            if (isUgly(i) == 1)
                count++;
        }
        return i;
    }
 
    // Driver code
    public static void Main()
    {
        int no = getNthUglyNo(150);
 
        // Function call
        Console.WriteLine("150th ugly"
                          + " no. is " + no);
    }
}
 
// This code is contributed by Sam007.
PHP



<?php
// PHP program to find nth ugly number
 
// This function divides a by
// greatest divisible power of b
function maxDivide($a, $b)
{
    while ($a % $b == 0)
    $a = $a / $b;
    return $a;
}
 
// Function to check if a
// number is ugly or not
function isUgly($no)
{
    $no = maxDivide($no, 2);
    $no = maxDivide($no, 3);
    $no = maxDivide($no, 5);
     
    return ($no == 1)? 1 : 0;
}
 
// Function to get the nth
// ugly number
function getNthUglyNo($n)
{
    $i = 1;
     
    // ugly number count
    $count = 1;
 
// Check for all integers
// untill ugly count becomes n
while ($n > $count)
{
    $i++;    
    if (isUgly($i))
    $count++;
}
return $i;
}
 
    // Driver Code
    $no = getNthUglyNo(150);
    echo "150th ugly no. is ". $no;
 
// This code is contributed by Sam007
?>
Javascript



<script>
// javascript program to find nth ugly number   
/*
     * This function divides a by greatest divisible power of b
     */
    function maxDivide(a , b) {
        while (a % b == 0)
            a = a / b;
        return a;
    }
 
    /*
     * Function to check if a number is ugly or not
     */
    function isUgly(no) {
        no = maxDivide(no, 2);
        no = maxDivide(no, 3);
        no = maxDivide(no, 5);
 
        return (no == 1) ? 1 : 0;
    }
 
    /*
     * Function to get the nth ugly number
     */
    function getNthUglyNo(n)
    {
        var i = 1;
 
        // ugly number count
        var count = 1;
 
        // check for all integers
        // until count becomes n
        while (n > count)
        {
            i++;
            if (isUgly(i) == 1)
                count++;
        }
        return i;
    }
 
    /* Driver Code */   
    var no = getNthUglyNo(150);
 
    // Function call
    document.write("150th ugly " + "no. is " + no);
 
// This code is contributed by shikhasingrajput
</script>
Output
150th ugly no. is 5832 
This method is not time efficient as it checks for all integers until ugly number count becomes n, but space complexity of this method is O(1) 
 
Method 2 (Use Dynamic Programming) 
Here is a time efficient solution with O(n) extra space. The ugly-number sequence is 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … 
     because every number can only be divided by 2, 3, 5, one way to look at the sequence is to split the sequence to three groups as below: 
     (1) 1×2, 2×2, 3×2, 4×2, 5×2, … 
     (2) 1×3, 2×3, 3×3, 4×3, 5×3, … 
     (3) 1×5, 2×5, 3×5, 4×5, 5×5, …
     We can find that every subsequence is the ugly-sequence itself (1, 2, 3, 4, 5, …) multiply 2, 3, 5. Then we use similar merge method as merge sort, to get every ugly number from the three subsequence. Every step we choose the smallest one, and move one step after.
1 Declare an array for ugly numbers:  ugly[n]
2 Initialize first ugly no:  ugly[0] = 1
3 Initialize three array index variables i2, i3, i5 to point to 
   1st element of the ugly array: 
        i2 = i3 = i5 =0; 
4 Initialize 3 choices for the next ugly no:
         next_mulitple_of_2 = ugly[i2]*2;
         next_mulitple_of_3 = ugly[i3]*3
         next_mulitple_of_5 = ugly[i5]*5;
5 Now go in a loop to fill all ugly numbers till 150:
For (i = 1; i < 150; i++ ) 
{
    /* These small steps are not optimized for good 
      readability. Will optimize them in C program */
    next_ugly_no  = Min(next_mulitple_of_2,
                        next_mulitple_of_3,
                        next_mulitple_of_5); 

    ugly[i] =  next_ugly_no       

    if (next_ugly_no  == next_mulitple_of_2) 
    {             
        i2 = i2 + 1;        
        next_mulitple_of_2 = ugly[i2]*2;
    } 
    if (next_ugly_no  == next_mulitple_of_3) 
    {             
        i3 = i3 + 1;        
        next_mulitple_of_3 = ugly[i3]*3;
     }            
     if (next_ugly_no  == next_mulitple_of_5)
     {    
        i5 = i5 + 1;        
        next_mulitple_of_5 = ugly[i5]*5;
     } 
     
}/* end of for loop */ 
6.return next_ugly_no
Example: 
Let us see how it works 
initialize
   ugly[] =  | 1 |
   i2 =  i3 = i5 = 0;

First iteration
   ugly[1] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
            = Min(2, 3, 5)
            = 2
   ugly[] =  | 1 | 2 |
   i2 = 1,  i3 = i5 = 0  (i2 got incremented ) 

Second iteration
    ugly[2] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
             = Min(4, 3, 5)
             = 3
    ugly[] =  | 1 | 2 | 3 |
    i2 = 1,  i3 =  1, i5 = 0  (i3 got incremented ) 

Third iteration
    ugly[3] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
             = Min(4, 6, 5)
             = 4
    ugly[] =  | 1 | 2 | 3 |  4 |
    i2 = 2,  i3 =  1, i5 = 0  (i2 got incremented )

Fourth iteration
    ugly[4] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
              = Min(6, 6, 5)
              = 5
    ugly[] =  | 1 | 2 | 3 |  4 | 5 |
    i2 = 2,  i3 =  1, i5 = 1  (i5 got incremented )

Fifth iteration
    ugly[4] = Min(ugly[i2]*2, ugly[i3]*3, ugly[i5]*5)
              = Min(6, 6, 10)
              = 6
    ugly[] =  | 1 | 2 | 3 |  4 | 5 | 6 |
    i2 = 3,  i3 =  2, i5 = 1  (i2 and i3 got incremented )

Will continue same way till I < 150
C++



// C++ program to find n'th Ugly number
#include <bits/stdc++.h>
using namespace std;
 
// Function to get the nth ugly number
unsigned getNthUglyNo(unsigned n)
{
    // To store ugly numbers
    unsigned ugly[n];
    unsigned i2 = 0, i3 = 0, i5 = 0;
    unsigned next_multiple_of_2 = 2;
    unsigned next_multiple_of_3 = 3;
    unsigned next_multiple_of_5 = 5;
    unsigned next_ugly_no = 1;
 
    ugly[0] = 1;
    for (int i = 1; i < n; i++) {
        next_ugly_no = min(
            next_multiple_of_2,
            min(next_multiple_of_3, next_multiple_of_5));
        ugly[i] = next_ugly_no;
        if (next_ugly_no == next_multiple_of_2) {
            i2 = i2 + 1;
            next_multiple_of_2 = ugly[i2] * 2;
        }
        if (next_ugly_no == next_multiple_of_3) {
            i3 = i3 + 1;
            next_multiple_of_3 = ugly[i3] * 3;
        }
        if (next_ugly_no == next_multiple_of_5) {
            i5 = i5 + 1;
            next_multiple_of_5 = ugly[i5] * 5;
        }
    } 
   
    // End of for loop (i=1; i<n; i++)
    return next_ugly_no;
}
 
// Driver Code
int main()
{
    int n = 150;
    cout << getNthUglyNo(n);
    return 0;
}
Java



// Java program to find nth ugly number
import java.lang.Math;
 
class UglyNumber
{
    // Function to get the nth ugly number
    int getNthUglyNo(int n)
    {
         // To store ugly numbers
        int ugly[] = new int[n];
        int i2 = 0, i3 = 0, i5 = 0;
        int next_multiple_of_2 = 2;
        int next_multiple_of_3 = 3;
        int next_multiple_of_5 = 5;
        int next_ugly_no = 1;
 
        ugly[0] = 1;
 
        for (int i = 1; i < n; i++)
        {
            next_ugly_no
                = Math.min(next_multiple_of_2,
                           Math.min(next_multiple_of_3,
                                    next_multiple_of_5));
 
            ugly[i] = next_ugly_no;
            if (next_ugly_no == next_multiple_of_2)
            {
                i2 = i2 + 1;
                next_multiple_of_2 = ugly[i2] * 2;
            }
            if (next_ugly_no == next_multiple_of_3)
            {
                i3 = i3 + 1;
                next_multiple_of_3 = ugly[i3] * 3;
            }
            if (next_ugly_no == next_multiple_of_5)
            {
                i5 = i5 + 1;
                next_multiple_of_5 = ugly[i5] * 5;
            }
        }
         
        // End of for loop (i=1; i<n; i++)
        return next_ugly_no;
    }
 
    // Driver code
    public static void main(String args[])
    {
         
        int n = 150;
         
        // Function call
        UglyNumber obj = new UglyNumber();
        System.out.println(obj.getNthUglyNo(n));
    }
}
 
// This code has been contributed by Amit Khandelwal (Amit
// Khandelwal 1)
Python



# Python program to find n'th Ugly number
 
# Function to get the nth ugly number
 
 
def getNthUglyNo(n):
 
    ugly = [0] * n  # To store ugly numbers
 
    # 1 is the first ugly number
    ugly[0] = 1
 
    # i2, i3, i5 will indicate indices for
    # 2,3,5 respectively
    i2 = i3 = i5 = 0
 
    # Set initial multiple value
    next_multiple_of_2 = 2
    next_multiple_of_3 = 3
    next_multiple_of_5 = 5
 
    # Start loop to find value from
    # ugly[1] to ugly[n]
    for l in range(1, n):
 
        # Shoose the min value of all
        # available multiples
        ugly[l] = min(next_multiple_of_2,
                      next_multiple_of_3,
                      next_multiple_of_5)
 
        # Increment the value of index accordingly
        if ugly[l] == next_multiple_of_2:
            i2 += 1
            next_multiple_of_2 = ugly[i2] * 2
 
        if ugly[l] == next_multiple_of_3:
            i3 += 1
            next_multiple_of_3 = ugly[i3] * 3
 
        if ugly[l] == next_multiple_of_5:
            i5 += 1
            next_multiple_of_5 = ugly[i5] * 5
 
    # Return ugly[n] value
    return ugly[-1]
 
# Driver Code
def main():
 
    n = 150
 
    print getNthUglyNo(n)
 
 
if __name__ == '__main__':
    main()
 
# This code is contributed by Neelam Yadav
C#



// C# program to count inversions in an array
using System;
using System.Collections.Generic;
 
class GFG {
 
    // Function to get the nth ugly number
    static int getNthUglyNo(int n)
    {
 
        // To store ugly numbers
        int[] ugly = new int[n];
        int i2 = 0, i3 = 0, i5 = 0;
        int next_multiple_of_2 = 2;
        int next_multiple_of_3 = 3;
        int next_multiple_of_5 = 5;
        int next_ugly_no = 1;
 
        ugly[0] = 1;
 
        for (int i = 1; i < n; i++)
        {
            next_ugly_no
                = Math.Min(next_multiple_of_2,
                           Math.Min(next_multiple_of_3,
                                    next_multiple_of_5));
 
            ugly[i] = next_ugly_no;
 
            if (next_ugly_no == next_multiple_of_2)
            {
                i2 = i2 + 1;
                next_multiple_of_2 = ugly[i2] * 2;
            }
 
            if (next_ugly_no == next_multiple_of_3)
            {
                i3 = i3 + 1;
                next_multiple_of_3 = ugly[i3] * 3;
            }
            if (next_ugly_no == next_multiple_of_5)
            {
                i5 = i5 + 1;
                next_multiple_of_5 = ugly[i5] * 5;
            }
        }
 
        return next_ugly_no;
    }
 
    // Driver code
    public static void Main()
    {
        int n = 150;
       
        // Function call
        Console.WriteLine(getNthUglyNo(n));
    }
}
 
// This code is contributed by Sam007
PHP



<?php
// PHP program to find
// n'th Ugly number
 
//  Function to get the
// nth ugly number
function getNthUglyNo($n)
{
    // To store ugly numbers
    $ugly = array_fill(0, $n, 0);
    $i2 = 0;
    $i3 = 0;
    $i5 = 0;
    $next_multiple_of_2 = 2;
    $next_multiple_of_3 = 3;
    $next_multiple_of_5 = 5;
    $next_ugly_no = 1;
 
    $ugly[0] = 1;
    for ($i = 1; $i < $n; $i++)
    {
    $next_ugly_no = min($next_multiple_of_2,
                    min($next_multiple_of_3,
                        $next_multiple_of_5));
    $ugly[$i] = $next_ugly_no;
    if ($next_ugly_no ==
        $next_multiple_of_2)
    {
        $i2 = $i2 + 1;
        $next_multiple_of_2 = $ugly[$i2] * 2;
    }
    if ($next_ugly_no ==
        $next_multiple_of_3)
    {
        $i3 = $i3 + 1;
        $next_multiple_of_3 = $ugly[$i3] * 3;
    }
    if ($next_ugly_no ==
        $next_multiple_of_5)
    {
        $i5 = $i5 + 1;
        $next_multiple_of_5 = $ugly[$i5] * 5;
    }
    } /*End of for loop (i=1; i<n; i++) */
    return $next_ugly_no;
}
 
// Driver code
$n = 150;
echo getNthUglyNo($n);
 
// This code is contributed by mits
?>
Javascript



<script>
// javascript program to find nth ugly numberclass UglyNumber
 
// Function to get the nth ugly number
function getNthUglyNo(n)
{
 
     // To store ugly numbers
    var ugly = Array.from({length: n}, (_, i) => 0);
    var i2 = 0, i3 = 0, i5 = 0;
    var next_multiple_of_2 = 2;
    var next_multiple_of_3 = 3;
    var next_multiple_of_5 = 5;
    var next_ugly_no = 1;
 
    ugly[0] = 1;
 
    for (i = 1; i < n; i++)
    {
        next_ugly_no
            = Math.min(next_multiple_of_2,
                       Math.min(next_multiple_of_3,
                                next_multiple_of_5));
 
        ugly[i] = next_ugly_no;
        if (next_ugly_no == next_multiple_of_2)
        {
            i2 = i2 + 1;
            next_multiple_of_2 = ugly[i2] * 2;
        }
        if (next_ugly_no == next_multiple_of_3)
        {
            i3 = i3 + 1;
            next_multiple_of_3 = ugly[i3] * 3;
        }
        if (next_ugly_no == next_multiple_of_5)
        {
            i5 = i5 + 1;
            next_multiple_of_5 = ugly[i5] * 5;
        }
    }
     
    // End of for loop (i=1; i<n; i++)
    return next_ugly_no;
}
 
// Driver code
var n = 150;
 
// Function call
document.write(getNthUglyNo(n));
 
// This code is contributed by Amit Katiyar
</script>
Output
5832
Time Complexity: O(n) 
Auxiliary Space: O(n)
Super Ugly Number (Number whose prime factors are in the given set)
Method 3 (Using SET Data Structure in C++)
In this method, SET data structure to store the minimum of the 3 generated ugly numbers which will the ith Ugly Number stored at the first position of the set. SET Data Structure as a set stores all the element in ascending order
Below is the implementation of the above approach:


C++



// C++ Implemenatation of the above approach
#include<bits/stdc++.h>
using namespace std;
 
int nthUglyNumber(int n)
{
    // Base cases...
    if(n==1 or n==2 or n==3 or n==4 or n==5)
        return n;
     
    set<long long int> s;
    s.insert(1);
    n--;
     
    while(n)
    {
        auto it=s.begin();
         
        //Get the beginning element of the set
        long long int x=*it;
         
        // Deleting the ith element
        s.erase(it);
 
        // Inserting all the other options
        s.insert(x*2);
        s.insert(x*3);
        s.insert(x*5);
        n--;
    }
   
    // The top of the set represents the nth ugly number
    return *s.begin();
}
 
// Driver Code
int main()
{
    int n=150;
   
    // Function call
    cout<<nthUglyNumber(n);
}
 
//Contributed by:- Soumak Poddar
Output
5832
Time Complexity:- O(N log N)
Auxiliary Space:- O(N)
Method 4(Using Binary Search)
  1. This method is suitable if you have a max value for n. The no will be of form x=pow(2,p)*pow(3,q)*pow(5,r).
  2. Search from low=1 to high =21474836647. We are expecting nth ugly no to be in this range.
  3. So we do a binary search. Now suppose we are at mid now we are going to find the total number of ugly numbers less than mid and put our conditions accordingly.
Below is the rough CPP code:
C++



// CPP program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Print nth Ugly number
int nthUglyNumber(int n)
{
 
  int pow[40] = { 1 };
 
  // stored powers of 2 from
  // pow(2,0) to pow(2,30)
  for (int i = 1; i <= 30; ++i)
    pow[i] = pow[i - 1] * 2;
 
  // Initialized low and high
  int l = 1, r = 2147483647;
 
  int ans = -1;
 
  // Applying Binary Search
  while (l <= r) {
 
    // Found mid
    int mid = l + ((r - l) / 2);
 
    // cnt stores total numbers of ugly
    // number less than mid
    int cnt = 0;
 
    // Iterate from 1 to mid
    for (long long i = 1; i <= mid; i *= 5)
 
    {
      // Possible powers of i less than mid is i
      for (long long j = 1; j * i <= mid; j *= 3)
 
      {
        // possible powers of 3 and 5 such that
        // their product is less than mid
 
        // using the power array of 2 (pow) we are
        // trying to find the max power of 2 such
        // that i*J*power of 2 is less than mid
 
        cnt += upper_bound(pow, pow + 31,
                           mid / (i * j)) - pow;
      }
    }
 
    // If total numbers of ugly number
    // less than equal
    // to mid is less than n we update l
    if (cnt < n)
      l = mid + 1;
 
    // If total numbers of ugly number
    // less than qual to
    // mid is greater than n we update
    // r and ans simultaneously.
    else
      r = mid - 1, ans = mid;
  }
 
  return ans;
}
 
// Driver Code
int main()
{
     
    int n = 150;
   
    // Function Call
    cout << nthUglyNumber(n);
    return 0;
}
Output
5832
Time Complexity: O(log N)
Auxiliary Space: O(1)
Please write comments if you find any bug in the above program or other ways to solve the same problem. 
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.
My Personal Notes
arrow_drop_up
Next

Program for Fibonacci numbers
Recommended Articles
Page :
Maximum length of a sub-array with ugly numbers
18, Mar 19
Total distinct pairs of ugly numbers from two arrays
20, Mar 19
Sort ugly numbers in an array at their relative positions
26, Mar 19
Super Ugly Number (Number whose prime factors are in given set)
05, Jan 17
Check whether a given number is an ugly number or not
20, Jul 20
Print numbers such that no two consecutive numbers are co-prime and every three consecutive numbers are co-prime
22, Jan 19
Kth element in permutation of first N natural numbers having all even numbers placed before odd numbers in increasing order
03, Mar 21
Given pairwise sum of n numbers, find the numbers
31, Mar 17
Print all distinct integers that can be formed by K numbers from a given array of N numbers
02, Jul 18
Absolute Difference between the Sum of Non-Prime numbers and Prime numbers of an Array
02, Nov 18
Absolute difference between the Product of Non-Prime numbers and Prime numbers of an Array
03, Nov 18
Bitwise AND of the sum of prime numbers and the sum of composite numbers in an array
20, Sep 19
Absolute difference between the XOR of Non-Prime numbers and Prime numbers of an Array
23, Sep 19
Count of N-digit Numbers having Sum of even and odd positioned digits divisible by given numbers
07, Aug 20
Maximize count of equal numbers in Array of numbers upto N by replacing pairs with their sum
28, Aug 20
Count prime numbers that can be expressed as sum of consecutive prime numbers
10, Sep 20
Sort all even numbers in ascending order and then sort all odd numbers in descending order
11, Mar 17
Game of Numbers - Playing with Numbers | Class 8 Maths
02, Dec 20
Fill the missing numbers in the array of N natural numbers such that arr[i] not equal to i
26, Feb 20
Find ratio of zeroes, positive numbers and negative numbers in the Array
19, Apr 20
Rearrange numbers in an array such that no two adjacent numbers are same
10, Jun 19
Even numbers at even index and odd numbers at odd index
28, Oct 17
Count of numbers upto M divisible by given Prime Numbers
31, Jul 20
Maximum sum of distinct numbers such that LCM of these numbers is N
04, Jun 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox