Come arrotondare un numero intero a centinaia?

Non lo so, la mia nomenclatura è corretta! Ad ogni modo, questi sono i numeri interi che ho, ad esempio:

76 121 9660 

E mi piacerebbe arrotondarli al centinaio, come devono diventare:

 100 100 9700 

Come posso farlo più velocemente in C #? Penso ad un algoritmo, ma forse ci sono alcune utilità su C #?

Prova il metodo Math.Round . Ecco come:

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

Ho scritto un semplice metodo di estensione per generalizzare questo tipo di arrotondamento qualche tempo fa:

 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; } } 

Sfrutta la divisione intera per trovare l'arrotondamento più vicino.

Esempio di utilizzo:

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

E nel tuo esempio:

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

Prova questa espressione:

 (n + 50) / 100 * 100 

Solo qualche aggiunta alla risposta accettata di @krizzzn …

Si noti che quanto segue restituirà 0:

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

Prendi in considerazione l’utilizzo di quanto segue e rendilo invece 100:

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

A seconda di cosa stai facendo, usare i decimali potrebbe essere una scelta migliore (nota la m ):

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

So che questo è un vecchio thread. Ho scritto un nuovo metodo. Spero che questo sia utile per qualcuno.

  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); } } 

Esempio:

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

Ciao io scrivo questa estensione questo ottiene il prossimo centinaio per ogni numero che passi

 ///  /// this extension gets the next hunfìdred for any number you whant ///  /// numeber to rounded /// the next hundred number ///  /// eg.: /// i = 21 gets 100 /// i = 121 gets 200 /// i = 200 gets 300 /// i = 1211 gets 1300 /// i = -108 gets -200 ///  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 ///  /// this extension gets the close hundred for any number you whant ///  /// number to be rounded /// the close hundred number ///  /// eg.: /// number = 21 gets 0 /// number = 149 gets 100 /// number = 151 gets 200 /// number = -149 gets -100 /// number = -151 gets -200 ///  public static int RoundCloseHundred(this int number) { return (int)Math.Round(number / 100D) * 100; } 
 int num = 9660; int remainder = num % 100; Console.WriteLine(remainder < 50 ? num - remainder : num + (100 -remainder)); 

Nota: non l'ho provato a fondo

Se vuoi solo arrotondare i numeri interi (come effettivamente fatto l’OP), allora puoi ricorrere a questa soluzione:

 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; } } 

Se si desidera eseguire arrotondamenti a virgola mobile (o decimale), ricorrere alle risposte di @krizzzn e @Jim Aho.