Open In App

Round the given number to nearest multiple of 10

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

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

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:  

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.


Python3




# 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.


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
?>


Javascript




<script>
    // 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;
      document.write(round(n));
          
        // THIS CODE IS CONTRIBUTED BY MUKESH07.
</script>


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 or 2 or 3 or 4 or 5 make it 0
    else if(c[n - 1] == '1' || c[n - 1] == '2' || 
            c[n - 1] == '3' || c[n - 1] == '4' || 
            c[n - 1] == '5' )
    {
      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 or 2 or 3 or 4 or 5 make it 0
    else if(c[n-1] == '1' || c[n-1] == '2' || 
            c[n-1] == '3' || c[n-1] == '4' || 
            c[n-1] == '5' )
    {
      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));
  
  }
}


Python3




# 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 or 2 or 3 or 4 or 5 make it 0
    elif (c[n - 1] == '1' or c[n - 1] == '2' or 
          c[n - 1] == '3' or c[n - 1] == '4' or 
          c[n - 1] == '5'):
        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 or 2 or 3 or 4 or 5 make it 0
    else if(c[n - 1] == '1' || c[n - 1] == '2' || 
            c[n - 1] == '3' || c[n - 1] == '4' || 
            c[n - 1] == '5' )
    {
      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




<script>
  
// 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 or 2 or 3 or 4 or 5 make it 0
    else if (c[n - 1] == '1' || c[n - 1] == '2' ||
             c[n - 1] == '3' || c[n - 1] == '4' ||
             c[n - 1] == '5' )
    {
        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
document.write(round(s,n));
  
// This code is contributed by rameshtravel07
  
</script>


Output

5748965412485599999874589966000

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



Last Updated : 20 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads