web-dev-qa-db-fra.com

Comment arrondir un entier à la centaine proche?

Je ne le sais pas ma nomenclature est correcte! Quoi qu'il en soit, ce sont l'entier que j'ai, par exemple:

76
121
9660

Et je voudrais les arrondir à la centaine près, tels qu'ils doivent devenir:

100
100
9700

Comment puis-je le faire plus rapidement en C #? Je pense à un algorithme, mais il y a peut-être des utilitaires sur C #?

c#.netmath
36
markzzz

Essaie le Math.Round méthode. Voici comment:

Math.Round(76d / 100d, 0) * 100;
Math.Round(121d / 100d, 0) * 100;
Math.Round(9660d / 100d, 0) * 100;
70
krizzzn

J'ai écrit une méthode d'extension simple pour généraliser ce type d'arrondi il y a quelque temps:

public static class MathExtensions
{
    public static int Round(this int i, int nearest)
    {
        if (nearest <= 0 || nearest % 10 != 0)
            throw new ArgumentOutOfRangeException("nearest", "Must round to a positive multiple of 10");

        return (i + 5 * nearest / 10) / nearest * nearest;
    }
}

Il exploite la division entière pour trouver l'arrondi le plus proche.

Exemple d'utilisation:

int example = 152;
Console.WriteLine(example.Round(100)); // round to the nearest 100
Console.WriteLine(example.Round(10)); // round to the nearest 10

Et dans votre exemple:

Console.WriteLine(76.Round(100)); // 100
Console.WriteLine(121.Round(100)); // 100
Console.WriteLine(9660.Round(100)); // 9700
23
Jason Larke

Essayez cette expression:

(n + 50) / 100 * 100
16
Marcelo Cantos

Juste un ajout à la réponse acceptée de @ krizzzn ...

Notez que ce qui suit renverra 0:

Math.Round(50d / 100d, 0) * 100;

Envisagez d'utiliser ce qui suit et faites-le renvoyer 100 à la place:

Math.Round(50d / 100d, 0, MidpointRounding.AwayFromZero) * 100;

Selon ce que vous faites, l'utilisation de décimales peut être un meilleur choix (notez le m ):

Math.Round(50m / 100m, 0, MidpointRounding.AwayFromZero) * 100m;
7
Jim Aho

Je sais que c'est un vieux fil. J'ai écrit une nouvelle méthode. J'espère que cela sera utile pour quelqu'un.

    public static double Round(this float value, int precision)
    {
        if (precision < -4 && precision > 15)
            throw new ArgumentOutOfRangeException("precision", "Must be and integer between -4 and 15");

        if (precision >= 0) return Math.Round(value, precision);
        else
        {
            precision = (int)Math.Pow(10, Math.Abs(precision));
            value = value + (5 * precision / 10);
            return Math.Round(value - (value % precision), 0);
        }
    }

Exemple:

float value = F6666.677777;
Console.Write(value.Round(2)) // = 6666.68
Console.Write(value.Round(0)) // = 6667
Console.Write(value.Round(-2)) // = 6700
6
Raghu

Salut, j'écris cette extension, cela donne la centaine suivante pour chaque numéro que vous passez

/// <summary>
    /// this extension gets the next hunfìdred for any number you whant
    /// </summary>
    /// <param name="i">numeber to rounded</param>
    /// <returns>the next hundred number</returns>
    /// <remarks>
    /// eg.:
    /// i =   21 gets 100
    /// i =  121 gets 200
    /// i =  200 gets 300
    /// i = 1211 gets 1300
    /// i = -108 gets -200
    /// </remarks>
    public static int RoundToNextHundred(this int i)
    {
        return i += (100 * Math.Sign(i) - i % 100);
        //use this line below if you want RoundHundred not NEXT
        //return i % 100 == byte.MinValue? i : i += (100 * Math.Sign(i) - i % 100);
    }

    //and for answer at title point use this algoritm
    var closeHundred = Math.Round(number / 100D)*100;

    //and here the extension method if you prefer

    /// <summary>
    /// this extension gets the close hundred for any number you whant
    /// </summary>
    /// <param name="number">number to be rounded</param>
    /// <returns>the close hundred number</returns>
    /// <remarks>
    /// eg.:
    /// number =   21 gets    0
    /// number =  149 gets  100
    /// number =  151 gets  200
    /// number = -149 gets -100
    /// number = -151 gets -200
    /// </remarks>
    public static int RoundCloseHundred(this int number)
    {
        return (int)Math.Round(number / 100D) * 100;
    }
1
luka
int num = 9660;
int remainder = num % 100;
Console.WriteLine(remainder < 50 ? num - remainder : num + (100 -remainder));

Remarque: je n'ai pas testé cela à fond.

0
shahkalpesh

Si vous souhaitez uniquement arrondir les nombres entiers (comme l'OP l'a fait), vous pouvez recourir à cette solution:

public static class MathExtensions
{
    public static int RoundUpTo(this int number, int nearest)
    {
        if (nearest < 10 || nearest % 10 != 0)
            throw new ArgumentOutOfRangeException(nameof(nearest), $"{nameof(nearest)} must be a positive multiple of 10, but you specified {nearest}.");

        int modulo = number % nearest;
        return modulo == 0 ? number : modulo > 0 ? number + (nearest - modulo) : number - modulo;
    }
}

Si vous souhaitez effectuer un arrondi à virgule flottante (ou décimal), utilisez les réponses de @krizzzn et @Jim Aho.

0
feO2x