Round the given number to nearest multiple of 10 (original) (raw)

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

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

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

`

**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)