Comment arrondir un nombre entier pour la proximité cent?

Je ne sais pas il ma nomenclature est correct! De toute façon, ce sont les entier je n'ai, par exemple :

76
121
9660

Et j'aimerais autour d'eux jusqu'à la fin centaines de, comme ils doivent devenir :

100
100
9700

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

Il a essayé de StackOverflow!
hahaha!!! Ouais, j'ai essayé avec près @L. B solution (il supprimer le post, je ne sais pas : var newi = (int)Math.Round(oldi / 100d)*100;). Je pense que c'est le meilleur moyen...
Qu'en 50? 0 ou 100?

InformationsquelleAutor markzzz | 2012-10-31

.net c#math

68

Essayer 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;
```
- C'est la solution la plus simple à comprendre à partir du lot. +1! Vous n'avez pas besoin de la surcharge de spécifier 0 bien. Peut-être que vous pourriez utiliser le milieu de l'arrondi de surcharge mieux
- Décimal, pas de double pour cette.
- Je ne pense pas que c'est la manière dont la plupart des gens attendent! Math.Round tronque la valeur Math.Round(50d / 100d, 0) sera de 0. Certaines personnes pourrait s'attendre à 100.
- Lorsque vous vous attendez à ce que 50/100 tours à l'un, vous pouvez utiliser le Math.Round(decimal d, int decimals, MidpointRounding mode) surcharge: Math.Round(50d / 100d, 0, MidpointRounding.AwayFromZero);
- Oh. Je viens de voir que @JimAho ajouté une réponse à cette question qui vous montre comment utiliser le MidpointRounding enum (stackoverflow.com/a/36421665/964821)
InformationsquelleAutor krizzzn
23

J'ai écrit une simple extension de la méthode de généraliser ce type d'arrondi il y a un moment:
```
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;
    }
}
```
De tirer profit de la division entière pour trouver la plus proche de l'arrondissement.

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
```
- Ce qui donnerait pour 51.Round(-10) ?
- +1 Pour les très pratique méthode d'extension!
- Je l'ai testé et il m'a donné 40.
- Il serait jeter un UseYourCommonSense exception.
- Changé la logique d'exception.
- Merci! Aussi, quel est-il appelé ensuite vous utilisez this int i pour le premier paramètre. C'est un nouveau truc que j'ai appris de cette réponse.
- Il a appelé une Extension Method voir msdn.microsoft.com/en-AU/library/bb383977.aspx ils sont tout à fait à portée de main.
InformationsquelleAutor Jason Larke
16

Essayer cette expression:
```
(n + 50) / 100 * 100
```
- C'est la réponse correcte. La question posée sur les entiers.
InformationsquelleAutor Marcelo Cantos
7

Juste quelques plus @krizzzn's accepté de répondre...

Ne remarque que le suivant sera de retour 0:
```
Math.Round(50d / 100d, 0) * 100;
```
Envisager d'utiliser la commande suivante et rendre retour à 100 au lieu de cela:
```
Math.Round(50d / 100d, 0, MidpointRounding.AwayFromZero) * 100;
```
En fonction de ce que vous êtes en train de faire, à l'aide de décimales peut être un meilleur choix (à noter la m):
```
Math.Round(50m / 100m, 0, MidpointRounding.AwayFromZero) * 100m;
```
InformationsquelleAutor Jim Aho

Je sais que c'est un vieux thread. J'ai écrit une nouvelle méthode. J'espère que ce sera utile pour certains une.

    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

InformationsquelleAutor Raghu

1

Salut je vous écris cette extension de cette fonction retourne la prochaine cents pour chaque numéro, 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;
    }
```
- Cet algorithme n'a pas fait ronde, mais elle cherche la valeur suivante où value % 100 == 0, par exemple, lorsque cette méthode est appelée avec i = 200, puis il retourne à 300.
- Et il ne fonctionne pas pour les valeurs négatives: lorsque cette méthode est appelée avec i = -4, puis il retourne 100, mais je m'attends à 0.
- c'est la droite qui est la prochaine centaine de 200 ? 300
- Ce n'est pas arrondi œuvres, quand j'ai déjà une valeur de 200, alors il ne doit pas être arrondi à 300 (parce que 200 est déjà une quantification de la valeur de l'arrondi à l'échelle). Si vous n'normale entier arrondissement, alors vous aussi vous ne s'attendrait pas à l'instruction suivante pour être vrai: les Maths.Cycle(1) == 2
- J'ai insérer le numéro du négatif , maintenant, si vous insérez un nombre négatif, il obtient le côté négatif de cent
- Gardez à l'esprit la méthode est appelée Ronde Cent pas RoundHundred. dans le second cas, vous avez raison, mais 300 est la PROCHAINE centaine de 200
- J'ai ajouté le RoundHundred fo feO2x
- Encore une fois, ce n'est pas comment l'arrondissement de travaux - même si le nom indique que votre méthode ne fonctionne pas comme prévu. L'OP clairement demandé une approximation de la solution à sa question.
- OP demandé pour la centaine près, pas à côté de cent. Par votre logique, ce n'est pas une réponse à la question.
- la dernière ligne est ce que vous voulez.
InformationsquelleAutor luka

int num = 9660;
int remainder = num % 100;
Console.WriteLine(remainder < 50 ? num - remainder : num + (100 -remainder));

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

InformationsquelleAutor shahkalpesh

Si vous ne voulez arrondir des nombres entiers (comme l'OP fait), alors 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 virgule flottante (ou virgule) arrondi, alors recourir à des réponses de @krizzzn et @Jim Aho.

InformationsquelleAutor feO2x

Vous devez vous connecter pour publier un commentaire.