 Open in App
Not now

# Round the given number to nearest multiple of 10

• Difficulty Level : Basic
• Last Updated : 20 Feb, 2023

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

 ` ``\$b` `- ``\$n``) ? ``\$b` `: ``\$a``;  ` `}  ` ` `  `// Driver Code  ` `\$n` `= 4722;  ` `echo` `roundFunation(``\$n``), ``"\n"``;  ` `     `  `// This code is contributed by ajit ` `?> `

## Javascript

 ``

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 ` `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'``) ` `      ``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'``) ` `      ``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

 ``

Output

`5748965412485599999874589966000`

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

My Personal Notes arrow_drop_up
Related Articles