Round the given number to nearest multiple of 10

Last Updated : 19 Jun, 2024

Given a positive integer n, round it to nearest whole number having zero as last digit.

Examples: 

Input : 4722
Output : 4720

Input : 38
Output : 40

Input : 10
Output: 10
Recommended Practice
Nearest multiple of 10
Try It!

Approach: 

Let's round down the given number n to the nearest integer which ends with 0 and store this value in a variable a. 
a = (n / 10) * 10. So, the round up n (call it b) is b = a + 10.
If n - a > b - n then the answer is b otherwise the answer is a.

Below is the implementation of the above approach:  

Try It Yourself
redirect icon
C++
// C++ program to round the given 
// integer to a whole number 
// which ends with zero.
#include <bits/stdc++.h>
using namespace std;

// function to round the number
int round(int n)
{
    // Smaller multiple
    int a = (n / 10) * 10;
    
    // Larger multiple
    int b = a + 10;

    // Return of closest of two
    return (n - a >= b - n)? b : a;
}

// driver function
int main()
{
    int n = 4722;
    cout << round(n) << endl;
    return 0;
}
Java
// Java Code for Round the given number
// to nearest multiple of 10
import java.util.*;

class GFG {
    
    // function to round the number
    static int round(int n)
    {
        // Smaller multiple
        int a = (n / 10) * 10;
         
        // Larger multiple
        int b = a + 10;
     
        // Return of closest of two
        return (n - a >= b - n)? b : a;
    }
    
    /* Driver program to test above function */
    public static void main(String[] args) 
    {
         int n = 4722;
         System.out.println(round(n));
    }
}

// This code is contributed by Arnav Kr. Mandal.
Python
# Python3 code to round the given 
# integer to a whole number 
# which ends with zero.

# function to round the number
def round( n ):

    # Smaller multiple
    a = (n // 10) * 10
    
    # Larger multiple
    b = a + 10
    
    # Return of closest of two
    return (b if n - a >= b - n else a)

# driver code
n = 4722
print(round(n))

# This code is contributed by "Sharad_Bhardwaj".
C#
// C# Code for Round the given number
// to nearest multiple of 10
using System;

class GFG {
    
    // function to round the number
    static int round(int n)
    {
        // Smaller multiple
        int a = (n / 10) * 10;
        
        // Larger multiple
        int b = a + 10;
    
        // Return of closest of two
        return (n - a >= b - n)? b : a;
    }
    
    // Driver program 
    public static void Main() 
    {
        int n = 4722;
        Console.WriteLine(round(n));
    }
}

// This code is contributed by Vt_m.
JavaScript
    // Javascript Code for Round the given number
    // to nearest multiple of 10
    
    // function to round the number
    function round(n)
    {
        // Smaller multiple
        let a = parseInt(n / 10, 10) * 10;
         
        // Larger multiple
        let b = a + 10;
     
        // Return of closest of two
        return (n - a >= b - n)? b : a;
    }
    
    let n = 4722;
      console.log(round(n));
        
        // THIS CODE IS CONTRIBUTED BY MUKESH07.
PHP
<?php
// PHP program to round the given integer 
// to a whole number which ends with zero. 

// function to round the number 
function roundFunation($n) 
{ 
    // Smaller multiple 
    $a = (int)($n / 10) * 10; 
    
    // Larger multiple 
    $b = ($a + 10); 

    // Return of closest of two 
    return ($n - $a >= $b - $n) ? $b : $a; 
} 

// Driver Code 
$n = 4722; 
echo roundFunation($n), "\n"; 
    
// This code is contributed by ajit
?>

Output
4720

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

Another method if n is large:
The above method is good only for Integer or Long MAX value. if the input length is greater than the integer or long-range above method does not work.

We can solve the problem using String.

C++
// C++ code for above approach
#include <bits/stdc++.h>
using namespace std;

// Program to round the number to the 
// nearest number having one's digit 0
string Round(string s, int n)
{
    string c = s;
    
    // last character is 0 then return the
    // original string
    if(c[n - 1] == '0')
      return s;
     
    // if last character is '1' to '4'
    else if(c[n - 1] >= '1' && c[n - 1] <= '4')
    {
      c[n - 1] = '0';
      return c;
    }
    else
    {
      c[n - 1] = '0';
       
      // process carry 
      for(int i = n - 2 ; i >= 0 ; i--)
      {
        if(c[i] == '9')
          c[i] = '0';
        else
        {
          int t = c[i] - '0' + 1;
          c[i] = (char)(48 + t);
          break;
        }
      } 
    }
    
    string s1 = c;
    
    if(s1[0] == '0')
      s1 = "1" + s1;
     
    // return final string
    return s1;
}

// Driver code
int main()
{
    string s="5748965412485599999874589965999";
    int n=s.length();
     
    // Function Call
    cout << Round(s,n) << endl;

    return 0;
}

// This code is contributed by divyeshrabadiya07
Java
// Java code for above approach
import java.io.*;

class GFG 
{
  
  // Program to round the number to the 
  // nearest number having one's digit 0
  public static String round(String s, int n)
  {
    char[] c=s.toCharArray();

    // last character is 0 then return the
    // original string
    if(c[n-1]=='0')
      return s;
    
    // if last character is '1' to '4'
    else if(c[n - 1] >= '1' && c[n - 1] <= '4')
    {
      c[n-1]='0';
      return new String(c);
    }
    else
    {
      c[n-1]='0';
      
      // process carry 
      for(int i = n - 2 ; i >= 0 ; i--)
      {
        if(c[i] == '9')
          c[i]='0';
        else
        {
          int t= c[i] - '0' + 1;
          c[i]=(char)(48+t);
          break;
        }
      } 
    }

    String s1=new String(c);

    if(s1.charAt(0) == '0')
      s1="1"+s1;
    
    // return final string
    return s1;
  }

  // Driver Code
  public static void main (String[] args) 
  {

    String s="5748965412485599999874589965999";
    int n=s.length();
    
    // Function Call
    System.out.println(round(s,n));

  }
}
Python
# Python3 code for above approach

# Function to round the number to the 
# nearest number having one's digit 0
def Round(s, n):
    
    s = list(s)
    c = s.copy()

    # Last character is 0 then return the
    # original string
    if (c[n - 1] == '0'):
        return ("".join(s))
        
    # If last character is '1' to '4'
    elif (c[n - 1] >= '1' and c[n - 1] <= '4'):
        c[n - 1] = '0'
        return ("".join(c))
    else:
        c[n - 1] = '0'

        # Process carry 
        for i in range(n - 2, -1, -1):
            if (c[i] == '9'):
                c[i] = '0'
            else:
                t = ord(c[i]) - ord('0') + 1
                c[i] = chr(48 + t)
                break
                
    s1 = "".join(c)
    
    if (s1[0] == '0'):
        s1 = "1" + s1
        
    # Return final string
    return s1

# Driver code
s = "5748965412485599999874589965999"
n = len(s)

print(Round(s, n))

# This code is contributed by rag2127
C#
// C# code for above approach
using System;
class GFG {

    // Program to round the number to the
    // nearest number having one's digit 0
    static string round(string s, int n)
    {
        char[] c = s.ToCharArray();

        // last character is 0 then return the
        // original string
        if (c[n - 1] == '0')
            return s;

        // if last character is '1' to '4'
        else if (c[n - 1] >= '1' && c[n - 1] <= '4') {
            c[n - 1] = '0';
            return new string(c);
        }
        else {
            c[n - 1] = '0';

            // process carry
            for (int i = n - 2; i >= 0; i--) {
                if (c[i] == '9')
                    c[i] = '0';
                else {
                    int t = c[i] - '0' + 1;
                    c[i] = (char)(48 + t);
                    break;
                }
            }
        }

        string s1 = new string(c);

        if (s1[0] == '0')
            s1 = "1" + s1;

        // return final string
        return s1;
    }

    static void Main()
    {
        string s = "5748965412485599999874589965999";
        int n = s.Length;

        // Function Call
        Console.WriteLine(round(s, n));
    }
}

// This code is contributed by divyesh072019
JavaScript
// Javascript code for above approach

// Program to round the number to the
// nearest number having one's digit 0
function round(s, n)
{
    let c = s.split('');
    
    // Last character is 0 then return the
    // original string
    if (c[n - 1] == '0')
        return s;
    
    // If last character is '1' to '4'
    else if (c[n - 1] >= '1' && c[n - 1] <= '4')
    {
        c[n - 1] = '0';
        return c.join("");
    }
    else
    {
        c[n - 1] = '0';
        
        // process carry
        for(let i = n - 2 ; i >= 0 ; i--)
        {
            if (c[i] == '9')
                c[i] = '0';
            else
            {
                let t = c[i].charCodeAt() - 
                         '0'.charCodeAt() + 1;
                c[i] = String.fromCharCode(48 + t);
                break;
            }
        }
    }
    
    let s1 = c.join("");
    
    if (s1[0] == '0')
        s1 = "1" + s1;
    
    // Return final string
    return s1;
}

// Driver code   
let s = "5748965412485599999874589965999";
let n = s.length;
  
// Function Call
console.log(round(s,n));

// This code is contributed by rameshtravel07

Output
5748965412485599999874589966000

Time Complexity: O(N) where N is length of string.
Auxiliary Space: O(1)

Comment

Explore