# Round the given number to nearest multiple of 10 | Set-2

• Difficulty Level : Easy
• Last Updated : 22 Dec, 2022

Given a large positive integer represented as a string str. The task is to round this number to the nearest multiple of 10

Examples:

Input: str = “99999999999999993”
Output: 99999999999999990

Input: str = “99999999999999996”
Output: 100000000000000000

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: A solution to the same problem has been discussed in this article which will not work for large numbers. When the number is large and represented as strings we can process the number digit by digit. The main observation is that if the last digit of the number is â‰¤ 5 then only the last digit will get affected i.e. it will be replaced with a 0. If it is something greater than 5 then the number has to be rounded to some next higher multiple of 10 i.e. the last digit will be replaced with a 0 and 1 will have to be added to the rest of the number i.e. the number represented by the sub-string str[0…n-1] which can be done by storing carry generated at every step (digit).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to round the given number``// to the nearest multiple of 10``void` `roundToNearest(string str, ``int` `n)``{` `    ``// If string is empty``    ``if` `(str == ``""``)``        ``return``;` `    ``// If the last digit is less than or equal to 5``    ``// then it can be rounded to the nearest``    ``// (previous) multiple of 10 by just replacing``    ``// the last digit with 0``    ``if` `(str[n - 1] - ``'0'` `<= 5) {` `        ``// Set the last digit to 0``        ``str[n - 1] = ``'0'``;` `        ``// Print the updated number``        ``cout << str.substr(0, n);``    ``}` `    ``// The number hast to be rounded to``    ``// the next multiple of 10``    ``else` `{` `        ``// To store the carry``        ``int` `carry = 0;` `        ``// Replace the last digit with 0``        ``str[n - 1] = ``'0'``;` `        ``// Starting from the second last digit, add 1``        ``// to digits while there is carry``        ``int` `i = n - 2;``        ``carry = 1;` `        ``// While there are digits to consider``        ``// and there is carry to add``        ``while` `(i >= 0 && carry == 1) {` `            ``// Get the current digit``            ``int` `currentDigit = str[i] - ``'0'``;` `            ``// Add the carry``            ``currentDigit += carry;` `            ``// If the digit exceeds 9 then``            ``// the carry will be generated``            ``if` `(currentDigit > 9) {``                ``carry = 1;``                ``currentDigit = 0;``            ``}` `            ``// Else there will be no carry``            ``else``                ``carry = 0;` `            ``// Update the current digit``            ``str[i] = (``char``)(currentDigit + ``'0'``);` `            ``// Get to the previous digit``            ``i--;``        ``}` `        ``// If the carry is still 1 then it must be``        ``// inserted at the beginning of the string``        ``if` `(carry == 1)``            ``cout << carry;` `        ``// Print the rest of the number``        ``cout << str.substr(0, n);``    ``}``}` `// Driver code``int` `main()``{``    ``string str = ``"99999999999999993"``;``    ``int` `n = str.length();` `    ``roundToNearest(str, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;``class` `GFG``{` `// Function to round the given number``// to the nearest multiple of 10``static` `void` `roundToNearest(StringBuilder str, ``int` `n)``{` `    ``// If string is empty``    ``if` `(str.toString() == ``""``)``        ``return``;` `    ``// If the last digit is less than or equal to 5``    ``// then it can be rounded to the nearest``    ``// (previous) multiple of 10 by just replacing``    ``// the last digit with 0``    ``if` `(str.charAt(n - ``1``) - ``'0'` `<= ``5``)``    ``{` `        ``// Set the last digit to 0``        ``str.setCharAt(n - ``1``, ``'0'``);` `        ``// Print the updated number``        ``System.out.print(str.substring(``0``, n));``    ``}` `    ``// The number hast to be rounded to``    ``// the next multiple of 10``    ``else``    ``{` `        ``// To store the carry``        ``int` `carry = ``0``;` `        ``// Replace the last digit with 0``        ``str.setCharAt(n - ``1``, ``'0'``);` `        ``// Starting from the second last digit,``        ``// add 1 to digits while there is carry``        ``int` `i = n - ``2``;``        ``carry = ``1``;` `        ``// While there are digits to consider``        ``// and there is carry to add``        ``while` `(i >= ``0` `&& carry == ``1``)``        ``{` `            ``// Get the current digit``            ``int` `currentDigit = str.charAt(i) - ``'0'``;` `            ``// Add the carry``            ``currentDigit += carry;` `            ``// If the digit exceeds 9 then``            ``// the carry will be generated``            ``if` `(currentDigit > ``9``)``            ``{``                ``carry = ``1``;``                ``currentDigit = ``0``;``            ``}` `            ``// Else there will be no carry``            ``else``                ``carry = ``0``;` `            ``// Update the current digit``            ``str.setCharAt(i, (``char``)(currentDigit + ``'0'``));` `            ``// Get to the previous digit``            ``i--;``        ``}` `        ``// If the carry is still 1 then it must be``        ``// inserted at the beginning of the string``        ``if` `(carry == ``1``)``            ``System.out.print(carry);` `        ``// Print the rest of the number``        ``System.out.print(str.substring(``0``, n));``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``StringBuilder str = ``new` `StringBuilder(``"99999999999999993"``);``    ``int` `n = str.length();``    ``roundToNearest(str, n);``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Python 3 implementation of the approach` `# Function to round the given number``# to the nearest multiple of 10``def` `roundToNearest(``str``, n):``    ` `    ``# If string is empty``    ``if` `(``str` `=``=` `""):``        ``return` `    ``# If the last digit is less than or equal to 5``    ``# then it can be rounded to the nearest``    ``# (previous) multiple of 10 by just replacing``    ``# the last digit with 0``    ``if` `(``ord``(``str``[n ``-` `1``]) ``-` `ord``(``'0'``) <``=` `5``):``        ` `        ``# Set the last digit to 0``        ``str` `=` `list``(``str``)``        ``str``[n ``-` `1``] ``=` `'0'``        ``str` `=` `''.join(``str``)` `        ``# Print the updated number``        ``print``(``str``[``0``:n])` `    ``# The number hast to be rounded to``    ``# the next multiple of 10``    ``else``:``        ` `        ``# To store the carry``        ``carry ``=` `0` `        ``# Replace the last digit with 0``        ``str` `=` `list``(``str``)``        ``str``[n ``-` `1``] ``=` `'0'` `        ``str` `=` `''.join(``str``)` `        ``# Starting from the second last digit,``        ``# add 1 to digits while there is carry``        ``i ``=` `n ``-` `2``        ``carry ``=` `1` `        ``# While there are digits to consider``        ``# and there is carry to add``        ``while` `(i >``=` `0` `and` `carry ``=``=` `1``):``            ` `            ``# Get the current digit``            ``currentDigit ``=` `ord``(``str``[i]) ``-` `ord``(``'0'``)` `            ``# Add the carry``            ``currentDigit ``+``=` `carry` `            ``# If the digit exceeds 9 then``            ``# the carry will be generated``            ``if` `(currentDigit > ``9``):``                ``carry ``=` `1``                ``currentDigit ``=` `0` `            ``# Else there will be no carry``            ``else``:``                ``carry ``=` `0` `            ``# Update the current digit``            ``str``[i] ``=` `chr``(currentDigit ``+` `'0'``)` `            ``# Get to the previous digit``            ``i ``-``=` `1` `        ``# If the carry is still 1 then it must be``        ``# inserted at the beginning of the string``        ``if` `(carry ``=``=` `1``):``            ``print``(carry)` `        ``# Print the rest of the number``        ``print``(``str``[``0``:n])``    ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``str` `=` `"99999999999999993"``    ``n ``=` `len``(``str``)` `    ``roundToNearest(``str``, n)` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Text;` `class` `GFG``{` `// Function to round the given number``// to the nearest multiple of 10``static` `void` `roundToNearest(StringBuilder str, ``int` `n)``{` `    ``// If string is empty``    ``if` `(str.ToString() == ``""``)``        ``return``;` `    ``// If the last digit is less than or equal to 5``    ``// then it can be rounded to the nearest``    ``// (previous) multiple of 10 by just replacing``    ``// the last digit with 0``    ``if` `(str[n - 1] - ``'0'` `<= 5)``    ``{` `        ``// Set the last digit to 0``        ``str[n - 1] = ``'0'``;` `        ``// Print the updated number``        ``Console.Write(str.ToString().Substring(0, n));``    ``}` `    ``// The number hast to be rounded to``    ``// the next multiple of 10``    ``else``    ``{` `        ``// To store the carry``        ``int` `carry = 0;` `        ``// Replace the last digit with 0``        ``str[n - 1] = ``'0'``;` `        ``// Starting from the second last digit,``        ``// add 1 to digits while there is carry``        ``int` `i = n - 2;``        ``carry = 1;` `        ``// While there are digits to consider``        ``// and there is carry to add``        ``while` `(i >= 0 && carry == 1)``        ``{` `            ``// Get the current digit``            ``int` `currentDigit = str[i] - ``'0'``;` `            ``// Add the carry``            ``currentDigit += carry;` `            ``// If the digit exceeds 9 then``            ``// the carry will be generated``            ``if` `(currentDigit > 9)``            ``{``                ``carry = 1;``                ``currentDigit = 0;``            ``}` `            ``// Else there will be no carry``            ``else``                ``carry = 0;` `            ``// Update the current digit``            ``str[i] = (``char``)(currentDigit + ``'0'``);` `            ``// Get to the previous digit``            ``i--;``        ``}` `        ``// If the carry is still 1 then it must be``        ``// inserted at the beginning of the string``        ``if` `(carry == 1)``            ``Console.Write(carry);` `        ``// Print the rest of the number``        ``Console.Write(str.ToString().Substring(0, n));``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``StringBuilder str = ``new` `StringBuilder(``"99999999999999993"``);``    ``int` `n = str.Length;``    ``roundToNearest(str, n);``}``}` `// This code is contributed by``// Rajnis09`

## Javascript

 `// JS implementation of the approach` `// Function to round the given number``// to the nearest multiple of 10``function` `roundToNearest(str, n)``{``    ``str = Array.from(str)``    ` `    ``// If string is empty``    ``if` `((str.join(``""``)).localeCompare(``""``) == 0)``        ``return``;` `    ``// If the last digit is less than or equal to 5``    ``// then it can be rounded to the nearest``    ``// (previous) multiple of 10 by just replacing``    ``// the last digit with 0``    ``if` `(parseInt(str[n - 1]) <= 5)``    ``{` `        ``// Set the last digit to 0``        ``str[n - 1] = ``'0'``;` `        ``// Print the updated number``        ``process.stdout.write(str.join(``""``));``    ``}` `    ``// The number hast to be rounded to``    ``// the next multiple of 10``    ``else``    ``{` `        ``// To store the carry``        ``let carry = 0;` `        ``// Replace the last digit with 0``        ``str[n - 1] = ``'0'``;` `        ``// Starting from the second last digit,``        ``// add 1 to digits while there is carry``        ``let i = n - 2;``        ``carry = 1;` `        ``// While there are digits to consider``        ``// and there is carry to add``        ``while` `(i >= 0 && carry == 1)``        ``{` `            ``// Get the current digit``            ``let currentDigit = parseInt(str[i]);` `            ``// Add the carry``            ``currentDigit += carry;` `            ``// If the digit exceeds 9 then``            ``// the carry will be generated``            ``if` `(currentDigit > 9)``            ``{``                ``carry = 1;``                ``currentDigit = 0;``            ``}` `            ``// Else there will be no carry``            ``else``                ``carry = 0;` `            ``// Update the current digit``            ``str[i] = String(currentDigit);` `            ``// Get to the previous digit``            ``i--;``        ``}` `        ``// If the carry is still 1 then it must be``        ``// inserted at the beginning of the string``        ``if` `(carry == 1)``            ``process.stdout.write(1);` `        ``// Print the rest of the number``        ``process.stdout.write(str.join(``""``));``    ``}``}` `// Driver code``let str = ``"99999999999999993"``;``let n = str.length;``roundToNearest(str, n);`` ` `// This code is contributed by``// phasing17`

Output:

`99999999999999990`

Time Complexity: O(n), where n is the length of the given string.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

My Personal Notes arrow_drop_up