Construído em .net algoritmo para valor volta para o 10 intervalo mais próximo

Question

Como, em C # redonda qualquer valor a 10 intervalo? Por exemplo, se eu tiver 11, eu quero que ela retorne 10, se eu tiver 136, então eu quero que ele retorne 140.

Eu posso facilmente fazê-lo com a mão

return ((int)(number / 10)) * 10;

Mas estou procurando um algoritmo builtin para fazer este trabalho, algo como Math.Round (). A razão pela qual eu não vai querer fazer com a mão é que eu não quero escrever igual ou semelhante pedaço de código todo meus projetos, mesmo para algo tão simples como o acima.

Answer 1

Não há built-in função na biblioteca de classes que vai fazer isso. O mais próximo é System.Math.Round () que é apenas para arredondar o número de tipos decimal e duas vezes para o valor inteiro mais próximo. No entanto, você pode quebrar a sua declaração em um método de extensão, se você estiver trabalhando com .NET 3.5, o que permitirá que você use a função muito mais limpa.

public static class ExtensionMethods
{
    public static int RoundOff (this int i)
    {
        return ((int)Math.Round(i / 10.0)) * 10;
    }
}

int roundedNumber = 236.RoundOff(); // returns 240
int roundedNumber2 = 11.RoundOff(); // returns 10

Se você estiver programando contra uma versão mais antiga do framework .NET, basta remover o "presente" da função de arredondamento, e chamar a função assim:

int roundedNumber = ExtensionMethods.RoundOff(236); // returns 240
int roundedNumber2 = ExtensionMethods.RoundOff(11); // returns 10

Answer 2

Use Math.Ceiling para sempre até round.

int number = 236;
number = (int)(Math.Ceiling(number / 10.0d) * 10);

Modulus (%) recebe o restante, de modo a obter:

// number = 236 + 10 - 6

Coloque isso em um método de extensão

public static int roundupbyten(this int i){
    // return i + (10 - i % 10); <-- logic error. Oops!
    return (int)(Math.Ceiling(i / 10.0d)*10); // fixed
}

// call like so:
int number = 236.roundupbyten();

acima editado: Eu deveria ter ido com o meu primeiro instinto de usar Math.Ceiling

blog sobre isso ao calcular os dígitos de verificação UPC .

Answer 3

Isso pode ser um pouco tarde demais, mas acho que isso pode ser de boa ajuda algum dia ...

Eu tentei isso:

public int RoundOff(int number, int interval){
    int remainder = number % interval;
    number += (remainder < interval / 2) ? -remainder : (interval - remainder);
    return number;
}

Para usar:

int number = 11;
int roundednumber = RoundOff(number, 10);

Desta forma, você tem a opção se se a metade do intervalo será arredondado para cima ou para baixo arredondado. =)

Answer 4

Completando um float para um inteiro é semelhante a (int) (x + 0,5), ao invés de simplesmente fundição x -. Se você quiser um múltiplo de 10, você pode facilmente adaptar esse

Se você quiser apenas fazer número inteiro matemática e são arredondando-a dez, tente (x + 10/2) / 10 * 10.

Editar: notei que esta resposta não atender o pedido do autor do original, e é também uma forma tendenciosa de arredondamento que eu prefiro não fazer. Math.round No entanto, uma outra resposta aceite já foi dito (), uma solução muito melhor.

Answer 5

velha questão, mas aqui é uma maneira de fazer o que foi pedido mais eu estendeu para ser capaz de completar qualquer número para o número de figos sig que você deseja.

    private double Rounding(double d, int digits)
    {
        int neg = 1;
        if (d < 0)
        {
            d = d * (-1);
            neg = -1;
        }

        int n = 0;
        if (d > 1)
        {
            while (d > 1)
            {
                d = d / 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d * Math.Pow(10, n - digits);
        }
        else
        {
            while (d < 0.1)
            {
                d = d * 10;
                n++;
            }
            d = Math.Round(d * Math.Pow(10, digits));
            d = d / Math.Pow(10, n + digits);
        }

        return d*neg;
    }


   private void testing()
   {
       double a = Rounding(1230435.34553,3);
       double b = Rounding(0.004567023523,4);
       double c = Rounding(-89032.5325,2);
       double d = Rounding(-0.123409,4);
       double e = Rounding(0.503522,1);
       Console.Write(a.ToString() + "\n" + b.ToString() + "\n" + 
           c.ToString() + "\n" + d.ToString() + "\n" + e.ToString() + "\n");
   }

Answer 6

Eu prefiro não trazer na biblioteca Math nem ir para ponto flutuante por isso a minha sugestão é apenas fazer número inteiro aritmética como abaixo onde eu arredondar para o próximo 1K. Envolvê-la em um método ou lambda trecho ou algo se você não quer repetir.

int MyRoundedUp1024Int = ((lSomeInteger + 1023) / 1024) * 1024;

Eu não executar testes de desempenho neste outro vs. as maneiras, mas eu aposto que é a maneira mais rápida de fazer isso, salvo talvez um deslocamento e rotação da versão pedaços deste.