Redondea el número dado al múltiplo más cercano de 10 | Conjunto-2

Dado un entero positivo grande representado como una string str . La tarea es redondear este número al múltiplo de 10 más cercano .

Ejemplos:

Entrada: str = “99999999999999993”
Salida: 99999999999999990

Entrada: str = “99999999999999996”
Salida: 100000000000000000

Enfoque: En este artículo se ha discutido una solución al mismo problema que no funcionará para grandes números. Cuando el número es grande y se representa como strings, podemos procesar el número dígito por dígito. La observación principal es que si el último dígito del número es ≤ 5 , solo el último dígito se verá afectado, es decir, será reemplazado por un 0 . Si es algo mayor que 5, entonces el número debe redondearse al siguiente múltiplo más alto de 10 , es decir, el último dígito se reemplazará con un 0 y se deberá agregar 1 al resto del número, es decir, el número representado por el substring str[0…n-1]lo que se puede hacer almacenando el acarreo generado en cada paso (dígito).

A continuación se muestra la implementación del enfoque anterior:

// C++ implementation of the approach
#include <bits/stdc++.h>
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 then 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 implementation of the approach 
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 then 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

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

99999999999999990